@cartanova/qgrid-cli 2.7.0 → 2.7.2

package/bundle/dist/application/qgrid/schema-prompt.js

@@ -0,0 +1,240 @@
+//#region src/application/qgrid/schema-prompt.ts
+/**
+* system prompt 말미에 계약을 덧붙인다. anthropic 은 cold-only(매 턴 CC 재스폰 + system
+* 재전송)라 멀티턴에도 계약이 매 턴 일관되게 주입된다. system 이 argv 64KB 를 넘으면
+* claude-session 의 --system-prompt-file 분기가 흡수한다.
+*/
+function composeSystemWithSchemaContract(system, input) {
+	const contract = renderSchemaContractPrompt(input);
+	if (contract === void 0) return system;
+	return system ? `${system}\n\n${contract}` : contract;
+}
+/** 요청에 스키마/tools 가 없으면 undefined — 계약 주입 없이 평범한 텍스트 요청이다. */
+function renderSchemaContractPrompt(input) {
+	if (input.tools?.length) return renderToolEnvelopePrompt(input.tools, input.jsonSchema);
+	if (input.jsonSchema !== void 0) return renderOutputSchemaPrompt(input.jsonSchema);
+}
+function renderOutputSchemaPrompt(jsonSchema) {
+	return [
+		"## Output Format",
+		"",
+		"Your entire reply must be a single JSON object that conforms to the JSON Schema below.",
+		"Output raw JSON only — no code fences, no prose before or after the JSON.",
+		"Start your reply with { and end it with }.",
+		"",
+		"<output-json-schema>",
+		jsonSchema,
+		"</output-json-schema>"
+	].join("\n");
+}
+/**
+* envelope 예시 JSON. 렌더 문구와 parseEnvelope 계약의 드리프트를 교차 테스트로 잡기
+* 위해 분리 export 한다 — 예시가 실제 파서를 통과하지 못하면 안내문이 틀린 것이다.
+*
+* 예시는 스스로 계약을 지켜야 한다: args 는 첫 tool 의 inputSchema 를 실제로 만족하는
+* 인스턴스여야 한다. 생성기가 다루지 못하는 keyword(pattern/$ref/allOf 등)가 스키마에
+* 있으면 **fail-closed** — 위반 가능성이 있는 예시를 싣는 대신 예시 자체를 생략하고
+* 렌더러가 프로즈 서술로 대체한다 (`toolCallExample: undefined`).
+*/
+function buildEnvelopeExamples(tools) {
+	const firstTool = tools[0];
+	const args = firstTool ? exampleValueForSchema(firstTool.inputSchema) : {
+		ok: true,
+		value: {}
+	};
+	return {
+		...args.ok ? { toolCallExample: JSON.stringify({ result: {
+			action: "tool_call",
+			answer: null,
+			toolCalls: [{
+				toolName: firstTool?.name ?? "toolName",
+				args: JSON.stringify(args.value)
+			}]
+		} }) } : {},
+		textAnswerExample: JSON.stringify({ result: {
+			action: "answer",
+			answer: "your final answer",
+			toolCalls: null
+		} })
+	};
+}
+/** 생성기가 값 선택에 반영하는 keyword. 어노테이션(description 등)은 값과 무관해 무시한다. */
+const EXAMPLE_ANNOTATION_KEYWORDS = /* @__PURE__ */ new Set([
+	"description",
+	"title",
+	"default",
+	"examples",
+	"$comment",
+	"deprecated",
+	"readOnly",
+	"writeOnly"
+]);
+const EXAMPLE_HANDLED_KEYWORDS = /* @__PURE__ */ new Set([
+	"type",
+	"enum",
+	"const",
+	"properties",
+	"required",
+	"additionalProperties",
+	"items",
+	"minItems",
+	"maxItems",
+	"minLength",
+	"maxLength",
+	"minimum",
+	"maximum",
+	"exclusiveMinimum",
+	"exclusiveMaximum",
+	"anyOf",
+	"oneOf"
+]);
+/**
+* inputSchema 를 만족하는 예시 인스턴스 생성. 지원 keyword 집합 밖의 제약
+* (pattern/format/$ref/allOf/not/if/multipleOf/uniqueItems/...)을 만나면 값을
+* 지어내지 않고 { ok: false } 를 돌려준다 — 계약 위반 예시는 모델이 베낀다.
+*/
+function exampleValueForSchema(schema) {
+	if (schema === true || schema === void 0) return {
+		ok: true,
+		value: {}
+	};
+	if (schema === null || typeof schema !== "object" || Array.isArray(schema)) return { ok: false };
+	const node = schema;
+	for (const keyword of Object.keys(node)) if (!EXAMPLE_HANDLED_KEYWORDS.has(keyword) && !EXAMPLE_ANNOTATION_KEYWORDS.has(keyword)) return { ok: false };
+	if (Array.isArray(node.enum) && node.enum.length > 0) return {
+		ok: true,
+		value: node.enum[0]
+	};
+	if ("const" in node) return {
+		ok: true,
+		value: node.const
+	};
+	for (const kw of ["anyOf", "oneOf"]) if (Array.isArray(node[kw])) {
+		const list = node[kw];
+		if (kw === "oneOf" && list.length > 1) return { ok: false };
+		for (const branch of list) {
+			const result = exampleValueForSchema(branch);
+			if (result.ok) return result;
+		}
+		return { ok: false };
+	}
+	switch (Array.isArray(node.type) ? node.type[0] : node.type) {
+		case "string": {
+			const min = typeof node.minLength === "number" ? node.minLength : 0;
+			if (min > 64) return { ok: false };
+			const base = "example";
+			const value = 7 >= min ? base : base.padEnd(min, "x");
+			if (typeof node.maxLength === "number" && value.length > node.maxLength) {
+				if (node.maxLength < min) return { ok: false };
+				return {
+					ok: true,
+					value: value.slice(0, node.maxLength)
+				};
+			}
+			return {
+				ok: true,
+				value
+			};
+		}
+		case "number":
+		case "integer": {
+			let value = 0;
+			if (typeof node.minimum === "number") value = node.minimum;
+			else if (typeof node.exclusiveMinimum === "number") value = node.exclusiveMinimum + 1;
+			if (typeof node.maximum === "number" && value > node.maximum) return { ok: false };
+			if (typeof node.exclusiveMaximum === "number" && value >= node.exclusiveMaximum) return { ok: false };
+			return {
+				ok: true,
+				value
+			};
+		}
+		case "boolean": return {
+			ok: true,
+			value: false
+		};
+		case "null": return {
+			ok: true,
+			value: null
+		};
+		case "array": {
+			const min = typeof node.minItems === "number" ? node.minItems : 0;
+			if (min > 8) return { ok: false };
+			if (typeof node.maxItems === "number" && node.maxItems < min) return { ok: false };
+			if (min === 0) return {
+				ok: true,
+				value: []
+			};
+			const item = exampleValueForSchema(node.items);
+			if (!item.ok) return { ok: false };
+			return {
+				ok: true,
+				value: Array.from({ length: min }, () => item.value)
+			};
+		}
+		case void 0:
+		case "object": {
+			const properties = node.properties && typeof node.properties === "object" && !Array.isArray(node.properties) ? node.properties : {};
+			const required = Array.isArray(node.required) ? node.required.filter((k) => typeof k === "string") : [];
+			const entries = [];
+			for (const key of required) {
+				const child = exampleValueForSchema(properties[key]);
+				if (!child.ok) return { ok: false };
+				entries.push([key, child.value]);
+			}
+			return {
+				ok: true,
+				value: Object.fromEntries(entries)
+			};
+		}
+		default: return { ok: false };
+	}
+}
+function renderToolEnvelopePrompt(tools, jsonSchema) {
+	const { toolCallExample, textAnswerExample } = buildEnvelopeExamples(tools);
+	const toolList = tools.map((tool) => {
+		const description = tool.description ? ` — ${tool.description}` : "";
+		return `- ${tool.name}${description}\n  inputSchema: ${JSON.stringify(tool.inputSchema)}`;
+	}).join("\n");
+	const answerVariant = jsonSchema === void 0 ? [
+		"2. Final answer — use only when no further client tool result is needed:",
+		textAnswerExample,
+		"- \"toolCalls\" must be null.",
+		"- \"answer\" must be a plain string with your final answer (not null)."
+	] : [
+		"2. Final answer — use only when no further client tool result is needed:",
+		"- Set \"action\" to \"answer\" and \"toolCalls\" to null.",
+		"- \"answer\" must be a JSON value (not null, and not a string of JSON) that conforms to the JSON Schema below.",
+		"",
+		"<answer-json-schema>",
+		jsonSchema,
+		"</answer-json-schema>"
+	];
+	return [
+		"## Client Tool Protocol",
+		"",
+		"The client-side tools listed below are executed by the client, which returns each result",
+		"in a follow-up turn. Do not invoke them as native Claude Code tools.",
+		"",
+		"Your entire reply must be a single JSON object of the form {\"result\": ...} —",
+		"raw JSON only, no code fences, no prose before or after the JSON.",
+		"The \"result\" value is exactly one of the two variants:",
+		"",
+		...[
+			toolCallExample !== void 0 ? "1. Request client-side tool execution, for example:" : "1. Request client-side tool execution:",
+			...toolCallExample !== void 0 ? [toolCallExample] : ["- Set \"action\" to \"tool_call\" and \"answer\" to null.", "- \"toolCalls\" is an array of objects, each {\"toolName\": ..., \"args\": ...}."],
+			"- \"toolCalls\" must contain at least one entry.",
+			"- \"toolName\" must be one of the client tool names listed below.",
+			"- \"args\" must be the tool arguments encoded as a JSON string (not an object), conforming to that tool's inputSchema.",
+			"- \"answer\" must be null."
+		],
+		"",
+		...answerVariant,
+		"",
+		"Available client tools:",
+		toolList
+	].join("\n");
+}
+//#endregion
+export { buildEnvelopeExamples, composeSystemWithSchemaContract, renderOutputSchemaPrompt, renderSchemaContractPrompt, renderToolEnvelopePrompt };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"schema-prompt.js","names":[],"sources":["../../../src/application/qgrid/schema-prompt.ts"],"sourcesContent":["/**\n * output schema / tool envelope 계약의 프롬프트 렌더링 (SON-532).\n *\n * anthropic 경로는 CC 에 --json-schema 를 전달하지 않는다 — 강제 없는 사후 채점(AJV)이\n * 소비자 의도와 충돌해 내부 재시도 루프를 만들었기 때문. 대신 여기서 계약을 텍스트로\n * 렌더해 system prompt 말미에 주입하고, 판정은 소비자 zod(스키마) / parseEnvelope\n * (envelope, tool-emulation.ts)가 맡는다.\n *\n * 원칙:\n * - user 스키마는 수신 원형 그대로 안내한다 — strictify(전 필드 required 강제,\n *   additionalProperties:false)를 거치지 않아 소비자의 nullish/optional 의도가 보존된다.\n * - envelope 은 buildToolCallSchema(tool-emulation-schema.ts)처럼 user 스키마를 $defs 로\n *   합성하지 않는다. 텍스트 안내라 `$ref` 문서 루트 충돌이 없어 rebase 가 불필요하고,\n *   그 덕에 rebase 가 거절하던 형태(named anchor $ref 등)도 그대로 통과한다.\n * - 렌더된 계약은 parseEnvelope 의 zod 계약({\"result\": ...} 한 겹, 상호배타 변형)과\n *   정확히 일치해야 한다 — 교차 테스트(schema-prompt.test.ts)가 드리프트를 막는다.\n */\nimport { type QgridTool, type QueryInput } from \"./qgrid.types\";\n\n/**\n * system prompt 말미에 계약을 덧붙인다. anthropic 은 cold-only(매 턴 CC 재스폰 + system\n * 재전송)라 멀티턴에도 계약이 매 턴 일관되게 주입된다. system 이 argv 64KB 를 넘으면\n * claude-session 의 --system-prompt-file 분기가 흡수한다.\n */\nexport function composeSystemWithSchemaContract(\n  system: string | undefined,\n  input: Pick<QueryInput, \"tools\" | \"jsonSchema\">,\n): string | undefined {\n  const contract = renderSchemaContractPrompt(input);\n  if (contract === undefined) return system;\n  return system ? `${system}\\n\\n${contract}` : contract;\n}\n\n/** 요청에 스키마/tools 가 없으면 undefined — 계약 주입 없이 평범한 텍스트 요청이다. */\nexport function renderSchemaContractPrompt(\n  input: Pick<QueryInput, \"tools\" | \"jsonSchema\">,\n): string | undefined {\n  if (input.tools?.length) {\n    return renderToolEnvelopePrompt(input.tools, input.jsonSchema);\n  }\n  if (input.jsonSchema !== undefined) {\n    return renderOutputSchemaPrompt(input.jsonSchema);\n  }\n  return undefined;\n}\n\n// 1091748 실측(스키마 원문 + \"펜스·설명 없이 JSON 만\" 지시)에서 검증된 형식을 따른다.\nexport function renderOutputSchemaPrompt(jsonSchema: string): string {\n  return [\n    \"## Output Format\",\n    \"\",\n    \"Your entire reply must be a single JSON object that conforms to the JSON Schema below.\",\n    \"Output raw JSON only — no code fences, no prose before or after the JSON.\",\n    \"Start your reply with { and end it with }.\",\n    \"\",\n    \"<output-json-schema>\",\n    jsonSchema,\n    \"</output-json-schema>\",\n  ].join(\"\\n\");\n}\n\n/**\n * envelope 예시 JSON. 렌더 문구와 parseEnvelope 계약의 드리프트를 교차 테스트로 잡기\n * 위해 분리 export 한다 — 예시가 실제 파서를 통과하지 못하면 안내문이 틀린 것이다.\n *\n * 예시는 스스로 계약을 지켜야 한다: args 는 첫 tool 의 inputSchema 를 실제로 만족하는\n * 인스턴스여야 한다. 생성기가 다루지 못하는 keyword(pattern/$ref/allOf 등)가 스키마에\n * 있으면 **fail-closed** — 위반 가능성이 있는 예시를 싣는 대신 예시 자체를 생략하고\n * 렌더러가 프로즈 서술로 대체한다 (`toolCallExample: undefined`).\n */\nexport function buildEnvelopeExamples(tools: QgridTool[]): {\n  toolCallExample?: string;\n  textAnswerExample: string;\n} {\n  const firstTool = tools[0];\n  const args = firstTool ? exampleValueForSchema(firstTool.inputSchema) : { ok: true, value: {} };\n  return {\n    ...(args.ok\n      ? {\n          toolCallExample: JSON.stringify({\n            result: {\n              action: \"tool_call\",\n              answer: null,\n              toolCalls: [\n                { toolName: firstTool?.name ?? \"toolName\", args: JSON.stringify(args.value) },\n              ],\n            },\n          }),\n        }\n      : {}),\n    textAnswerExample: JSON.stringify({\n      result: { action: \"answer\", answer: \"your final answer\", toolCalls: null },\n    }),\n  };\n}\n\ntype ExampleResult = { ok: true; value: unknown } | { ok: false };\n\n/** 생성기가 값 선택에 반영하는 keyword. 어노테이션(description 등)은 값과 무관해 무시한다. */\nconst EXAMPLE_ANNOTATION_KEYWORDS = new Set([\n  \"description\",\n  \"title\",\n  \"default\",\n  \"examples\",\n  \"$comment\",\n  \"deprecated\",\n  \"readOnly\",\n  \"writeOnly\",\n]);\nconst EXAMPLE_HANDLED_KEYWORDS = new Set([\n  \"type\",\n  \"enum\",\n  \"const\",\n  \"properties\",\n  \"required\",\n  \"additionalProperties\",\n  \"items\",\n  \"minItems\",\n  \"maxItems\",\n  \"minLength\",\n  \"maxLength\",\n  \"minimum\",\n  \"maximum\",\n  \"exclusiveMinimum\",\n  \"exclusiveMaximum\",\n  \"anyOf\",\n  \"oneOf\",\n]);\n\n/**\n * inputSchema 를 만족하는 예시 인스턴스 생성. 지원 keyword 집합 밖의 제약\n * (pattern/format/$ref/allOf/not/if/multipleOf/uniqueItems/...)을 만나면 값을\n * 지어내지 않고 { ok: false } 를 돌려준다 — 계약 위반 예시는 모델이 베낀다.\n */\nfunction exampleValueForSchema(schema: unknown): ExampleResult {\n  if (schema === true || schema === undefined) return { ok: true, value: {} };\n  if (schema === null || typeof schema !== \"object\" || Array.isArray(schema)) return { ok: false };\n  const node = schema as Record<string, unknown>;\n\n  for (const keyword of Object.keys(node)) {\n    if (!EXAMPLE_HANDLED_KEYWORDS.has(keyword) && !EXAMPLE_ANNOTATION_KEYWORDS.has(keyword)) {\n      return { ok: false };\n    }\n  }\n\n  if (Array.isArray(node.enum) && node.enum.length > 0) return { ok: true, value: node.enum[0] };\n  if (\"const\" in node) return { ok: true, value: node.const };\n\n  for (const kw of [\"anyOf\", \"oneOf\"] as const) {\n    if (Array.isArray(node[kw])) {\n      // oneOf 는 \"정확히 하나\"라 첫 브랜치 값이 다른 브랜치에도 매칭될 수 있다 —\n      // 검증기 없이 확신할 수 없으므로 브랜치가 하나일 때만 생성한다.\n      const list = node[kw] as unknown[];\n      if (kw === \"oneOf\" && list.length > 1) return { ok: false };\n      for (const branch of list) {\n        const result = exampleValueForSchema(branch);\n        if (result.ok) return result;\n      }\n      return { ok: false };\n    }\n  }\n\n  const type = Array.isArray(node.type) ? node.type[0] : node.type;\n  switch (type) {\n    case \"string\": {\n      const min = typeof node.minLength === \"number\" ? node.minLength : 0;\n      if (min > 64) return { ok: false };\n      const base = \"example\";\n      const value = base.length >= min ? base : base.padEnd(min, \"x\");\n      if (typeof node.maxLength === \"number\" && value.length > node.maxLength) {\n        if (node.maxLength < min) return { ok: false };\n        return { ok: true, value: value.slice(0, node.maxLength) };\n      }\n      return { ok: true, value };\n    }\n    case \"number\":\n    case \"integer\": {\n      let value = 0;\n      if (typeof node.minimum === \"number\") value = node.minimum;\n      else if (typeof node.exclusiveMinimum === \"number\") value = node.exclusiveMinimum + 1;\n      if (typeof node.maximum === \"number\" && value > node.maximum) return { ok: false };\n      if (typeof node.exclusiveMaximum === \"number\" && value >= node.exclusiveMaximum) {\n        return { ok: false };\n      }\n      return { ok: true, value };\n    }\n    case \"boolean\":\n      return { ok: true, value: false };\n    case \"null\":\n      return { ok: true, value: null };\n    case \"array\": {\n      const min = typeof node.minItems === \"number\" ? node.minItems : 0;\n      if (min > 8) return { ok: false };\n      if (typeof node.maxItems === \"number\" && node.maxItems < min) return { ok: false };\n      if (min === 0) return { ok: true, value: [] };\n      const item = exampleValueForSchema(node.items);\n      if (!item.ok) return { ok: false };\n      // 같은 값 반복이라 uniqueItems 와 충돌하지만, uniqueItems 는 지원 집합 밖이라\n      // 위의 keyword 검사에서 이미 fail-closed 된다.\n      return { ok: true, value: Array.from({ length: min }, () => item.value) };\n    }\n    case undefined:\n    case \"object\": {\n      const properties =\n        node.properties && typeof node.properties === \"object\" && !Array.isArray(node.properties)\n          ? (node.properties as Record<string, unknown>)\n          : {};\n      const required = Array.isArray(node.required)\n        ? node.required.filter((k): k is string => typeof k === \"string\")\n        : [];\n      const entries: Array<[string, unknown]> = [];\n      for (const key of required) {\n        const child = exampleValueForSchema(properties[key]);\n        if (!child.ok) return { ok: false };\n        entries.push([key, child.value]);\n      }\n      return { ok: true, value: Object.fromEntries(entries) };\n    }\n    default:\n      return { ok: false };\n  }\n}\n\n// envelope 계약 문구는 buildToolCallSchema 의 description 들과 같은 표현을 쓴다\n// (\"Do not invoke ... as native Claude Code tools\" 등) — 모델이 structured/프롬프트\n// 어느 안내를 받아도 같은 규칙을 읽게 한다.\nexport function renderToolEnvelopePrompt(tools: QgridTool[], jsonSchema?: string): string {\n  const { toolCallExample, textAnswerExample } = buildEnvelopeExamples(tools);\n\n  const toolList = tools\n    .map((tool) => {\n      const description = tool.description ? ` — ${tool.description}` : \"\";\n      return `- ${tool.name}${description}\\n  inputSchema: ${JSON.stringify(tool.inputSchema)}`;\n    })\n    .join(\"\\n\");\n\n  // 예시가 raw-JSON-only 규칙을 스스로 어기면 안 된다: json answer 는 스키마 종속이라\n  // 유효한 리터럴 예시를 만들 수 없으므로 예시 없이 프로즈로만 서술한다 (자리표시자가\n  // 섞인 비 JSON 예시를 모델이 그대로 베끼는 것 방지).\n  const answerVariant =\n    jsonSchema === undefined\n      ? [\n          \"2. Final answer — use only when no further client tool result is needed:\",\n          textAnswerExample,\n          '- \"toolCalls\" must be null.',\n          '- \"answer\" must be a plain string with your final answer (not null).',\n        ]\n      : [\n          \"2. Final answer — use only when no further client tool result is needed:\",\n          '- Set \"action\" to \"answer\" and \"toolCalls\" to null.',\n          '- \"answer\" must be a JSON value (not null, and not a string of JSON) that conforms to the JSON Schema below.',\n          \"\",\n          \"<answer-json-schema>\",\n          jsonSchema,\n          \"</answer-json-schema>\",\n        ];\n\n  // 예시 생성기가 다루지 못하는 inputSchema(fail-closed)면 구조 서술로 대체한다 —\n  // 스키마를 위반할 수 있는 예시를 싣는 것보다 예시가 없는 편이 안전하다.\n  const toolCallVariant = [\n    toolCallExample !== undefined\n      ? \"1. Request client-side tool execution, for example:\"\n      : \"1. Request client-side tool execution:\",\n    ...(toolCallExample !== undefined\n      ? [toolCallExample]\n      : [\n          '- Set \"action\" to \"tool_call\" and \"answer\" to null.',\n          '- \"toolCalls\" is an array of objects, each {\"toolName\": ..., \"args\": ...}.',\n        ]),\n    '- \"toolCalls\" must contain at least one entry.',\n    '- \"toolName\" must be one of the client tool names listed below.',\n    '- \"args\" must be the tool arguments encoded as a JSON string (not an object), conforming to that tool\\'s inputSchema.',\n    '- \"answer\" must be null.',\n  ];\n\n  return [\n    \"## Client Tool Protocol\",\n    \"\",\n    \"The client-side tools listed below are executed by the client, which returns each result\",\n    \"in a follow-up turn. Do not invoke them as native Claude Code tools.\",\n    \"\",\n    'Your entire reply must be a single JSON object of the form {\"result\": ...} —',\n    \"raw JSON only, no code fences, no prose before or after the JSON.\",\n    'The \"result\" value is exactly one of the two variants:',\n    \"\",\n    ...toolCallVariant,\n    \"\",\n    ...answerVariant,\n    \"\",\n    \"Available client tools:\",\n    toolList,\n  ].join(\"\\n\");\n}\n"],"mappings":"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"}

package/bundle/dist/application/qgrid/token-subscriber.js

@@ -130,7 +130,7 @@ var TokenSubscriber = class {
 		const payload = JSON.parse(payloadJson);
 		if (payload.op === "DELETE") {
 			this.dispatcher.removeCache(payload.id);
-			await this.dispatcher.openaiDispatcher?.onTokenRemoved(payload.id).catch((e) => logger.warn(`openai worker remove failed: ${e.message}`));
+			await this.dispatcher.openaiDispatcher?.onTokenRemoved(payload.id).catch((e) => logger.warn(`openai token remove failed: ${e.message}`));
 			this.dispatcher.anthropicDispatcher?.onTokenRemoved(payload.id);
 			logger.info(`NOTIFY ${payload.op} id=${payload.id} → removed from cache`);
 			return;
@@ -138,7 +138,7 @@ var TokenSubscriber = class {
 		const row = await TokenModel.findOne("A", { id: payload.id });
 		if (!row) {
 			this.dispatcher.removeCache(payload.id);
-			await this.dispatcher.openaiDispatcher?.onTokenRemoved(payload.id).catch((e) => logger.warn(`openai worker remove failed: ${e.message}`));
+			await this.dispatcher.openaiDispatcher?.onTokenRemoved(payload.id).catch((e) => logger.warn(`openai token remove failed: ${e.message}`));
 			this.dispatcher.anthropicDispatcher?.onTokenRemoved(payload.id);
 			logger.info(`NOTIFY ${payload.op} id=${payload.id} → missing, removed from cache`);
 			return;
@@ -147,9 +147,9 @@ var TokenSubscriber = class {
 		if (row.provider === "openai") {
 			const creds = row.credentials;
 			const openaiDispatcher = this.dispatcher.openaiDispatcher;
-			if (payload.op === "INSERT" && row.active) await openaiDispatcher?.onTokenAdded(payload.id, row.name, creds, row.quota_threshold, row.weight).catch((e) => logger.warn(`openai worker spawn failed: ${e.message}`));
+			if (payload.op === "INSERT" && row.active) await openaiDispatcher?.onTokenAdded(payload.id, row.name, creds, row.quota_threshold, row.weight).catch((e) => logger.warn(`openai token add failed: ${e.message}`));
 			else if (row.active) {
-				if (openaiDispatcher) await openaiDispatcher.onTokenUpdated(payload.id, row.name, creds, row.quota_threshold, row.weight).then(() => openaiDispatcher.onTokenActivated(payload.id)).catch((e) => logger.warn(`openai worker update failed: ${e.message}`));
+				if (openaiDispatcher) await openaiDispatcher.onTokenUpdated(payload.id, row.name, creds, row.quota_threshold, row.weight).then(() => openaiDispatcher.onTokenActivated(payload.id)).catch((e) => logger.warn(`openai token update failed: ${e.message}`));
 			} else openaiDispatcher?.onTokenDeactivated(payload.id);
 		} else if (row.provider === "anthropic") {
 			const creds = row.credentials;
@@ -192,4 +192,4 @@ var TokenSubscriber = class {
 //#endregion
 export { TokenSubscriber };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"token-subscriber.js","names":[],"sources":["../../../src/application/qgrid/token-subscriber.ts"],"sourcesContent":["/** tokens_changed LISTEN subscriber. */\nimport { getLogger } from \"@logtape/logtape\";\nimport { Client, type ClientConfig } from \"pg\";\n\nimport { TokenModel } from \"../token/token.model\";\nimport { type AnthropicCredentials, type OpenAICredentials } from \"../token/token.types\";\nimport { type QgridDispatcherClass } from \"./qgrid.dispatcher\";\nimport { type SubscriberStatus } from \"./qgrid.types\";\n\nconst logger = getLogger([\"qgrid\", \"subscriber\"]);\n\nconst TOKENS_CHANGED = \"tokens_changed\";\nconst RECONCILE_INTERVAL_MS = 10 * 60 * 1000;\nconst CONNECTION_TIMEOUT_MS = 5_000;\nconst BACKOFF_BASE_MS = 500;\nconst BACKOFF_CAP_MS = 30_000;\n\ntype Payload = { op: \"INSERT\" | \"UPDATE\" | \"DELETE\"; id: number };\n\nexport class TokenSubscriber {\n  client: Client | null = null;\n  reconcileTimer: NodeJS.Timeout | null = null;\n  reconnectTimer: NodeJS.Timeout | null = null;\n  shutdownRequested = false;\n  attempt = 0;\n  connectedAt: Date | null = null;\n  lastReconcileAt: Date | null = null;\n  private operationChain: Promise<void> = Promise.resolve();\n\n  constructor(\n    public connConfig: ClientConfig,\n    public dispatcher: QgridDispatcherClass,\n  ) {}\n\n  async start(): Promise<boolean> {\n    this.shutdownRequested = false;\n    this.ensureReconcileTimer();\n\n    try {\n      await this.connectAndReconcile();\n      return true;\n    } catch (e) {\n      logger.warn(`subscriber start failed: ${(e as Error).message}, scheduling retry`);\n      this.retryLater();\n      return false;\n    }\n  }\n\n  async stop(): Promise<void> {\n    this.shutdownRequested = true;\n    if (this.reconcileTimer) {\n      clearInterval(this.reconcileTimer);\n      this.reconcileTimer = null;\n    }\n    if (this.reconnectTimer) {\n      clearTimeout(this.reconnectTimer);\n      this.reconnectTimer = null;\n    }\n    await this.closeClient();\n  }\n\n  status(): SubscriberStatus {\n    return {\n      connected: this.client !== null && this.reconnectTimer === null,\n      connectedAt: this.connectedAt,\n      lastReconcileAt: this.lastReconcileAt,\n      attempt: this.attempt,\n    };\n  }\n\n  ensureReconcileTimer(): void {\n    if (this.reconcileTimer) return;\n\n    // LISTEN/NOTIFY 는 끊긴 동안 유실될 수 있어 주기적으로 DB 기준으로 맞춘다.\n    this.reconcileTimer = setInterval(() => {\n      this.reconcile().catch((e) =>\n        logger.warn(`periodic reconcile failed: ${(e as Error).message}`),\n      );\n    }, RECONCILE_INTERVAL_MS);\n  }\n\n  async connectAndReconcile(): Promise<void> {\n    await this.connectAndListen();\n    await this.reconcile();\n    this.attempt = 0;\n  }\n\n  async connectAndListen(): Promise<void> {\n    const client = new Client({\n      ...this.connConfig,\n      connectionTimeoutMillis: CONNECTION_TIMEOUT_MS,\n      keepAlive: true,\n      keepAliveInitialDelayMillis: 10_000,\n      application_name: \"qgrid-listener\",\n    });\n\n    client.on(\"error\", (e) => {\n      logger.warn(`subscriber error: ${e.message}`);\n      this.retryLater();\n    });\n    client.on(\"end\", () => {\n      if (!this.shutdownRequested) this.retryLater();\n    });\n    client.on(\"notification\", (msg) => {\n      if (msg.channel !== TOKENS_CHANGED || !msg.payload) return;\n      this.handleNotification(msg.payload).catch((e) =>\n        logger.warn(`handle NOTIFY failed: ${(e as Error).message}`),\n      );\n    });\n\n    try {\n      await client.connect();\n      await client.query(\"SET statement_timeout = 0\");\n      await client.query(\"SET idle_in_transaction_session_timeout = 0\");\n      await client.query(`LISTEN ${client.escapeIdentifier(TOKENS_CHANGED)}`);\n    } catch (e) {\n      client.removeAllListeners();\n      await client.end().catch(() => {});\n      throw e;\n    }\n\n    this.client = client;\n    this.connectedAt = new Date();\n    logger.info(`subscribed to ${TOKENS_CHANGED}`);\n  }\n\n  retryLater(): void {\n    if (this.shutdownRequested) return;\n    if (this.reconnectTimer) return;\n\n    void this.closeClient();\n    this.attempt += 1;\n    const cap = Math.min(BACKOFF_BASE_MS * 2 ** this.attempt, BACKOFF_CAP_MS);\n    const delay = Math.floor(Math.random() * cap);\n    logger.info(`reconnecting in ${delay}ms (attempt ${this.attempt})`);\n    this.reconnectTimer = setTimeout(() => {\n      this.reconnectTimer = null;\n      this.connectAndReconcile().catch((e) => {\n        logger.warn(`subscriber reconnect failed: ${(e as Error).message}`);\n        this.retryLater();\n      });\n    }, delay);\n  }\n\n  async closeClient(): Promise<void> {\n    const client = this.client;\n    if (!client) return;\n\n    this.client = null;\n    client.removeAllListeners();\n    await client.end().catch(() => {});\n  }\n\n  async handleNotification(payloadJson: string): Promise<void> {\n    return this.enqueueOperation(() => this.handleNotificationNow(payloadJson));\n  }\n\n  private async handleNotificationNow(payloadJson: string): Promise<void> {\n    const payload = JSON.parse(payloadJson) as Payload;\n    if (payload.op === \"DELETE\") {\n      this.dispatcher.removeCache(payload.id);\n      await this.dispatcher.openaiDispatcher\n        ?.onTokenRemoved(payload.id)\n        .catch((e) => logger.warn(`openai worker remove failed: ${(e as Error).message}`));\n      // anthropic 토큰 이벤트는 동기(void) — provider 를 모르므로 무해하게 항상 제거 시도.\n      this.dispatcher.anthropicDispatcher?.onTokenRemoved(payload.id);\n      logger.info(`NOTIFY ${payload.op} id=${payload.id} → removed from cache`);\n      return;\n    }\n    const row = await TokenModel.findOne(\"A\", { id: payload.id });\n    if (!row) {\n      this.dispatcher.removeCache(payload.id);\n      await this.dispatcher.openaiDispatcher\n        ?.onTokenRemoved(payload.id)\n        .catch((e) => logger.warn(`openai worker remove failed: ${(e as Error).message}`));\n      this.dispatcher.anthropicDispatcher?.onTokenRemoved(payload.id);\n      logger.info(`NOTIFY ${payload.op} id=${payload.id} → missing, removed from cache`);\n      return;\n    }\n\n    this.dispatcher.upsertCache(payload.id, row);\n\n    if (row.provider === \"openai\") {\n      const creds = row.credentials as Record<string, unknown>;\n      const openaiDispatcher = this.dispatcher.openaiDispatcher;\n      if (payload.op === \"INSERT\" && row.active) {\n        await openaiDispatcher\n          ?.onTokenAdded(\n            payload.id,\n            row.name,\n            creds as OpenAICredentials,\n            row.quota_threshold,\n            row.weight,\n          )\n          .catch((e) => logger.warn(`openai worker spawn failed: ${(e as Error).message}`));\n      } else if (row.active) {\n        if (openaiDispatcher) {\n          await openaiDispatcher\n            .onTokenUpdated(\n              payload.id,\n              row.name,\n              creds as OpenAICredentials,\n              row.quota_threshold,\n              row.weight,\n            )\n            .then(() => openaiDispatcher.onTokenActivated(payload.id))\n            .catch((e) => logger.warn(`openai worker update failed: ${(e as Error).message}`));\n        }\n      } else {\n        openaiDispatcher?.onTokenDeactivated(payload.id);\n      }\n    } else if (row.provider === \"anthropic\") {\n      // anthropic 토큰 이벤트는 동기(void). worker 가 없고 풀(Map)만 관리하므로 단순:\n      //  INSERT → 추가, active 면 갱신(onTokenUpdated 가 identity 변경도 처리), inactive 면 풀에서 제거.\n      //  (별도 activate/deactivate 콜백이 없어 active 토글을 add/remove 로 매핑.)\n      const creds = row.credentials as AnthropicCredentials;\n      if (payload.op === \"INSERT\" && row.active) {\n        this.dispatcher.anthropicDispatcher?.onTokenAdded(\n          payload.id,\n          row.name,\n          creds,\n          row.quota_threshold,\n          row.weight,\n        );\n      } else if (row.active) {\n        this.dispatcher.anthropicDispatcher?.onTokenUpdated(\n          payload.id,\n          row.name,\n          creds,\n          row.quota_threshold,\n          row.weight,\n        );\n      } else {\n        // inactive 면 INSERT 든 UPDATE 든 풀에 넣지 않는다.\n        this.dispatcher.anthropicDispatcher?.onTokenRemoved(payload.id);\n      }\n    }\n    logger.info(`NOTIFY ${payload.op} id=${payload.id} (${row.name}) active=${row.active}`);\n  }\n\n  async reconcile(): Promise<void> {\n    return this.enqueueOperation(() => this.reconcileNow());\n  }\n\n  private async reconcileNow(): Promise<void> {\n    const rows = await TokenModel.findActive(\"A\");\n    this.dispatcher.replaceCache(rows);\n    // NOTIFY 유실 대비: AnthropicDispatcher 풀도 DB active anthropic 토큰 기준으로 재동기화.\n    // (rows 는 active 만 — inactive/삭제된 토큰은 여기 없으므로 replaceTokens 가 풀에서 제거한다.)\n    const anthropicRows = rows\n      .filter((r) => r.provider === \"anthropic\")\n      .map((r) => ({\n        id: r.id,\n        name: r.name,\n        credentials: r.credentials as AnthropicCredentials,\n        quotaThreshold: r.quota_threshold,\n        weight: r.weight,\n      }));\n    this.dispatcher.anthropicDispatcher?.replaceTokens(anthropicRows);\n    const openaiRows = rows\n      .filter((r) => r.provider === \"openai\")\n      .map((r) => ({\n        id: r.id,\n        name: r.name,\n        credentials: r.credentials as OpenAICredentials,\n        quotaThreshold: r.quota_threshold,\n        weight: r.weight,\n      }));\n    await this.dispatcher.openaiDispatcher\n      ?.replaceTokens(openaiRows)\n      .catch((e) => logger.warn(`openai reconcile failed: ${(e as Error).message}`));\n    this.lastReconcileAt = new Date();\n  }\n\n  private enqueueOperation(operation: () => Promise<void>): Promise<void> {\n    const next = this.operationChain.then(operation, operation);\n    this.operationChain = next.catch(() => {});\n    return next;\n  }\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"token-subscriber.js","names":[],"sources":["../../../src/application/qgrid/token-subscriber.ts"],"sourcesContent":["/** tokens_changed LISTEN subscriber. */\nimport { getLogger } from \"@logtape/logtape\";\nimport { Client, type ClientConfig } from \"pg\";\n\nimport { TokenModel } from \"../token/token.model\";\nimport { type AnthropicCredentials, type OpenAICredentials } from \"../token/token.types\";\nimport { type QgridDispatcherClass } from \"./qgrid.dispatcher\";\nimport { type SubscriberStatus } from \"./qgrid.types\";\n\nconst logger = getLogger([\"qgrid\", \"subscriber\"]);\n\nconst TOKENS_CHANGED = \"tokens_changed\";\nconst RECONCILE_INTERVAL_MS = 10 * 60 * 1000;\nconst CONNECTION_TIMEOUT_MS = 5_000;\nconst BACKOFF_BASE_MS = 500;\nconst BACKOFF_CAP_MS = 30_000;\n\ntype Payload = { op: \"INSERT\" | \"UPDATE\" | \"DELETE\"; id: number };\n\nexport class TokenSubscriber {\n  client: Client | null = null;\n  reconcileTimer: NodeJS.Timeout | null = null;\n  reconnectTimer: NodeJS.Timeout | null = null;\n  shutdownRequested = false;\n  attempt = 0;\n  connectedAt: Date | null = null;\n  lastReconcileAt: Date | null = null;\n  private operationChain: Promise<void> = Promise.resolve();\n\n  constructor(\n    public connConfig: ClientConfig,\n    public dispatcher: QgridDispatcherClass,\n  ) {}\n\n  async start(): Promise<boolean> {\n    this.shutdownRequested = false;\n    this.ensureReconcileTimer();\n\n    try {\n      await this.connectAndReconcile();\n      return true;\n    } catch (e) {\n      logger.warn(`subscriber start failed: ${(e as Error).message}, scheduling retry`);\n      this.retryLater();\n      return false;\n    }\n  }\n\n  async stop(): Promise<void> {\n    this.shutdownRequested = true;\n    if (this.reconcileTimer) {\n      clearInterval(this.reconcileTimer);\n      this.reconcileTimer = null;\n    }\n    if (this.reconnectTimer) {\n      clearTimeout(this.reconnectTimer);\n      this.reconnectTimer = null;\n    }\n    await this.closeClient();\n  }\n\n  status(): SubscriberStatus {\n    return {\n      connected: this.client !== null && this.reconnectTimer === null,\n      connectedAt: this.connectedAt,\n      lastReconcileAt: this.lastReconcileAt,\n      attempt: this.attempt,\n    };\n  }\n\n  ensureReconcileTimer(): void {\n    if (this.reconcileTimer) return;\n\n    // LISTEN/NOTIFY 는 끊긴 동안 유실될 수 있어 주기적으로 DB 기준으로 맞춘다.\n    this.reconcileTimer = setInterval(() => {\n      this.reconcile().catch((e) =>\n        logger.warn(`periodic reconcile failed: ${(e as Error).message}`),\n      );\n    }, RECONCILE_INTERVAL_MS);\n  }\n\n  async connectAndReconcile(): Promise<void> {\n    await this.connectAndListen();\n    await this.reconcile();\n    this.attempt = 0;\n  }\n\n  async connectAndListen(): Promise<void> {\n    const client = new Client({\n      ...this.connConfig,\n      connectionTimeoutMillis: CONNECTION_TIMEOUT_MS,\n      keepAlive: true,\n      keepAliveInitialDelayMillis: 10_000,\n      application_name: \"qgrid-listener\",\n    });\n\n    client.on(\"error\", (e) => {\n      logger.warn(`subscriber error: ${e.message}`);\n      this.retryLater();\n    });\n    client.on(\"end\", () => {\n      if (!this.shutdownRequested) this.retryLater();\n    });\n    client.on(\"notification\", (msg) => {\n      if (msg.channel !== TOKENS_CHANGED || !msg.payload) return;\n      this.handleNotification(msg.payload).catch((e) =>\n        logger.warn(`handle NOTIFY failed: ${(e as Error).message}`),\n      );\n    });\n\n    try {\n      await client.connect();\n      await client.query(\"SET statement_timeout = 0\");\n      await client.query(\"SET idle_in_transaction_session_timeout = 0\");\n      await client.query(`LISTEN ${client.escapeIdentifier(TOKENS_CHANGED)}`);\n    } catch (e) {\n      client.removeAllListeners();\n      await client.end().catch(() => {});\n      throw e;\n    }\n\n    this.client = client;\n    this.connectedAt = new Date();\n    logger.info(`subscribed to ${TOKENS_CHANGED}`);\n  }\n\n  retryLater(): void {\n    if (this.shutdownRequested) return;\n    if (this.reconnectTimer) return;\n\n    void this.closeClient();\n    this.attempt += 1;\n    const cap = Math.min(BACKOFF_BASE_MS * 2 ** this.attempt, BACKOFF_CAP_MS);\n    const delay = Math.floor(Math.random() * cap);\n    logger.info(`reconnecting in ${delay}ms (attempt ${this.attempt})`);\n    this.reconnectTimer = setTimeout(() => {\n      this.reconnectTimer = null;\n      this.connectAndReconcile().catch((e) => {\n        logger.warn(`subscriber reconnect failed: ${(e as Error).message}`);\n        this.retryLater();\n      });\n    }, delay);\n  }\n\n  async closeClient(): Promise<void> {\n    const client = this.client;\n    if (!client) return;\n\n    this.client = null;\n    client.removeAllListeners();\n    await client.end().catch(() => {});\n  }\n\n  async handleNotification(payloadJson: string): Promise<void> {\n    return this.enqueueOperation(() => this.handleNotificationNow(payloadJson));\n  }\n\n  private async handleNotificationNow(payloadJson: string): Promise<void> {\n    const payload = JSON.parse(payloadJson) as Payload;\n    if (payload.op === \"DELETE\") {\n      this.dispatcher.removeCache(payload.id);\n      await this.dispatcher.openaiDispatcher\n        ?.onTokenRemoved(payload.id)\n        .catch((e) => logger.warn(`openai token remove failed: ${(e as Error).message}`));\n      // anthropic 토큰 이벤트는 동기(void) — provider 를 모르므로 무해하게 항상 제거 시도.\n      this.dispatcher.anthropicDispatcher?.onTokenRemoved(payload.id);\n      logger.info(`NOTIFY ${payload.op} id=${payload.id} → removed from cache`);\n      return;\n    }\n    const row = await TokenModel.findOne(\"A\", { id: payload.id });\n    if (!row) {\n      this.dispatcher.removeCache(payload.id);\n      await this.dispatcher.openaiDispatcher\n        ?.onTokenRemoved(payload.id)\n        .catch((e) => logger.warn(`openai token remove failed: ${(e as Error).message}`));\n      this.dispatcher.anthropicDispatcher?.onTokenRemoved(payload.id);\n      logger.info(`NOTIFY ${payload.op} id=${payload.id} → missing, removed from cache`);\n      return;\n    }\n\n    this.dispatcher.upsertCache(payload.id, row);\n\n    if (row.provider === \"openai\") {\n      const creds = row.credentials as Record<string, unknown>;\n      const openaiDispatcher = this.dispatcher.openaiDispatcher;\n      if (payload.op === \"INSERT\" && row.active) {\n        await openaiDispatcher\n          ?.onTokenAdded(\n            payload.id,\n            row.name,\n            creds as OpenAICredentials,\n            row.quota_threshold,\n            row.weight,\n          )\n          .catch((e) => logger.warn(`openai token add failed: ${(e as Error).message}`));\n      } else if (row.active) {\n        if (openaiDispatcher) {\n          await openaiDispatcher\n            .onTokenUpdated(\n              payload.id,\n              row.name,\n              creds as OpenAICredentials,\n              row.quota_threshold,\n              row.weight,\n            )\n            .then(() => openaiDispatcher.onTokenActivated(payload.id))\n            .catch((e) => logger.warn(`openai token update failed: ${(e as Error).message}`));\n        }\n      } else {\n        openaiDispatcher?.onTokenDeactivated(payload.id);\n      }\n    } else if (row.provider === \"anthropic\") {\n      // anthropic 토큰 이벤트는 동기(void). worker 가 없고 풀(Map)만 관리하므로 단순:\n      //  INSERT → 추가, active 면 갱신(onTokenUpdated 가 identity 변경도 처리), inactive 면 풀에서 제거.\n      //  (별도 activate/deactivate 콜백이 없어 active 토글을 add/remove 로 매핑.)\n      const creds = row.credentials as AnthropicCredentials;\n      if (payload.op === \"INSERT\" && row.active) {\n        this.dispatcher.anthropicDispatcher?.onTokenAdded(\n          payload.id,\n          row.name,\n          creds,\n          row.quota_threshold,\n          row.weight,\n        );\n      } else if (row.active) {\n        this.dispatcher.anthropicDispatcher?.onTokenUpdated(\n          payload.id,\n          row.name,\n          creds,\n          row.quota_threshold,\n          row.weight,\n        );\n      } else {\n        // inactive 면 INSERT 든 UPDATE 든 풀에 넣지 않는다.\n        this.dispatcher.anthropicDispatcher?.onTokenRemoved(payload.id);\n      }\n    }\n    logger.info(`NOTIFY ${payload.op} id=${payload.id} (${row.name}) active=${row.active}`);\n  }\n\n  async reconcile(): Promise<void> {\n    return this.enqueueOperation(() => this.reconcileNow());\n  }\n\n  private async reconcileNow(): Promise<void> {\n    const rows = await TokenModel.findActive(\"A\");\n    this.dispatcher.replaceCache(rows);\n    // NOTIFY 유실 대비: AnthropicDispatcher 풀도 DB active anthropic 토큰 기준으로 재동기화.\n    // (rows 는 active 만 — inactive/삭제된 토큰은 여기 없으므로 replaceTokens 가 풀에서 제거한다.)\n    const anthropicRows = rows\n      .filter((r) => r.provider === \"anthropic\")\n      .map((r) => ({\n        id: r.id,\n        name: r.name,\n        credentials: r.credentials as AnthropicCredentials,\n        quotaThreshold: r.quota_threshold,\n        weight: r.weight,\n      }));\n    this.dispatcher.anthropicDispatcher?.replaceTokens(anthropicRows);\n    const openaiRows = rows\n      .filter((r) => r.provider === \"openai\")\n      .map((r) => ({\n        id: r.id,\n        name: r.name,\n        credentials: r.credentials as OpenAICredentials,\n        quotaThreshold: r.quota_threshold,\n        weight: r.weight,\n      }));\n    await this.dispatcher.openaiDispatcher\n      ?.replaceTokens(openaiRows)\n      .catch((e) => logger.warn(`openai reconcile failed: ${(e as Error).message}`));\n    this.lastReconcileAt = new Date();\n  }\n\n  private enqueueOperation(operation: () => Promise<void>): Promise<void> {\n    const next = this.operationChain.then(operation, operation);\n    this.operationChain = next.catch(() => {});\n    return next;\n  }\n}\n"],"mappings":";;;;;AASA,MAAM,SAAS,UAAU,CAAC,SAAS,YAAY,CAAC;AAEhD,MAAM,iBAAiB;AACvB,MAAM,wBAAwB,MAAU;AACxC,MAAM,wBAAwB;AAC9B,MAAM,kBAAkB;AACxB,MAAM,iBAAiB;AAIvB,IAAa,kBAAb,MAA6B;CAWlB;CACA;CAXT,SAAwB;CACxB,iBAAwC;CACxC,iBAAwC;CACxC,oBAAoB;CACpB,UAAU;CACV,cAA2B;CAC3B,kBAA+B;CAC/B,iBAAwC,QAAQ,QAAQ;CAExD,YACE,YACA,YACA;EAFO,KAAA,aAAA;EACA,KAAA,aAAA;CACN;CAEH,MAAM,QAA0B;EAC9B,KAAK,oBAAoB;EACzB,KAAK,qBAAqB;EAE1B,IAAI;GACF,MAAM,KAAK,oBAAoB;GAC/B,OAAO;EACT,SAAS,GAAG;GACV,OAAO,KAAK,4BAA6B,EAAY,QAAQ,mBAAmB;GAChF,KAAK,WAAW;GAChB,OAAO;EACT;CACF;CAEA,MAAM,OAAsB;EAC1B,KAAK,oBAAoB;EACzB,IAAI,KAAK,gBAAgB;GACvB,cAAc,KAAK,cAAc;GACjC,KAAK,iBAAiB;EACxB;EACA,IAAI,KAAK,gBAAgB;GACvB,aAAa,KAAK,cAAc;GAChC,KAAK,iBAAiB;EACxB;EACA,MAAM,KAAK,YAAY;CACzB;CAEA,SAA2B;EACzB,OAAO;GACL,WAAW,KAAK,WAAW,QAAQ,KAAK,mBAAmB;GAC3D,aAAa,KAAK;GAClB,iBAAiB,KAAK;GACtB,SAAS,KAAK;EAChB;CACF;CAEA,uBAA6B;EAC3B,IAAI,KAAK,gBAAgB;EAGzB,KAAK,iBAAiB,kBAAkB;GACtC,KAAK,UAAU,CAAC,CAAC,OAAO,MACtB,OAAO,KAAK,8BAA+B,EAAY,SAAS,CAClE;EACF,GAAG,qBAAqB;CAC1B;CAEA,MAAM,sBAAqC;EACzC,MAAM,KAAK,iBAAiB;EAC5B,MAAM,KAAK,UAAU;EACrB,KAAK,UAAU;CACjB;CAEA,MAAM,mBAAkC;EACtC,MAAM,SAAS,IAAI,OAAO;GACxB,GAAG,KAAK;GACR,yBAAyB;GACzB,WAAW;GACX,6BAA6B;GAC7B,kBAAkB;EACpB,CAAC;EAED,OAAO,GAAG,UAAU,MAAM;GACxB,OAAO,KAAK,qBAAqB,EAAE,SAAS;GAC5C,KAAK,WAAW;EAClB,CAAC;EACD,OAAO,GAAG,aAAa;GACrB,IAAI,CAAC,KAAK,mBAAmB,KAAK,WAAW;EAC/C,CAAC;EACD,OAAO,GAAG,iBAAiB,QAAQ;GACjC,IAAI,IAAI,YAAY,kBAAkB,CAAC,IAAI,SAAS;GACpD,KAAK,mBAAmB,IAAI,OAAO,CAAC,CAAC,OAAO,MAC1C,OAAO,KAAK,yBAA0B,EAAY,SAAS,CAC7D;EACF,CAAC;EAED,IAAI;GACF,MAAM,OAAO,QAAQ;GACrB,MAAM,OAAO,MAAM,2BAA2B;GAC9C,MAAM,OAAO,MAAM,6CAA6C;GAChE,MAAM,OAAO,MAAM,UAAU,OAAO,iBAAiB,cAAc,GAAG;EACxE,SAAS,GAAG;GACV,OAAO,mBAAmB;GAC1B,MAAM,OAAO,IAAI,CAAC,CAAC,YAAY,CAAC,CAAC;GACjC,MAAM;EACR;EAEA,KAAK,SAAS;EACd,KAAK,8BAAc,IAAI,KAAK;EAC5B,OAAO,KAAK,iBAAiB,gBAAgB;CAC/C;CAEA,aAAmB;EACjB,IAAI,KAAK,mBAAmB;EAC5B,IAAI,KAAK,gBAAgB;EAEzB,AAAK,KAAK,YAAY;EACtB,KAAK,WAAW;EAChB,MAAM,MAAM,KAAK,IAAI,kBAAkB,KAAK,KAAK,SAAS,cAAc;EACxE,MAAM,QAAQ,KAAK,MAAM,KAAK,OAAO,IAAI,GAAG;EAC5C,OAAO,KAAK,mBAAmB,MAAM,cAAc,KAAK,QAAQ,EAAE;EAClE,KAAK,iBAAiB,iBAAiB;GACrC,KAAK,iBAAiB;GACtB,KAAK,oBAAoB,CAAC,CAAC,OAAO,MAAM;IACtC,OAAO,KAAK,gCAAiC,EAAY,SAAS;IAClE,KAAK,WAAW;GAClB,CAAC;EACH,GAAG,KAAK;CACV;CAEA,MAAM,cAA6B;EACjC,MAAM,SAAS,KAAK;EACpB,IAAI,CAAC,QAAQ;EAEb,KAAK,SAAS;EACd,OAAO,mBAAmB;EAC1B,MAAM,OAAO,IAAI,CAAC,CAAC,YAAY,CAAC,CAAC;CACnC;CAEA,MAAM,mBAAmB,aAAoC;EAC3D,OAAO,KAAK,uBAAuB,KAAK,sBAAsB,WAAW,CAAC;CAC5E;CAEA,MAAc,sBAAsB,aAAoC;EACtE,MAAM,UAAU,KAAK,MAAM,WAAW;EACtC,IAAI,QAAQ,OAAO,UAAU;GAC3B,KAAK,WAAW,YAAY,QAAQ,EAAE;GACtC,MAAM,KAAK,WAAW,kBAClB,eAAe,QAAQ,EAAE,CAAC,CAC3B,OAAO,MAAM,OAAO,KAAK,+BAAgC,EAAY,SAAS,CAAC;GAElF,KAAK,WAAW,qBAAqB,eAAe,QAAQ,EAAE;GAC9D,OAAO,KAAK,UAAU,QAAQ,GAAG,MAAM,QAAQ,GAAG,sBAAsB;GACxE;EACF;EACA,MAAM,MAAM,MAAM,WAAW,QAAQ,KAAK,EAAE,IAAI,QAAQ,GAAG,CAAC;EAC5D,IAAI,CAAC,KAAK;GACR,KAAK,WAAW,YAAY,QAAQ,EAAE;GACtC,MAAM,KAAK,WAAW,kBAClB,eAAe,QAAQ,EAAE,CAAC,CAC3B,OAAO,MAAM,OAAO,KAAK,+BAAgC,EAAY,SAAS,CAAC;GAClF,KAAK,WAAW,qBAAqB,eAAe,QAAQ,EAAE;GAC9D,OAAO,KAAK,UAAU,QAAQ,GAAG,MAAM,QAAQ,GAAG,+BAA+B;GACjF;EACF;EAEA,KAAK,WAAW,YAAY,QAAQ,IAAI,GAAG;EAE3C,IAAI,IAAI,aAAa,UAAU;GAC7B,MAAM,QAAQ,IAAI;GAClB,MAAM,mBAAmB,KAAK,WAAW;GACzC,IAAI,QAAQ,OAAO,YAAY,IAAI,QACjC,MAAM,kBACF,aACA,QAAQ,IACR,IAAI,MACJ,OACA,IAAI,iBACJ,IAAI,MACN,CAAC,CACA,OAAO,MAAM,OAAO,KAAK,4BAA6B,EAAY,SAAS,CAAC;QAC1E,IAAI,IAAI,QACb;QAAI,kBACF,MAAM,iBACH,eACC,QAAQ,IACR,IAAI,MACJ,OACA,IAAI,iBACJ,IAAI,MACN,CAAC,CACA,WAAW,iBAAiB,iBAAiB,QAAQ,EAAE,CAAC,CAAC,CACzD,OAAO,MAAM,OAAO,KAAK,+BAAgC,EAAY,SAAS,CAAC;GACpF,OAEA,kBAAkB,mBAAmB,QAAQ,EAAE;EAEnD,OAAO,IAAI,IAAI,aAAa,aAAa;GAIvC,MAAM,QAAQ,IAAI;GAClB,IAAI,QAAQ,OAAO,YAAY,IAAI,QACjC,KAAK,WAAW,qBAAqB,aACnC,QAAQ,IACR,IAAI,MACJ,OACA,IAAI,iBACJ,IAAI,MACN;QACK,IAAI,IAAI,QACb,KAAK,WAAW,qBAAqB,eACnC,QAAQ,IACR,IAAI,MACJ,OACA,IAAI,iBACJ,IAAI,MACN;QAGA,KAAK,WAAW,qBAAqB,eAAe,QAAQ,EAAE;EAElE;EACA,OAAO,KAAK,UAAU,QAAQ,GAAG,MAAM,QAAQ,GAAG,IAAI,IAAI,KAAK,WAAW,IAAI,QAAQ;CACxF;CAEA,MAAM,YAA2B;EAC/B,OAAO,KAAK,uBAAuB,KAAK,aAAa,CAAC;CACxD;CAEA,MAAc,eAA8B;EAC1C,MAAM,OAAO,MAAM,WAAW,WAAW,GAAG;EAC5C,KAAK,WAAW,aAAa,IAAI;EAGjC,MAAM,gBAAgB,KACnB,QAAQ,MAAM,EAAE,aAAa,WAAW,CAAC,CACzC,KAAK,OAAO;GACX,IAAI,EAAE;GACN,MAAM,EAAE;GACR,aAAa,EAAE;GACf,gBAAgB,EAAE;GAClB,QAAQ,EAAE;EACZ,EAAE;EACJ,KAAK,WAAW,qBAAqB,cAAc,aAAa;EAChE,MAAM,aAAa,KAChB,QAAQ,MAAM,EAAE,aAAa,QAAQ,CAAC,CACtC,KAAK,OAAO;GACX,IAAI,EAAE;GACN,MAAM,EAAE;GACR,aAAa,EAAE;GACf,gBAAgB,EAAE;GAClB,QAAQ,EAAE;EACZ,EAAE;EACJ,MAAM,KAAK,WAAW,kBAClB,cAAc,UAAU,CAAC,CAC1B,OAAO,MAAM,OAAO,KAAK,4BAA6B,EAAY,SAAS,CAAC;EAC/E,KAAK,kCAAkB,IAAI,KAAK;CAClC;CAEA,iBAAyB,WAA+C;EACtE,MAAM,OAAO,KAAK,eAAe,KAAK,WAAW,SAAS;EAC1D,KAAK,iBAAiB,KAAK,YAAY,CAAC,CAAC;EACzC,OAAO;CACT;AACF"}

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

@@ -1,5 +1,17 @@
 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
+/**
+* tool envelope + 사용자 output 스키마 합성 (요청 방향). 응답 해석은 tool-emulation.ts.
+*
+* tools 가 있어도 최종 answer 가 사용자 스키마로 강제되게 하려고 envelope 의 answer 브랜치에
+* 사용자 스키마를 심는다. 통째로 중첩할 수 없는 이유는 `$ref` 가 문서 절대 경로이기 때문 —
+* `#` 은 "이 조각의 루트"가 아니라 "최종 문서의 루트"라, 그대로 넣으면 포인터가 envelope 을
+* 가리켜 조용히 엉뚱한 걸 검증하게 된다. 그래서 예약 이름 아래로 옮기고 로컬 포인터를 재작성한다.
+*
+* 배경·실측·예시·거부 목록은 스킬 문서를 볼 것:
+*   packages/cli/skills/qgrid/references/tool-calling-and-multiturn.md
+*   → "Composing Tools With A User Output Schema"
+*/
 const USER_OUTPUT_DEFINITION = "__qgrid_user_output";
 const USER_OUTPUT_REF = `#/$defs/${USER_OUTPUT_DEFINITION}`;
 var ToolSchemaCompositionError = class extends Error {
@@ -110,4 +122,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":["/**\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\n// envelope 는 result 한 겹 아래에 discriminated union 을 둔다. 두 변형을 문법 수준에서\n// 상호배타로 만들어(answer 변형은 answer 비null 필수, tool_call 변형은 toolCalls 1개 이상)\n// `action:\"answer\", answer:null` 같은 퇴화 조합을 원천 차단한다 — 평평한 스키마 시절\n// 이 조합이 constrained decoding 을 통과해 13.5k 건의 오염 응답을 만든 실사고가 근거.\n// union 을 result property 안에 중첩하는 이유: OpenAI structured outputs 는 루트가\n// object 여야 하고 top-level anyOf 를 거부한다. 중첩 anyOf 와 minItems 는 지원된다.\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 result.action to tool_call and include result.toolCalls. Use action answer only when no further client tool result is needed.\",\n    properties: {\n      result: {\n        anyOf: [\n          {\n            type: \"object\",\n            description: \"Final answer. Use only when no further client tool result is needed.\",\n            properties: {\n              action: { type: \"string\", enum: [\"answer\"] },\n              answer:\n                normalizedAnswerSchema === undefined\n                  ? { type: \"string\" }\n                  : { $ref: USER_OUTPUT_REF },\n              toolCalls: { type: \"null\" },\n            },\n            required: [\"action\", \"answer\", \"toolCalls\"],\n            additionalProperties: false,\n          },\n          {\n            type: \"object\",\n            description:\n              \"Request client-side tool execution through this structured output. Do not call these tools as native Claude Code tools.\",\n            properties: {\n              action: { type: \"string\", enum: [\"tool_call\"] },\n              answer: { type: \"null\" },\n              toolCalls: {\n                type: \"array\",\n                minItems: 1,\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            },\n            required: [\"action\", \"answer\", \"toolCalls\"],\n            additionalProperties: false,\n          },\n        ],\n      },\n    },\n    required: [\"result\"],\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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"}
+//# 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 {\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 JsonValue } from \"../../utils/providers/common/provider-types\";\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\n// envelope 는 result 한 겹 아래에 discriminated union 을 둔다. 두 변형을 문법 수준에서\n// 상호배타로 만들어(answer 변형은 answer 비null 필수, tool_call 변형은 toolCalls 1개 이상)\n// `action:\"answer\", answer:null` 같은 퇴화 조합을 원천 차단한다 — 평평한 스키마 시절\n// 이 조합이 constrained decoding 을 통과해 13.5k 건의 오염 응답을 만든 실사고가 근거.\n// union 을 result property 안에 중첩하는 이유: OpenAI structured outputs 는 루트가\n// object 여야 하고 top-level anyOf 를 거부한다. 중첩 anyOf 와 minItems 는 지원된다.\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 result.action to tool_call and include result.toolCalls. Use action answer only when no further client tool result is needed.\",\n    properties: {\n      result: {\n        anyOf: [\n          {\n            type: \"object\",\n            description: \"Final answer. Use only when no further client tool result is needed.\",\n            properties: {\n              action: { type: \"string\", enum: [\"answer\"] },\n              answer:\n                normalizedAnswerSchema === undefined\n                  ? { type: \"string\" }\n                  : { $ref: USER_OUTPUT_REF },\n              toolCalls: { type: \"null\" },\n            },\n            required: [\"action\", \"answer\", \"toolCalls\"],\n            additionalProperties: false,\n          },\n          {\n            type: \"object\",\n            description:\n              \"Request client-side tool execution through this structured output. Do not call these tools as native Claude Code tools.\",\n            properties: {\n              action: { type: \"string\", enum: [\"tool_call\"] },\n              answer: { type: \"null\" },\n              toolCalls: {\n                type: \"array\",\n                minItems: 1,\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            },\n            required: [\"action\", \"answer\", \"toolCalls\"],\n            additionalProperties: false,\n          },\n        ],\n      },\n    },\n    required: [\"result\"],\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/application/qgrid/tool-emulation.js

@@ -1,6 +1,6 @@
-import { getLogger } from "@logtape/logtape";
 import { Buffer } from "node:buffer";
 import { z } from "zod";
+import { getLogger } from "@logtape/logtape";
 //#region src/application/qgrid/tool-emulation.ts
 const STRUCTURED_ENVELOPE_LIMITS = {
 	maxUtf8Bytes: 512 * 1024,
@@ -44,8 +44,9 @@ function parseEnvelope(text, tools, answerKind) {
 	try {
 		value = JSON.parse(text);
 	} catch (error) {
-		logger.warn(`tool envelope parse failed: ${error.message}`);
-		throw new ToolCallEmulationError(`invalid tool envelope: ${error.message}`);
+		const head = JSON.stringify(text.slice(0, 200));
+		logger.warn(`tool envelope parse failed: ${error.message}; head=${head}`);
+		throw new ToolCallEmulationError(`invalid tool envelope (response is not JSON — the model ignored the envelope contract; retry is the caller's decision): ${error.message}; response head: ${head}`);
 	}
 	assertStructuredEnvelopeComplexity(value);
 	const validation = (answerKind === "text" ? TEXT_ENVELOPE : JSON_ENVELOPE).safeParse(value);
@@ -53,8 +54,9 @@ function parseEnvelope(text, tools, answerKind) {
 		const issue = validation.error.issues[0];
 		const path = issue && issue.path.length > 0 ? ` at ${issue.path.join(".")}` : "";
 		const detail = issue?.message ?? "unknown validation issue";
-		logger.warn(`tool envelope validation failed${path}: ${detail}`);
-		throw new ToolCallEmulationError(`invalid tool envelope${path}: ${detail}`);
+		const head = JSON.stringify(text.slice(0, 200));
+		logger.warn(`tool envelope validation failed${path}: ${detail}; head=${head}`);
+		throw new ToolCallEmulationError(`invalid tool envelope${path}: ${detail}; response head: ${head}`);
 	}
 	const response = value.result;
 	if (response.action === "tool_call") {
@@ -123,4 +125,4 @@ function assertStructuredEnvelopeComplexity(root) {
 //#endregion
 export { ToolCallEmulationError, applyToolCallEmulation };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"tool-emulation.js","names":[],"sources":["../../../src/application/qgrid/tool-emulation.ts"],"sourcesContent":["import { Buffer } from \"node:buffer\";\n\nimport { getLogger } from \"@logtape/logtape\";\nimport { z } from \"zod\";\n\n// 응답(모델 출력) envelope 의 자원 한도. caller 스키마 전처리 한도(CALLER_SCHEMA_LIMITS)와 값이\n// 같아 보여도 서로 다른 자원을 지키는 독립 상수다 — 스키마 깊이는 인스턴스 깊이를 bound 하지\n// 않으므로(재귀 $ref 허용) 캘러 한도를 조정해도 응답 수용 기준이 따라 움직여선 안 된다.\nconst STRUCTURED_ENVELOPE_LIMITS = {\n  maxUtf8Bytes: 512 * 1024,\n  maxNodes: 20_000,\n  maxDepth: 132,\n} as const;\nimport {\n  type QgridContent,\n  type QgridThreadCoord,\n  type QgridTool,\n  type QueryOutput,\n} from \"./qgrid.types\";\n\nconst logger = getLogger([\"qgrid\", \"tool-emulation\"]);\n\ntype EmulationResult = Omit<QueryOutput, \"content\" | \"finishReason\" | \"runContext\">;\ntype ToolCall = { toolName: string; args: string };\n\n// envelope 는 {result: <union>} 한 겹 구조 — 스키마 근거는 tool-emulation-schema.ts 참조.\n// answer 타입만 요청 형태에 따라 다르다: tools-only 는 string(그대로 반환),\n// tools+jsonSchema 는 사용자 스키마의 JSON 값(JSON.stringify 로 반환).\nfunction buildEnvelopeSchema(answerKind: AnswerKind) {\n  return z.strictObject({\n    result: z.discriminatedUnion(\"action\", [\n      z.strictObject({\n        action: z.literal(\"answer\"),\n        answer:\n          answerKind === \"text\"\n            ? z.string()\n            : z.json().refine((answer) => answer !== null, {\n                message: \"answer must be non-null\",\n              }),\n        toolCalls: z.null(),\n      }),\n      z.strictObject({\n        action: z.literal(\"tool_call\"),\n        answer: z.null(),\n        toolCalls: z\n          .array(\n            z.strictObject({\n              toolName: z.string(),\n              args: z.string(),\n            }),\n          )\n          .min(1),\n      }),\n    ]),\n  });\n}\n\nconst TEXT_ENVELOPE = buildEnvelopeSchema(\"text\");\nconst JSON_ENVELOPE = buildEnvelopeSchema(\"json\");\ntype EnvelopeResponse = z.infer<typeof JSON_ENVELOPE>[\"result\"];\n\nexport class ToolCallEmulationError extends Error {\n  constructor(message: string) {\n    super(`tool-call emulation: ${message}`);\n    this.name = \"ToolCallEmulationError\";\n  }\n}\n\n// dispatcher 가 넘기는 이미지 결과. qgrid 는 base64 payload 만 전달하고 포맷은 보장하지 않는다.\ninterface EmulationImage {\n  data: string;\n  revisedPrompt?: string | null;\n}\n\n// answer 인코딩 종류. envelope 디코더는 한 벌이고 이 값은 answer 브랜치의 타입과\n// 최종 직렬화(text: 그대로 / json: JSON.stringify)만 가른다.\nexport type AnswerKind = \"text\" | \"json\";\n\ninterface ToolCallEmulationOptions {\n  threadCoord?: QgridThreadCoord;\n  images?: EmulationImage[];\n  // 필수: 호출부가 answer 인코딩을 항상 명시해야 한다 (input.jsonSchema 유무로 판정).\n  answerKind: AnswerKind;\n}\n\nexport function applyToolCallEmulation(\n  result: EmulationResult,\n  tools: QgridTool[] | undefined,\n  options: ToolCallEmulationOptions,\n): QueryOutput {\n  const { threadCoord, images, answerKind } = options;\n  const runContext = threadCoord ? { threadCoord } : undefined;\n\n  if (!tools?.length) {\n    return answerOutput(result, result.text, images, runContext);\n  }\n\n  const parsed = parseEnvelope(result.text, tools, answerKind);\n  if (parsed.action === \"tool_call\") {\n    return toolCallOutput(result, parsed.toolCalls, images, runContext);\n  }\n\n  return answerOutput(\n    result,\n    answerKind === \"text\" ? (parsed.answer as string) : JSON.stringify(parsed.answer),\n    images,\n    runContext,\n  );\n}\n\nfunction parseEnvelope(text: string, tools: QgridTool[], answerKind: AnswerKind) {\n  if (Buffer.byteLength(text, \"utf8\") > STRUCTURED_ENVELOPE_LIMITS.maxUtf8Bytes) {\n    throw new ToolCallEmulationError(\n      `tool envelope exceeds UTF-8 byte limit of ${STRUCTURED_ENVELOPE_LIMITS.maxUtf8Bytes}`,\n    );\n  }\n\n  let value: unknown;\n  try {\n    value = JSON.parse(text);\n  } catch (error) {\n    // 관용 폴백 없음: envelope 는 양 provider 의 structured output 으로 강제되는 내부\n    // 계약이라 여기 도달한 비 JSON 은 버그다. 과거의 텍스트 구제는 퇴화 봉투를 답변으로\n    // 흘려보내 조용한 오염을 만들었다(2026-07 medpath, 13.5k 건).\n    logger.warn(`tool envelope parse failed: ${(error as Error).message}`);\n    throw new ToolCallEmulationError(`invalid tool envelope: ${(error as Error).message}`);\n  }\n\n  assertStructuredEnvelopeComplexity(value);\n  const schema = answerKind === \"text\" ? TEXT_ENVELOPE : JSON_ENVELOPE;\n  const validation = schema.safeParse(value);\n  if (!validation.success) {\n    const issue = validation.error.issues[0];\n    const path = issue && issue.path.length > 0 ? ` at ${issue.path.join(\".\")}` : \"\";\n    const detail = issue?.message ?? \"unknown validation issue\";\n    logger.warn(`tool envelope validation failed${path}: ${detail}`);\n    throw new ToolCallEmulationError(`invalid tool envelope${path}: ${detail}`);\n  }\n\n  // Zod clones JSON objects and drops own \"__proto__\" keys. The parsed JSON is safe to return\n  // after validation and preserves the caller's exact structured value.\n  const response = (value as { result: EnvelopeResponse }).result;\n  if (response.action === \"tool_call\") {\n    const unknownTool = findUnknownTool(response.toolCalls, tools);\n    if (unknownTool !== undefined) {\n      throw new ToolCallEmulationError(`unknown emulated tool: ${unknownTool}`);\n    }\n  }\n  return response;\n}\n\nfunction toolCallOutput(\n  result: EmulationResult,\n  toolCalls: ToolCall[],\n  images: EmulationImage[] | undefined,\n  runContext: QueryOutput[\"runContext\"],\n): QueryOutput {\n  return {\n    ...result,\n    content: appendImages(\n      toolCalls.map((toolCall) => ({\n        type: \"tool-call\",\n        toolCallId: `call_${Math.random().toString(36).slice(2, 10)}`,\n        toolName: toolCall.toolName,\n        input: toolCall.args,\n      })),\n      images,\n    ),\n    finishReason: \"tool-calls\",\n    runContext,\n  };\n}\n\nfunction answerOutput(\n  result: EmulationResult,\n  text: string,\n  images: EmulationImage[] | undefined,\n  runContext: QueryOutput[\"runContext\"],\n): QueryOutput {\n  return {\n    ...result,\n    text,\n    content: appendImages([{ type: \"text\", text }], images),\n    finishReason: \"stop\",\n    runContext,\n  };\n}\n\nfunction findUnknownTool(toolCalls: ToolCall[], tools: QgridTool[]): string | undefined {\n  const knownToolNames = new Set(tools.map((tool) => tool.name));\n  return toolCalls.find((toolCall) => !knownToolNames.has(toolCall.toolName))?.toolName;\n}\n\nfunction appendImages(content: QgridContent[], images?: EmulationImage[]): QgridContent[] {\n  if (!images?.length) return content;\n  return [\n    ...content,\n    ...images.map(\n      (image): QgridContent => ({\n        type: \"image\",\n        data: image.data,\n        revisedPrompt: image.revisedPrompt ?? null,\n      }),\n    ),\n  ];\n}\n\nfunction assertStructuredEnvelopeComplexity(root: unknown): void {\n  const maxDepth = STRUCTURED_ENVELOPE_LIMITS.maxDepth;\n  const stack = [{ value: root, depth: 0 }];\n  let nodes = 0;\n\n  while (stack.length > 0) {\n    const current = stack.pop()!;\n    nodes += 1;\n    if (nodes > STRUCTURED_ENVELOPE_LIMITS.maxNodes) {\n      throw new ToolCallEmulationError(\n        `structured-output envelope exceeds node limit of ${STRUCTURED_ENVELOPE_LIMITS.maxNodes}`,\n      );\n    }\n    if (current.depth > maxDepth) {\n      throw new ToolCallEmulationError(\n        `structured-output envelope exceeds depth limit of ${maxDepth}`,\n      );\n    }\n    if (typeof current.value === \"number\" && !Number.isFinite(current.value)) {\n      throw new ToolCallEmulationError(\"answer must be valid JSON\");\n    }\n    if (current.value === null || typeof current.value !== \"object\") continue;\n\n    for (const value of Object.values(current.value)) {\n      stack.push({ value, depth: current.depth + 1 });\n    }\n  }\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"tool-emulation.js","names":[],"sources":["../../../src/application/qgrid/tool-emulation.ts"],"sourcesContent":["import { Buffer } from \"node:buffer\";\n\nimport { getLogger } from \"@logtape/logtape\";\nimport { z } from \"zod\";\n\n// 응답(모델 출력) envelope 의 자원 한도. caller 스키마 전처리 한도(CALLER_SCHEMA_LIMITS)와 값이\n// 같아 보여도 서로 다른 자원을 지키는 독립 상수다 — 스키마 깊이는 인스턴스 깊이를 bound 하지\n// 않으므로(재귀 $ref 허용) 캘러 한도를 조정해도 응답 수용 기준이 따라 움직여선 안 된다.\nconst STRUCTURED_ENVELOPE_LIMITS = {\n  maxUtf8Bytes: 512 * 1024,\n  maxNodes: 20_000,\n  maxDepth: 132,\n} as const;\nimport {\n  type QgridContent,\n  type QgridThreadCoord,\n  type QgridTool,\n  type QueryOutput,\n} from \"./qgrid.types\";\n\nconst logger = getLogger([\"qgrid\", \"tool-emulation\"]);\n\ntype EmulationResult = Omit<QueryOutput, \"content\" | \"finishReason\" | \"runContext\">;\ntype ToolCall = { toolName: string; args: string };\n\n// envelope 는 {result: <union>} 한 겹 구조 — 스키마 근거는 tool-emulation-schema.ts 참조.\n// answer 타입만 요청 형태에 따라 다르다: tools-only 는 string(그대로 반환),\n// tools+jsonSchema 는 사용자 스키마의 JSON 값(JSON.stringify 로 반환).\nfunction buildEnvelopeSchema(answerKind: AnswerKind) {\n  return z.strictObject({\n    result: z.discriminatedUnion(\"action\", [\n      z.strictObject({\n        action: z.literal(\"answer\"),\n        answer:\n          answerKind === \"text\"\n            ? z.string()\n            : z.json().refine((answer) => answer !== null, {\n                message: \"answer must be non-null\",\n              }),\n        toolCalls: z.null(),\n      }),\n      z.strictObject({\n        action: z.literal(\"tool_call\"),\n        answer: z.null(),\n        toolCalls: z\n          .array(\n            z.strictObject({\n              toolName: z.string(),\n              args: z.string(),\n            }),\n          )\n          .min(1),\n      }),\n    ]),\n  });\n}\n\nconst TEXT_ENVELOPE = buildEnvelopeSchema(\"text\");\nconst JSON_ENVELOPE = buildEnvelopeSchema(\"json\");\ntype EnvelopeResponse = z.infer<typeof JSON_ENVELOPE>[\"result\"];\n\nexport class ToolCallEmulationError extends Error {\n  constructor(message: string) {\n    super(`tool-call emulation: ${message}`);\n    this.name = \"ToolCallEmulationError\";\n  }\n}\n\n// dispatcher 가 넘기는 이미지 결과. qgrid 는 base64 payload 만 전달하고 포맷은 보장하지 않는다.\ninterface EmulationImage {\n  data: string;\n  revisedPrompt?: string | null;\n}\n\n// answer 인코딩 종류. envelope 디코더는 한 벌이고 이 값은 answer 브랜치의 타입과\n// 최종 직렬화(text: 그대로 / json: JSON.stringify)만 가른다.\nexport type AnswerKind = \"text\" | \"json\";\n\ninterface ToolCallEmulationOptions {\n  threadCoord?: QgridThreadCoord;\n  images?: EmulationImage[];\n  // 필수: 호출부가 answer 인코딩을 항상 명시해야 한다 (input.jsonSchema 유무로 판정).\n  answerKind: AnswerKind;\n}\n\nexport function applyToolCallEmulation(\n  result: EmulationResult,\n  tools: QgridTool[] | undefined,\n  options: ToolCallEmulationOptions,\n): QueryOutput {\n  const { threadCoord, images, answerKind } = options;\n  const runContext = threadCoord ? { threadCoord } : undefined;\n\n  if (!tools?.length) {\n    return answerOutput(result, result.text, images, runContext);\n  }\n\n  const parsed = parseEnvelope(result.text, tools, answerKind);\n  if (parsed.action === \"tool_call\") {\n    return toolCallOutput(result, parsed.toolCalls, images, runContext);\n  }\n\n  return answerOutput(\n    result,\n    answerKind === \"text\" ? (parsed.answer as string) : JSON.stringify(parsed.answer),\n    images,\n    runContext,\n  );\n}\n\nfunction parseEnvelope(text: string, tools: QgridTool[], answerKind: AnswerKind) {\n  if (Buffer.byteLength(text, \"utf8\") > STRUCTURED_ENVELOPE_LIMITS.maxUtf8Bytes) {\n    throw new ToolCallEmulationError(\n      `tool envelope exceeds UTF-8 byte limit of ${STRUCTURED_ENVELOPE_LIMITS.maxUtf8Bytes}`,\n    );\n  }\n\n  let value: unknown;\n  try {\n    value = JSON.parse(text);\n  } catch (error) {\n    // 관용 폴백 없음. openai 는 envelope 이 structured output 으로 강제되므로 여기 도달한\n    // 비 JSON 은 버그다. anthropic 은 계약을 프롬프트로만 안내하므로(SON-532) 비 JSON 이\n    // \"예상 가능한 모델 실패\"지만, 그래도 구제하지 않는다 — 과거의 텍스트 구제는 퇴화\n    // 봉투를 답변으로 흘려보내 조용한 오염을 만들었다(2026-07 medpath, 13.5k 건).\n    // 정직한 실패가 보여야 소비자가 재시도하거나 근본 원인을 고친다.\n    // 진단에는 위반 원문의 머리가 필요하다(SON-495 전례) — parse 에러 위치만으로는\n    // \"프로즈로 답했는지 / 펜스가 남았는지 / JSON 이 잘렸는지\"를 구분할 수 없다.\n    const head = JSON.stringify(text.slice(0, 200));\n    logger.warn(`tool envelope parse failed: ${(error as Error).message}; head=${head}`);\n    throw new ToolCallEmulationError(\n      `invalid tool envelope (response is not JSON — the model ignored the envelope contract; retry is the caller's decision): ${(error as Error).message}; response head: ${head}`,\n    );\n  }\n\n  assertStructuredEnvelopeComplexity(value);\n  const schema = answerKind === \"text\" ? TEXT_ENVELOPE : JSON_ENVELOPE;\n  const validation = schema.safeParse(value);\n  if (!validation.success) {\n    const issue = validation.error.issues[0];\n    const path = issue && issue.path.length > 0 ? ` at ${issue.path.join(\".\")}` : \"\";\n    const detail = issue?.message ?? \"unknown validation issue\";\n    // valid JSON 이지만 계약 위반인 경우에도 원문 머리를 남긴다 — zod 경로만으로는\n    // \"키 생략인지 / 래퍼로 감쌌는지 / 타입이 틀렸는지\"의 실물을 볼 수 없다.\n    const head = JSON.stringify(text.slice(0, 200));\n    logger.warn(`tool envelope validation failed${path}: ${detail}; head=${head}`);\n    throw new ToolCallEmulationError(\n      `invalid tool envelope${path}: ${detail}; response head: ${head}`,\n    );\n  }\n\n  // Zod clones JSON objects and drops own \"__proto__\" keys. The parsed JSON is safe to return\n  // after validation and preserves the caller's exact structured value.\n  const response = (value as { result: EnvelopeResponse }).result;\n  if (response.action === \"tool_call\") {\n    const unknownTool = findUnknownTool(response.toolCalls, tools);\n    if (unknownTool !== undefined) {\n      throw new ToolCallEmulationError(`unknown emulated tool: ${unknownTool}`);\n    }\n  }\n  return response;\n}\n\nfunction toolCallOutput(\n  result: EmulationResult,\n  toolCalls: ToolCall[],\n  images: EmulationImage[] | undefined,\n  runContext: QueryOutput[\"runContext\"],\n): QueryOutput {\n  return {\n    ...result,\n    content: appendImages(\n      toolCalls.map((toolCall) => ({\n        type: \"tool-call\",\n        toolCallId: `call_${Math.random().toString(36).slice(2, 10)}`,\n        toolName: toolCall.toolName,\n        input: toolCall.args,\n      })),\n      images,\n    ),\n    finishReason: \"tool-calls\",\n    runContext,\n  };\n}\n\nfunction answerOutput(\n  result: EmulationResult,\n  text: string,\n  images: EmulationImage[] | undefined,\n  runContext: QueryOutput[\"runContext\"],\n): QueryOutput {\n  return {\n    ...result,\n    text,\n    content: appendImages([{ type: \"text\", text }], images),\n    finishReason: \"stop\",\n    runContext,\n  };\n}\n\nfunction findUnknownTool(toolCalls: ToolCall[], tools: QgridTool[]): string | undefined {\n  const knownToolNames = new Set(tools.map((tool) => tool.name));\n  return toolCalls.find((toolCall) => !knownToolNames.has(toolCall.toolName))?.toolName;\n}\n\nfunction appendImages(content: QgridContent[], images?: EmulationImage[]): QgridContent[] {\n  if (!images?.length) return content;\n  return [\n    ...content,\n    ...images.map(\n      (image): QgridContent => ({\n        type: \"image\",\n        data: image.data,\n        revisedPrompt: image.revisedPrompt ?? null,\n      }),\n    ),\n  ];\n}\n\nfunction assertStructuredEnvelopeComplexity(root: unknown): void {\n  const maxDepth = STRUCTURED_ENVELOPE_LIMITS.maxDepth;\n  const stack = [{ value: root, depth: 0 }];\n  let nodes = 0;\n\n  while (stack.length > 0) {\n    const current = stack.pop()!;\n    nodes += 1;\n    if (nodes > STRUCTURED_ENVELOPE_LIMITS.maxNodes) {\n      throw new ToolCallEmulationError(\n        `structured-output envelope exceeds node limit of ${STRUCTURED_ENVELOPE_LIMITS.maxNodes}`,\n      );\n    }\n    if (current.depth > maxDepth) {\n      throw new ToolCallEmulationError(\n        `structured-output envelope exceeds depth limit of ${maxDepth}`,\n      );\n    }\n    if (typeof current.value === \"number\" && !Number.isFinite(current.value)) {\n      throw new ToolCallEmulationError(\"answer must be valid JSON\");\n    }\n    if (current.value === null || typeof current.value !== \"object\") continue;\n\n    for (const value of Object.values(current.value)) {\n      stack.push({ value, depth: current.depth + 1 });\n    }\n  }\n}\n"],"mappings":";;;;AAQA,MAAM,6BAA6B;CACjC,cAAc,MAAM;CACpB,UAAU;CACV,UAAU;AACZ;AAQA,MAAM,SAAS,UAAU,CAAC,SAAS,gBAAgB,CAAC;AAQpD,SAAS,oBAAoB,YAAwB;CACnD,OAAO,EAAE,aAAa,EACpB,QAAQ,EAAE,mBAAmB,UAAU,CACrC,EAAE,aAAa;EACb,QAAQ,EAAE,QAAQ,QAAQ;EAC1B,QACE,eAAe,SACX,EAAE,OAAO,IACT,EAAE,KAAK,CAAC,CAAC,QAAQ,WAAW,WAAW,MAAM,EAC3C,SAAS,0BACX,CAAC;EACP,WAAW,EAAE,KAAK;CACpB,CAAC,GACD,EAAE,aAAa;EACb,QAAQ,EAAE,QAAQ,WAAW;EAC7B,QAAQ,EAAE,KAAK;EACf,WAAW,EACR,MACC,EAAE,aAAa;GACb,UAAU,EAAE,OAAO;GACnB,MAAM,EAAE,OAAO;EACjB,CAAC,CACH,CAAC,CACA,IAAI,CAAC;CACV,CAAC,CACH,CAAC,EACH,CAAC;AACH;AAEA,MAAM,gBAAgB,oBAAoB,MAAM;AAChD,MAAM,gBAAgB,oBAAoB,MAAM;AAGhD,IAAa,yBAAb,cAA4C,MAAM;CAChD,YAAY,SAAiB;EAC3B,MAAM,wBAAwB,SAAS;EACvC,KAAK,OAAO;CACd;AACF;AAmBA,SAAgB,uBACd,QACA,OACA,SACa;CACb,MAAM,EAAE,aAAa,QAAQ,eAAe;CAC5C,MAAM,aAAa,cAAc,EAAE,YAAY,IAAI;CAEnD,IAAI,CAAC,OAAO,QACV,OAAO,aAAa,QAAQ,OAAO,MAAM,QAAQ,UAAU;CAG7D,MAAM,SAAS,cAAc,OAAO,MAAM,OAAO,UAAU;CAC3D,IAAI,OAAO,WAAW,aACpB,OAAO,eAAe,QAAQ,OAAO,WAAW,QAAQ,UAAU;CAGpE,OAAO,aACL,QACA,eAAe,SAAU,OAAO,SAAoB,KAAK,UAAU,OAAO,MAAM,GAChF,QACA,UACF;AACF;AAEA,SAAS,cAAc,MAAc,OAAoB,YAAwB;CAC/E,IAAI,OAAO,WAAW,MAAM,MAAM,IAAI,2BAA2B,cAC/D,MAAM,IAAI,uBACR,6CAA6C,2BAA2B,cAC1E;CAGF,IAAI;CACJ,IAAI;EACF,QAAQ,KAAK,MAAM,IAAI;CACzB,SAAS,OAAO;EAQd,MAAM,OAAO,KAAK,UAAU,KAAK,MAAM,GAAG,GAAG,CAAC;EAC9C,OAAO,KAAK,+BAAgC,MAAgB,QAAQ,SAAS,MAAM;EACnF,MAAM,IAAI,uBACR,2HAA4H,MAAgB,QAAQ,mBAAmB,MACzK;CACF;CAEA,mCAAmC,KAAK;CAExC,MAAM,cADS,eAAe,SAAS,gBAAgB,cACpC,CAAO,UAAU,KAAK;CACzC,IAAI,CAAC,WAAW,SAAS;EACvB,MAAM,QAAQ,WAAW,MAAM,OAAO;EACtC,MAAM,OAAO,SAAS,MAAM,KAAK,SAAS,IAAI,OAAO,MAAM,KAAK,KAAK,GAAG,MAAM;EAC9E,MAAM,SAAS,OAAO,WAAW;EAGjC,MAAM,OAAO,KAAK,UAAU,KAAK,MAAM,GAAG,GAAG,CAAC;EAC9C,OAAO,KAAK,kCAAkC,KAAK,IAAI,OAAO,SAAS,MAAM;EAC7E,MAAM,IAAI,uBACR,wBAAwB,KAAK,IAAI,OAAO,mBAAmB,MAC7D;CACF;CAIA,MAAM,WAAY,MAAuC;CACzD,IAAI,SAAS,WAAW,aAAa;EACnC,MAAM,cAAc,gBAAgB,SAAS,WAAW,KAAK;EAC7D,IAAI,gBAAgB,QAClB,MAAM,IAAI,uBAAuB,0BAA0B,aAAa;CAE5E;CACA,OAAO;AACT;AAEA,SAAS,eACP,QACA,WACA,QACA,YACa;CACb,OAAO;EACL,GAAG;EACH,SAAS,aACP,UAAU,KAAK,cAAc;GAC3B,MAAM;GACN,YAAY,QAAQ,KAAK,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,MAAM,GAAG,EAAE;GAC1D,UAAU,SAAS;GACnB,OAAO,SAAS;EAClB,EAAE,GACF,MACF;EACA,cAAc;EACd;CACF;AACF;AAEA,SAAS,aACP,QACA,MACA,QACA,YACa;CACb,OAAO;EACL,GAAG;EACH;EACA,SAAS,aAAa,CAAC;GAAE,MAAM;GAAQ;EAAK,CAAC,GAAG,MAAM;EACtD,cAAc;EACd;CACF;AACF;AAEA,SAAS,gBAAgB,WAAuB,OAAwC;CACtF,MAAM,iBAAiB,IAAI,IAAI,MAAM,KAAK,SAAS,KAAK,IAAI,CAAC;CAC7D,OAAO,UAAU,MAAM,aAAa,CAAC,eAAe,IAAI,SAAS,QAAQ,CAAC,CAAC,EAAE;AAC/E;AAEA,SAAS,aAAa,SAAyB,QAA2C;CACxF,IAAI,CAAC,QAAQ,QAAQ,OAAO;CAC5B,OAAO,CACL,GAAG,SACH,GAAG,OAAO,KACP,WAAyB;EACxB,MAAM;EACN,MAAM,MAAM;EACZ,eAAe,MAAM,iBAAiB;CACxC,EACF,CACF;AACF;AAEA,SAAS,mCAAmC,MAAqB;CAC/D,MAAM,WAAW,2BAA2B;CAC5C,MAAM,QAAQ,CAAC;EAAE,OAAO;EAAM,OAAO;CAAE,CAAC;CACxC,IAAI,QAAQ;CAEZ,OAAO,MAAM,SAAS,GAAG;EACvB,MAAM,UAAU,MAAM,IAAI;EAC1B,SAAS;EACT,IAAI,QAAQ,2BAA2B,UACrC,MAAM,IAAI,uBACR,oDAAoD,2BAA2B,UACjF;EAEF,IAAI,QAAQ,QAAQ,UAClB,MAAM,IAAI,uBACR,qDAAqD,UACvD;EAEF,IAAI,OAAO,QAAQ,UAAU,YAAY,CAAC,OAAO,SAAS,QAAQ,KAAK,GACrE,MAAM,IAAI,uBAAuB,2BAA2B;EAE9D,IAAI,QAAQ,UAAU,QAAQ,OAAO,QAAQ,UAAU,UAAU;EAEjE,KAAK,MAAM,SAAS,OAAO,OAAO,QAAQ,KAAK,GAC7C,MAAM,KAAK;GAAE;GAAO,OAAO,QAAQ,QAAQ;EAAE,CAAC;CAElD;AACF"}