@cartanova/qgrid-cli 2.5.3 → 2.5.4

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

@@ -0,0 +1,121 @@
+//#region src/application/qgrid/tool-emulation-schema.ts
+const USER_OUTPUT_DEFINITION = "__qgrid_user_output";
+const USER_OUTPUT_REF = `#/$defs/${USER_OUTPUT_DEFINITION}`;
+var ToolSchemaCompositionError = class extends Error {
+	path;
+	constructor(message, path) {
+		super(`tool schema composition: ${message} (at ${path})`);
+		this.path = path;
+		this.name = "ToolSchemaCompositionError";
+	}
+};
+function buildToolCallSchema(tools, answerSchema) {
+	const toolDescriptions = tools.map((tool) => {
+		const schema = JSON.stringify(tool.inputSchema);
+		return `- ${tool.name}: ${tool.description ?? ""}\n  inputSchema: ${schema}`;
+	}).join("\n");
+	const normalizedAnswerSchema = answerSchema === void 0 ? void 0 : rebaseUserOutputSchema(answerSchema);
+	return {
+		type: "object",
+		description: "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.",
+		properties: {
+			action: {
+				type: "string",
+				enum: ["answer", "tool_call"],
+				description: "Use tool_call to request client-side tool execution through this structured output. Use answer only for a final answer."
+			},
+			answer: { anyOf: [normalizedAnswerSchema === void 0 ? { type: "string" } : { $ref: USER_OUTPUT_REF }, { type: "null" }] },
+			toolCalls: {
+				description: "Client-side tool calls requested through structured output. Do not call these tools as native Claude Code tools.",
+				anyOf: [{
+					type: "array",
+					items: {
+						type: "object",
+						properties: {
+							toolName: {
+								type: "string",
+								enum: tools.map((tool) => tool.name),
+								description: `Client-side tool name to request through structured output. Do not call this as a native Claude Code tool.\n${toolDescriptions}`
+							},
+							args: {
+								type: "string",
+								description: "Tool arguments as a JSON string for the client-side tool."
+							}
+						},
+						required: ["toolName", "args"],
+						additionalProperties: false
+					}
+				}, { type: "null" }]
+			}
+		},
+		required: [
+			"action",
+			"answer",
+			"toolCalls"
+		],
+		additionalProperties: false,
+		...normalizedAnswerSchema === void 0 ? {} : { $defs: { [USER_OUTPUT_DEFINITION]: normalizedAnswerSchema } }
+	};
+}
+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"
+]);
+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}`);
+	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`);
+		result.$ref = `${USER_OUTPUT_REF}${ref.slice(1)}`;
+	}
+	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}`)]));
+		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 result[keyword] = rewriteSchemaNode(child, keywordPath);
+	}
+	return result;
+}
+function isJsonObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(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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"}

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

@@ -1,107 +1,95 @@
+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,
+	maxNodes: 2e4,
+	maxDepth: 132
+};
 const logger = getLogger(["qgrid", "tool-emulation"]);
-function appendImages(content, images) {
-	if (!images?.length) return content;
-	return [...content, ...images.map((img) => ({
-		type: "image",
-		data: img.data,
-		revisedPrompt: img.revisedPrompt ?? null
-	}))];
-}
-function buildToolCallSchema(tools) {
-	const toolDescriptions = tools.map((tool) => {
-		const schema = JSON.stringify(tool.inputSchema);
-		return `- ${tool.name}: ${tool.description ?? ""}\n  inputSchema: ${schema}`;
-	}).join("\n");
-	return {
-		type: "object",
-		description: "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.",
-		properties: {
-			action: {
-				type: "string",
-				enum: ["answer", "tool_call"],
-				description: "Use tool_call to request client-side tool execution through this structured output. Use answer only for a final answer."
-			},
-			answer: { anyOf: [{ type: "string" }, { type: "null" }] },
-			toolCalls: {
-				description: "Client-side tool calls requested through structured output. Do not call these tools as native Claude Code tools.",
-				anyOf: [{
-					type: "array",
-					items: {
-						type: "object",
-						properties: {
-							toolName: {
-								type: "string",
-								enum: tools.map((tool) => tool.name),
-								description: `Client-side tool name to request through structured output. Do not call this as a native Claude Code tool.\n${toolDescriptions}`
-							},
-							args: {
-								type: "string",
-								description: "Tool arguments as a JSON string for the client-side tool."
-							}
-						},
-						required: ["toolName", "args"],
-						additionalProperties: false
-					}
-				}, { type: "null" }]
-			}
-		},
-		required: [
-			"action",
-			"answer",
-			"toolCalls"
-		],
-		additionalProperties: false
-	};
-}
-function applyToolCallEmulation(result, tools, threadCoord, images) {
-	const runContext = threadCoord ? { threadCoord } : void 0;
-	if (!tools?.length) {
-		const content = [{
-			type: "text",
-			text: result.text
-		}];
-		return {
-			...result,
-			content: appendImages(content, images),
-			finishReason: "stop",
-			runContext
-		};
+const StructuredToolCallResponse = z.discriminatedUnion("action", [z.strictObject({
+	action: z.literal("answer"),
+	answer: z.json().refine((answer) => answer !== null, { message: "answer must be non-null" }),
+	toolCalls: z.union([z.null(), z.tuple([])])
+}), z.strictObject({
+	action: z.literal("tool_call"),
+	answer: z.null(),
+	toolCalls: z.array(z.strictObject({
+		toolName: z.string(),
+		args: z.string()
+	})).min(1)
+})]);
+var ToolCallEmulationError = class extends Error {
+	constructor(message) {
+		super(`tool-call emulation: ${message}`);
+		this.name = "ToolCallEmulationError";
 	}
+};
+function applyToolCallEmulation(result, tools, options = {}) {
+	const { threadCoord, images, answerMode = "legacy" } = options;
+	const runContext = threadCoord ? { threadCoord } : void 0;
+	if (!tools?.length) return answerOutput(result, result.text, images, runContext);
+	if (answerMode === "legacy") return applyLegacyResponse(result, tools, images, runContext);
+	const parsed = parseStructuredResponse(result.text, tools);
+	if (parsed.action === "tool_call") return toolCallOutput(result, parsed.toolCalls, images, runContext);
+	return answerOutput(result, JSON.stringify(parsed.answer), images, runContext);
+}
+/**
+* Tools-only requests keep the permissive 2.5.3 contract. Structured-output requests use the
+* strict decoder below because their outer action envelope is an internal server contract.
+*/
+function applyLegacyResponse(result, tools, images, runContext) {
 	let parsed;
 	try {
 		parsed = JSON.parse(result.text);
-	} catch (e) {
-		logger.warn(`tool-call emulation parse failed, falling back to text: ${e.message}`);
-		return {
-			...result,
-			content: appendImages([{
-				type: "text",
-				text: result.text
-			}], images),
-			finishReason: "stop",
-			runContext
-		};
+	} catch (error) {
+		logger.warn(`tool-call emulation parse failed, falling back to text: ${error.message}`);
+		return answerOutput(result, result.text, images, runContext);
 	}
 	if (parsed.action === "tool_call") {
-		const content = (parsed.toolCalls ?? []).map((toolCall) => {
-			if (!tools.some((tool) => tool.name === toolCall.toolName)) throw new Error(`unknown emulated tool: ${toolCall.toolName}`);
-			return {
-				type: "tool-call",
-				toolCallId: `call_${Math.random().toString(36).slice(2, 10)}`,
-				toolName: toolCall.toolName,
-				input: toolCall.args
-			};
-		});
-		return {
-			...result,
-			content: appendImages(content, images),
-			finishReason: "tool-calls",
-			runContext
-		};
+		const toolCalls = parsed.toolCalls ?? [];
+		const unknownTool = findUnknownTool(toolCalls, tools);
+		if (unknownTool !== void 0) throw new Error(`unknown emulated tool: ${unknownTool}`);
+		return toolCallOutput(result, toolCalls, images, runContext);
+	}
+	return answerOutput(result, parsed.answer ?? result.text, images, runContext);
+}
+function parseStructuredResponse(text, tools) {
+	if (Buffer.byteLength(text, "utf8") > STRUCTURED_ENVELOPE_LIMITS.maxUtf8Bytes) throw new ToolCallEmulationError(`structured-output envelope exceeds UTF-8 byte limit of ${STRUCTURED_ENVELOPE_LIMITS.maxUtf8Bytes}`);
+	let value;
+	try {
+		value = JSON.parse(text);
+	} catch (error) {
+		throw new ToolCallEmulationError(`invalid structured-output envelope: ${error.message}`);
+	}
+	assertStructuredEnvelopeComplexity(value);
+	const validation = StructuredToolCallResponse.safeParse(value);
+	if (!validation.success) {
+		const issue = validation.error.issues[0];
+		throw new ToolCallEmulationError(`invalid structured-output envelope${issue && issue.path.length > 0 ? ` at ${issue.path.join(".")}` : ""}: ${issue?.message ?? "unknown validation issue"}`);
 	}
-	const text = parsed.answer ?? result.text;
+	const response = value;
+	if (response.action === "tool_call") {
+		const unknownTool = findUnknownTool(response.toolCalls, tools);
+		if (unknownTool !== void 0) throw new ToolCallEmulationError(`unknown emulated tool: ${unknownTool}`);
+	}
+	return response;
+}
+function toolCallOutput(result, toolCalls, images, runContext) {
+	return {
+		...result,
+		content: appendImages(toolCalls.map((toolCall) => ({
+			type: "tool-call",
+			toolCallId: `call_${Math.random().toString(36).slice(2, 10)}`,
+			toolName: toolCall.toolName,
+			input: toolCall.args
+		})), images),
+		finishReason: "tool-calls",
+		runContext
+	};
+}
+function answerOutput(result, text, images, runContext) {
 	return {
 		...result,
 		text,
@@ -113,7 +101,39 @@ function applyToolCallEmulation(result, tools, threadCoord, images) {
 		runContext
 	};
 }
+function findUnknownTool(toolCalls, tools) {
+	const knownToolNames = new Set(tools.map((tool) => tool.name));
+	return toolCalls.find((toolCall) => !knownToolNames.has(toolCall.toolName))?.toolName;
+}
+function appendImages(content, images) {
+	if (!images?.length) return content;
+	return [...content, ...images.map((image) => ({
+		type: "image",
+		data: image.data,
+		revisedPrompt: image.revisedPrompt ?? null
+	}))];
+}
+function assertStructuredEnvelopeComplexity(root) {
+	const maxDepth = STRUCTURED_ENVELOPE_LIMITS.maxDepth;
+	const stack = [{
+		value: root,
+		depth: 0
+	}];
+	let nodes = 0;
+	while (stack.length > 0) {
+		const current = stack.pop();
+		nodes += 1;
+		if (nodes > STRUCTURED_ENVELOPE_LIMITS.maxNodes) throw new ToolCallEmulationError(`structured-output envelope exceeds node limit of ${STRUCTURED_ENVELOPE_LIMITS.maxNodes}`);
+		if (current.depth > maxDepth) throw new ToolCallEmulationError(`structured-output envelope exceeds depth limit of ${maxDepth}`);
+		if (typeof current.value === "number" && !Number.isFinite(current.value)) throw new ToolCallEmulationError("answer must be valid JSON");
+		if (current.value === null || typeof current.value !== "object") continue;
+		for (const value of Object.values(current.value)) stack.push({
+			value,
+			depth: current.depth + 1
+		});
+	}
+}
 //#endregion
-export { applyToolCallEmulation, buildToolCallSchema };
+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 { getLogger } from \"@logtape/logtape\";\n\nimport { type JsonValue } from \"../../codex-protocol/serde_json/JsonValue\";\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 ToolCallResponse = {\n  action: \"answer\" | \"tool_call\";\n  answer?: string | null;\n  toolCalls?: Array<{ toolName: string; args: string }> | null;\n};\n\n// dispatcher 가 넘기는 이미지 결과. qgrid 는 base64 payload 만 전달하고 포맷은 보장하지 않는다.\nexport interface EmulationImage {\n  data: string;\n  revisedPrompt?: string | null;\n}\n\n// 조립된 content 뒤에 이미지 파트를 append 한다. 모든 반환 분기가 공유.\nfunction appendImages(content: QgridContent[], images?: EmulationImage[]): QgridContent[] {\n  if (!images?.length) return content;\n  return [\n    ...content,\n    ...images.map(\n      (img): QgridContent => ({\n        type: \"image\",\n        data: img.data,\n        revisedPrompt: img.revisedPrompt ?? null,\n      }),\n    ),\n  ];\n}\n\nexport function buildToolCallSchema(tools: QgridTool[]): 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  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: { anyOf: [{ type: \"string\" }, { type: \"null\" }] },\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  };\n}\n\nexport function applyToolCallEmulation(\n  result: Omit<QueryOutput, \"content\" | \"finishReason\" | \"runContext\">,\n  tools?: QgridTool[],\n  threadCoord?: QgridThreadCoord,\n  images?: EmulationImage[],\n): QueryOutput {\n  // thread 재사용 좌표를 runContext 로 실어 올린다 (auto 모드는 requestLogId 없이 threadCoord 만).\n  const runContext = threadCoord ? { threadCoord } : undefined;\n  // 이미지는 finishReason 과 직교하는 content 파트. 조립된 content 뒤에 append 한다.\n\n  if (!tools?.length) {\n    const content: QgridContent[] = [{ type: \"text\", text: result.text }];\n    return { ...result, content: appendImages(content, images), finishReason: \"stop\", runContext };\n  }\n\n  let parsed: ToolCallResponse;\n  try {\n    parsed = JSON.parse(result.text) as ToolCallResponse;\n  } catch (e) {\n    logger.warn(`tool-call emulation parse failed, falling back to text: ${(e as Error).message}`);\n    return {\n      ...result,\n      content: appendImages([{ type: \"text\", text: result.text }], images),\n      finishReason: \"stop\",\n      runContext,\n    };\n  }\n\n  if (parsed.action === \"tool_call\") {\n    const toolCalls = parsed.toolCalls ?? [];\n    const content: QgridContent[] = toolCalls.map((toolCall) => {\n      if (!tools.some((tool) => tool.name === toolCall.toolName)) {\n        throw new Error(`unknown emulated tool: ${toolCall.toolName}`);\n      }\n\n      return {\n        type: \"tool-call\",\n        toolCallId: `call_${Math.random().toString(36).slice(2, 10)}`,\n        toolName: toolCall.toolName,\n        input: toolCall.args,\n      };\n    });\n    return {\n      ...result,\n      content: appendImages(content, images),\n      finishReason: \"tool-calls\",\n      runContext,\n    };\n  }\n\n  const text = parsed.answer ?? result.text;\n  return {\n    ...result,\n    text,\n    content: appendImages([{ type: \"text\", text }], images),\n    finishReason: \"stop\",\n    runContext,\n  };\n}\n"],"mappings":";;AAUA,MAAM,SAAS,UAAU,CAAC,SAAS,gBAAgB,CAAC;AAepD,SAAS,aAAa,SAAyB,QAA2C;CACxF,IAAI,CAAC,QAAQ,QAAQ,OAAO;CAC5B,OAAO,CACL,GAAG,SACH,GAAG,OAAO,KACP,SAAuB;EACtB,MAAM;EACN,MAAM,IAAI;EACV,eAAe,IAAI,iBAAiB;CACtC,EACF,CACF;AACF;AAEA,SAAgB,oBAAoB,OAA+B;CACjE,MAAM,mBAAmB,MACtB,KAAK,SAAS;EACb,MAAM,SAAS,KAAK,UAAU,KAAK,WAAW;EAC9C,OAAO,KAAK,KAAK,KAAK,IAAI,KAAK,eAAe,GAAG,mBAAmB;CACtE,CAAC,CAAC,CACD,KAAK,IAAI;CAEZ,OAAO;EACL,MAAM;EACN,aACE;EACF,YAAY;GACV,QAAQ;IACN,MAAM;IACN,MAAM,CAAC,UAAU,WAAW;IAC5B,aACE;GACJ;GACA,QAAQ,EAAE,OAAO,CAAC,EAAE,MAAM,SAAS,GAAG,EAAE,MAAM,OAAO,CAAC,EAAE;GACxD,WAAW;IACT,aACE;IACF,OAAO,CACL;KACE,MAAM;KACN,OAAO;MACL,MAAM;MACN,YAAY;OACV,UAAU;QACR,MAAM;QACN,MAAM,MAAM,KAAK,SAAS,KAAK,IAAI;QACnC,aAAa,+GAA+G;OAC9H;OACA,MAAM;QACJ,MAAM;QACN,aAAa;OACf;MACF;MACA,UAAU,CAAC,YAAY,MAAM;MAC7B,sBAAsB;KACxB;IACF,GACA,EAAE,MAAM,OAAO,CACjB;GACF;EACF;EACA,UAAU;GAAC;GAAU;GAAU;EAAW;EAC1C,sBAAsB;CACxB;AACF;AAEA,SAAgB,uBACd,QACA,OACA,aACA,QACa;CAEb,MAAM,aAAa,cAAc,EAAE,YAAY,IAAI;CAGnD,IAAI,CAAC,OAAO,QAAQ;EAClB,MAAM,UAA0B,CAAC;GAAE,MAAM;GAAQ,MAAM,OAAO;EAAK,CAAC;EACpE,OAAO;GAAE,GAAG;GAAQ,SAAS,aAAa,SAAS,MAAM;GAAG,cAAc;GAAQ;EAAW;CAC/F;CAEA,IAAI;CACJ,IAAI;EACF,SAAS,KAAK,MAAM,OAAO,IAAI;CACjC,SAAS,GAAG;EACV,OAAO,KAAK,2DAA4D,EAAY,SAAS;EAC7F,OAAO;GACL,GAAG;GACH,SAAS,aAAa,CAAC;IAAE,MAAM;IAAQ,MAAM,OAAO;GAAK,CAAC,GAAG,MAAM;GACnE,cAAc;GACd;EACF;CACF;CAEA,IAAI,OAAO,WAAW,aAAa;EAEjC,MAAM,WADY,OAAO,aAAa,CAAC,EACP,CAAU,KAAK,aAAa;GAC1D,IAAI,CAAC,MAAM,MAAM,SAAS,KAAK,SAAS,SAAS,QAAQ,GACvD,MAAM,IAAI,MAAM,0BAA0B,SAAS,UAAU;GAG/D,OAAO;IACL,MAAM;IACN,YAAY,QAAQ,KAAK,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,MAAM,GAAG,EAAE;IAC1D,UAAU,SAAS;IACnB,OAAO,SAAS;GAClB;EACF,CAAC;EACD,OAAO;GACL,GAAG;GACH,SAAS,aAAa,SAAS,MAAM;GACrC,cAAc;GACd;EACF;CACF;CAEA,MAAM,OAAO,OAAO,UAAU,OAAO;CACrC,OAAO;EACL,GAAG;EACH;EACA,SAAS,aAAa,CAAC;GAAE,MAAM;GAAQ;EAAK,CAAC,GAAG,MAAM;EACtD,cAAc;EACd;CACF;AACF"}
+//# 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 };\ntype LegacyToolCallResponse = {\n  action?: \"answer\" | \"tool_call\";\n  answer?: string | null;\n  toolCalls?: ToolCall[] | null;\n};\n\nconst StructuredToolCallResponse = z.discriminatedUnion(\"action\", [\n  z.strictObject({\n    action: z.literal(\"answer\"),\n    answer: z.json().refine((answer) => answer !== null, {\n      message: \"answer must be non-null\",\n    }),\n    toolCalls: z.union([z.null(), z.tuple([])]),\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]);\ntype StructuredResponse = z.infer<typeof StructuredToolCallResponse>;\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\ninterface ToolCallEmulationOptions {\n  threadCoord?: QgridThreadCoord;\n  images?: EmulationImage[];\n  answerMode?: \"legacy\" | \"structured\";\n}\n\nexport function applyToolCallEmulation(\n  result: EmulationResult,\n  tools?: QgridTool[],\n  options: ToolCallEmulationOptions = {},\n): QueryOutput {\n  const { threadCoord, images, answerMode = \"legacy\" } = options;\n  const runContext = threadCoord ? { threadCoord } : undefined;\n\n  if (!tools?.length) {\n    return answerOutput(result, result.text, images, runContext);\n  }\n\n  if (answerMode === \"legacy\") {\n    return applyLegacyResponse(result, tools, images, runContext);\n  }\n\n  const parsed = parseStructuredResponse(result.text, tools);\n  if (parsed.action === \"tool_call\") {\n    return toolCallOutput(result, parsed.toolCalls, images, runContext);\n  }\n\n  return answerOutput(result, JSON.stringify(parsed.answer), images, runContext);\n}\n\n/**\n * Tools-only requests keep the permissive 2.5.3 contract. Structured-output requests use the\n * strict decoder below because their outer action envelope is an internal server contract.\n */\nfunction applyLegacyResponse(\n  result: EmulationResult,\n  tools: QgridTool[],\n  images: EmulationImage[] | undefined,\n  runContext: QueryOutput[\"runContext\"],\n): QueryOutput {\n  let parsed: LegacyToolCallResponse;\n  try {\n    parsed = JSON.parse(result.text) as LegacyToolCallResponse;\n  } catch (error) {\n    logger.warn(\n      `tool-call emulation parse failed, falling back to text: ${(error as Error).message}`,\n    );\n    return answerOutput(result, result.text, images, runContext);\n  }\n\n  if (parsed.action === \"tool_call\") {\n    const toolCalls = parsed.toolCalls ?? [];\n    const unknownTool = findUnknownTool(toolCalls, tools);\n    if (unknownTool !== undefined) throw new Error(`unknown emulated tool: ${unknownTool}`);\n    return toolCallOutput(result, toolCalls, images, runContext);\n  }\n\n  return answerOutput(result, parsed.answer ?? result.text, images, runContext);\n}\n\nfunction parseStructuredResponse(text: string, tools: QgridTool[]) {\n  if (Buffer.byteLength(text, \"utf8\") > STRUCTURED_ENVELOPE_LIMITS.maxUtf8Bytes) {\n    throw new ToolCallEmulationError(\n      `structured-output 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    throw new ToolCallEmulationError(\n      `invalid structured-output envelope: ${(error as Error).message}`,\n    );\n  }\n\n  assertStructuredEnvelopeComplexity(value);\n  const validation = StructuredToolCallResponse.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    throw new ToolCallEmulationError(`invalid structured-output 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 StructuredResponse;\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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"}

package/bundle/dist/application/request-log/request-log.model.js

@@ -1,8 +1,8 @@
-import { SD } from "../../i18n/sd.generated.js";
-import { requestLogLoaderQueries, requestLogSubsetQueries } from "../sonamu.generated.sso.js";
+import { calculateCostUsd } from "../../utils/providers/common/model-cost.js";
 import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.140.0/helpers/esm/decorateMetadata.js";
 import __decorate from "../../_virtual/_@oxc-project_runtime@0.140.0/helpers/esm/decorate.js";
-import { calculateCostUsd } from "../../utils/providers/common/model-cost.js";
+import { SD } from "../../i18n/sd.generated.js";
+import { requestLogLoaderQueries, requestLogSubsetQueries } from "../sonamu.generated.sso.js";
 import { BadRequestException, BaseModelClass, NotFoundException, Puri, api, asArray, exhaustive, transactional } from "sonamu";
 //#region src/application/request-log/request-log.model.ts
 const MICRO_USD = 1e6;

package/bundle/dist/application/request-log-step/request-log-step.model.js

@@ -1,7 +1,7 @@
-import { SD } from "../../i18n/sd.generated.js";
-import { requestLogStepLoaderQueries, requestLogStepSubsetQueries } from "../sonamu.generated.sso.js";
 import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.140.0/helpers/esm/decorateMetadata.js";
 import __decorate from "../../_virtual/_@oxc-project_runtime@0.140.0/helpers/esm/decorate.js";
+import { SD } from "../../i18n/sd.generated.js";
+import { requestLogStepLoaderQueries, requestLogStepSubsetQueries } from "../sonamu.generated.sso.js";
 import { BadRequestException, BaseModelClass, NotFoundException, api, asArray, exhaustive } from "sonamu";
 //#region src/application/request-log-step/request-log-step.model.ts
 var RequestLogStepModelClass = class extends BaseModelClass {

package/bundle/dist/application/token/token.model.js

@@ -1,7 +1,7 @@
-import { SD } from "../../i18n/sd.generated.js";
-import { tokenLoaderQueries, tokenSubsetQueries } from "../sonamu.generated.sso.js";
 import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.140.0/helpers/esm/decorateMetadata.js";
 import __decorate from "../../_virtual/_@oxc-project_runtime@0.140.0/helpers/esm/decorate.js";
+import { SD } from "../../i18n/sd.generated.js";
+import { tokenLoaderQueries, tokenSubsetQueries } from "../sonamu.generated.sso.js";
 import { BadRequestException, BaseModelClass, NotFoundException, api, asArray, exhaustive } from "sonamu";
 //#region src/application/token/token.model.ts
 const DEFAULT_QUOTA_THRESHOLD = 80;

package/bundle/dist/server-error-handler.js

@@ -0,0 +1,15 @@
+import { isSoException } from "sonamu";
+import { getLogger } from "@logtape/logtape";
+//#region src/server-error-handler.ts
+function handleServerError(error, reply) {
+	getLogger(["qgrid"]).error(`${error}`);
+	const statusCode = isSoException(error) && Number.isInteger(error.statusCode) && error.statusCode >= 400 && error.statusCode <= 599 ? error.statusCode : 500;
+	reply.status(statusCode).send({
+		name: error.name,
+		message: error.message
+	});
+}
+//#endregion
+export { handleServerError };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmVyLWVycm9yLWhhbmRsZXIuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vc3JjL3NlcnZlci1lcnJvci1oYW5kbGVyLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGdldExvZ2dlciB9IGZyb20gXCJAbG9ndGFwZS9sb2d0YXBlXCI7XG5pbXBvcnQgeyB0eXBlIEZhc3RpZnlSZXBseSB9IGZyb20gXCJmYXN0aWZ5XCI7XG5pbXBvcnQgeyBpc1NvRXhjZXB0aW9uIH0gZnJvbSBcInNvbmFtdVwiO1xuXG4vLyBzdGF0dXNDb2RlIOulvCDsi6DrorDtlZjripQg67KU7JyE66W8IFNvbmFtdSDsmIjsmbgg6rOE7JW9KGlzU29FeGNlcHRpb24p7Jy866GcIO2VnOygle2VnOuLpC4gcWdyaWQg64qUIO2UhOuhneyLnOudvFxuLy8gdXBzdHJlYW0gSFRUUCDsmKTrpZgoZmV0Y2gvdW5kaWNpIOulmCnrj4Qgc3RhdHVzQ29kZSDrpbwg64us6rOgIOuCmOyYpOuKlOuNsCwg6re46rG4IGR1Y2stdHlwaW5nIOycvOuhnFxuLy8g6re464yA66GcIOyXkOy9lO2VmOuptCB1cHN0cmVhbSDsnZggNDAxLzQyOSDqsIAg7Zi47Lac7J6QIOyekOyLoOydmCDsmKTrpZjroZwg65GU6rCR7ZWc64ukLiBTb25hbXUg7JiI7Jm46rCAIOyVhOuLiOuptCA1MDAuXG5leHBvcnQgZnVuY3Rpb24gaGFuZGxlU2VydmVyRXJyb3IoZXJyb3I6IEVycm9yLCByZXBseTogRmFzdGlmeVJlcGx5KTogdm9pZCB7XG4gIGdldExvZ2dlcihbXCJxZ3JpZFwiXSkuZXJyb3IoYCR7ZXJyb3J9YCk7XG4gIGNvbnN0IHN0YXR1c0NvZGUgPVxuICAgIGlzU29FeGNlcHRpb24oZXJyb3IpICYmXG4gICAgTnVtYmVyLmlzSW50ZWdlcihlcnJvci5zdGF0dXNDb2RlKSAmJlxuICAgIGVycm9yLnN0YXR1c0NvZGUgPj0gNDAwICYmXG4gICAgZXJyb3Iuc3RhdHVzQ29kZSA8PSA1OTlcbiAgICAgID8gZXJyb3Iuc3RhdHVzQ29kZVxuICAgICAgOiA1MDA7XG5cbiAgcmVwbHkuc3RhdHVzKHN0YXR1c0NvZGUpLnNlbmQoe1xuICAgIG5hbWU6IGVycm9yLm5hbWUsXG4gICAgbWVzc2FnZTogZXJyb3IubWVzc2FnZSxcbiAgfSk7XG59XG4iXSwibWFwcGluZ3MiOiI7OztBQU9BLFNBQWdCLGtCQUFrQixPQUFjLE9BQTJCO0NBQ3pFLFVBQVUsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLE1BQU0sR0FBRyxPQUFPO0NBQ3JDLE1BQU0sYUFDSixjQUFjLEtBQUssS0FDbkIsT0FBTyxVQUFVLE1BQU0sVUFBVSxLQUNqQyxNQUFNLGNBQWMsT0FDcEIsTUFBTSxjQUFjLE1BQ2hCLE1BQU0sYUFDTjtDQUVOLE1BQU0sT0FBTyxVQUFVLENBQUMsQ0FBQyxLQUFLO0VBQzVCLE1BQU0sTUFBTTtFQUNaLFNBQVMsTUFBTTtDQUNqQixDQUFDO0FBQ0gifQ==

package/bundle/dist/sonamu.config.js

@@ -1,10 +1,11 @@
 import { monitLogSink } from "./application/monit/log-buffer.js";
-import { OpenAIDispatcher } from "./utils/providers/openai/openai-dispatcher.js";
 import { QgridDispatcher } from "./application/qgrid/qgrid.dispatcher.js";
 import { QgridFrame } from "./application/qgrid/qgrid.frame.js";
 import { TokenSubscriber } from "./application/qgrid/token-subscriber.js";
 import { ensureTokensTrigger } from "./application/qgrid/token-trigger-setup.js";
+import { handleServerError } from "./server-error-handler.js";
 import { AnthropicDispatcher } from "./utils/providers/anthropic/anthropic-dispatcher.js";
+import { OpenAIDispatcher } from "./utils/providers/openai/openai-dispatcher.js";
 import { CachePresets, defineConfig } from "sonamu";
 import { getConsoleSink, getLogger } from "@logtape/logtape";
 import { drivers, store } from "sonamu/cache";
@@ -171,11 +172,7 @@ var sonamu_config_default = defineConfig({
 				log.info("graceful shutdown");
 			},
 			onError: (error, _request, reply) => {
-				getLogger(["qgrid"]).error(`${error}`);
-				reply.status(500).send({
-					name: error.name,
-					message: error.message
-				});
+				handleServerError(error, reply);
 			}
 		}
 	}
@@ -183,4 +180,4 @@ var sonamu_config_default = defineConfig({
 //#endregion
 export { sonamu_config_default as default };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sonamu.config.js","names":["cacheDrivers"],"sources":["../src/sonamu.config.ts"],"sourcesContent":["import path from \"path\";\n\nimport { getConsoleSink } from \"@logtape/logtape\";\nimport { getLogger } from \"@logtape/logtape\";\nimport { getPrettyFormatter } from \"@logtape/pretty\";\nimport { CachePresets, defineConfig } from \"sonamu\";\nimport { drivers as cacheDrivers, store } from \"sonamu/cache\";\n\nimport { monitLogSink } from \"./application/monit/log-buffer\";\nimport { QgridDispatcher } from \"./application/qgrid/qgrid.dispatcher\";\nimport { QgridFrame } from \"./application/qgrid/qgrid.frame\";\nimport { TokenSubscriber } from \"./application/qgrid/token-subscriber\";\nimport { ensureTokensTrigger } from \"./application/qgrid/token-trigger-setup\";\nimport { AnthropicDispatcher } from \"./utils/providers/anthropic/anthropic-dispatcher\";\nimport { OpenAIDispatcher } from \"./utils/providers/openai/openai-dispatcher\";\n\nconst host = process.env.HOST ?? \"localhost\";\nconst port = Number(process.env.PORT ?? 44900);\n\nconst connConfig = {\n  host: process.env.SONAMU_DB_HOST ?? \"localhost\",\n  port: Number(process.env.SONAMU_DB_PORT ?? 5432),\n  user: process.env.SONAMU_DB_USER ?? \"postgres\",\n  password: process.env.SONAMU_DB_PASSWORD ?? \"postgres\",\n  database: process.env.SONAMU_DB_NAME ?? \"qgrid\",\n};\n\nexport default defineConfig({\n  projectName: process.env.PROJECT_NAME ?? \"Qgrid\",\n  database: {\n    defaultOptions: {\n      connection: {\n        ...connConfig,\n        keepAlive: true,\n        keepAliveInitialDelayMillis: 10000,\n      },\n    },\n  },\n  api: {\n    dir: \"api\",\n    timezone: \"Asia/Seoul\",\n    route: {\n      prefix: \"/api\",\n    },\n  },\n  i18n: {\n    defaultLocale: \"ko\",\n    supportedLocales: [\"ko\", \"en\"],\n  },\n  sync: {\n    targets: [\"web\"],\n  },\n  test: {\n    parallel: true,\n    maxWorkers: 4,\n    devRunner: { enabled: true },\n  },\n  logging: {\n    sinks: {\n      console: getConsoleSink({\n        formatter: getPrettyFormatter({\n          timestamp: \"time\",\n          categoryWidth: 20,\n          categoryTruncate: \"middle\",\n        }),\n      }),\n      // Monit 탭용 in-memory ring buffer. 포맷은 sink 별 — 콘솔 출력은 그대로다.\n      monit: monitLogSink,\n    },\n    loggers: [\n      // qgrid 로그 (요청 분배, oauth/usage API)\n      { category: [\"qgrid\"], sinks: [\"console\", \"monit\"], lowestLevel: \"info\" },\n      // sonamu 로그는 warning 이상만\n      { category: [\"sonamu\"], sinks: [\"console\", \"monit\"], lowestLevel: \"warning\" },\n      // fastify 로그 차단\n      { category: [\"fastify\"], sinks: [], lowestLevel: \"fatal\" },\n    ],\n  },\n  server: {\n    listen: { port, host },\n    fastify: {\n      bodyLimit: 10 * 1024 * 1024,\n    },\n    plugins: {\n      formbody: true,\n      qs: true,\n      sse: true,\n      multipart: { limits: { fileSize: 1024 * 1024 * 30 } },\n      static: {\n        root: path.join(import.meta.dirname, \"/../\", \"public\"),\n        prefix: \"/api/public\",\n      },\n      custom: (server) => {\n        // OAuth 콜백 — Anthropic이 /callback으로 리다이렉트\n        server.get(\"/callback\", async (request, reply) => {\n          const { code, state } = request.query as { code?: string; state?: string };\n          if (!code || !state) {\n            return reply.redirect(\"/?oauth=error&reason=missing_params\");\n          }\n          try {\n            return QgridFrame.handleOAuthCallback(code, state, reply);\n          } catch (e) {\n            return reply.redirect(\n              `/?oauth=error&reason=${encodeURIComponent((e as Error).message)}`,\n            );\n          }\n        });\n\n        // OpenAI OAuth 는 codex app-server 가 자체 callback 서버를 올림\n        // handleOpenAICallback 불필요 — oauthCompleteOpenAI API 로 완료 확인\n      },\n    },\n    apiConfig: {\n      contextProvider: (defaultContext, request) => {\n        return {\n          ...defaultContext,\n          ip: request.ip,\n          body: request.body,\n        };\n      },\n      guardHandler: () => {},\n      cacheControlHandler: (req) => {\n        switch (req.type) {\n          case \"assets\":\n            // Hash 포함된 파일: 영구 캐시\n            if (req.path.match(/-[a-f0-9]+\\./)) {\n              return CachePresets.immutable;\n            }\n            return CachePresets.longLived;\n\n          case \"api\":\n            // GET 요청만 캐싱 고려\n            if (req.method === \"GET\") {\n              // 특정 경로는 짧은 캐시\n              if (req.path.startsWith(\"/api/static-data\")) {\n                return CachePresets.shortLived;\n              }\n              if (req.path.startsWith(\"/api/terms\")) {\n                return CachePresets.mediumLived;\n              }\n            }\n            // 기본: 캐시 없음\n            return CachePresets.noCache;\n\n          case \"ssr\":\n            // SSR 페이지: 10초 캐시\n            return CachePresets.ssr;\n\n          case \"csr\":\n            // CSR fallback (index.html): 1분 캐시\n            return CachePresets.shortLived;\n        }\n        return CachePresets.noCache;\n      },\n    },\n    cache: {\n      default: \"main\",\n      stores: {\n        main: store().useL1Layer(cacheDrivers.memory({ maxSize: \"50mb\" })),\n      },\n      ttl: \"5m\",\n      prefix: \"\",\n    },\n    lifecycle: {\n      onStart: async () => {\n        const log = getLogger([\"qgrid\", \"startup\"]);\n\n        let triggerReady = true;\n        try {\n          await ensureTokensTrigger(connConfig);\n        } catch (e) {\n          triggerReady = false;\n          log.warn(`trigger setup failed: ${(e as Error).message}`);\n        }\n\n        const subscriber = new TokenSubscriber(connConfig, QgridDispatcher);\n        QgridDispatcher.subscriber = subscriber;\n\n        const started = await subscriber.start();\n\n        try {\n          const openaiDispatcher = new OpenAIDispatcher();\n          await openaiDispatcher.start();\n          QgridDispatcher.openaiDispatcher = openaiDispatcher;\n        } catch (e) {\n          log.warn(`openai dispatcher failed: ${(e as Error).message}`);\n        }\n\n        try {\n          const anthropicDispatcher = new AnthropicDispatcher();\n          await anthropicDispatcher.start();\n          QgridDispatcher.anthropicDispatcher = anthropicDispatcher;\n        } catch (e) {\n          log.warn(`anthropic dispatcher failed: ${(e as Error).message}`);\n        }\n\n        const anthropicCount = QgridDispatcher.anthropicDispatcher?.tokenCount ?? 0;\n        const openaiReady = QgridDispatcher.openaiDispatcher?.readyWorkerCount ?? 0;\n        const openaiTotal = QgridDispatcher.openaiDispatcher?.workerCount ?? 0;\n\n        log.info(`listening on http://${host}:${port}`);\n        log.info(`anthropic: ${anthropicCount} tokens ready`);\n        log.info(`openai: ${openaiReady}/${openaiTotal} tokens ready`);\n        log.info(\n          `subscriber: ${started ? \"LISTEN active\" : \"degraded\"}${triggerReady ? \"\" : \", trigger failed\"}`,\n        );\n      },\n      onShutdown: async () => {\n        const log = getLogger([\"qgrid\", \"startup\"]);\n        if (QgridDispatcher.openaiDispatcher) {\n          await QgridDispatcher.openaiDispatcher.stop();\n        }\n        if (QgridDispatcher.anthropicDispatcher) {\n          await QgridDispatcher.anthropicDispatcher.stop();\n        }\n        if (QgridDispatcher.subscriber) {\n          await QgridDispatcher.subscriber.stop();\n        }\n        log.info(\"graceful shutdown\");\n      },\n      onError: (error, _request, reply) => {\n        getLogger([\"qgrid\"]).error(`${error}`);\n        reply.status(500).send({\n          name: error.name,\n          message: error.message,\n        });\n      },\n    },\n  },\n});\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sonamu.config.js","names":["cacheDrivers"],"sources":["../src/sonamu.config.ts"],"sourcesContent":["import path from \"path\";\n\nimport { getConsoleSink } from \"@logtape/logtape\";\nimport { getLogger } from \"@logtape/logtape\";\nimport { getPrettyFormatter } from \"@logtape/pretty\";\nimport { CachePresets, defineConfig } from \"sonamu\";\nimport { drivers as cacheDrivers, store } from \"sonamu/cache\";\n\nimport { monitLogSink } from \"./application/monit/log-buffer\";\nimport { QgridDispatcher } from \"./application/qgrid/qgrid.dispatcher\";\nimport { QgridFrame } from \"./application/qgrid/qgrid.frame\";\nimport { TokenSubscriber } from \"./application/qgrid/token-subscriber\";\nimport { ensureTokensTrigger } from \"./application/qgrid/token-trigger-setup\";\nimport { handleServerError } from \"./server-error-handler\";\nimport { AnthropicDispatcher } from \"./utils/providers/anthropic/anthropic-dispatcher\";\nimport { OpenAIDispatcher } from \"./utils/providers/openai/openai-dispatcher\";\n\nconst host = process.env.HOST ?? \"localhost\";\nconst port = Number(process.env.PORT ?? 44900);\n\nconst connConfig = {\n  host: process.env.SONAMU_DB_HOST ?? \"localhost\",\n  port: Number(process.env.SONAMU_DB_PORT ?? 5432),\n  user: process.env.SONAMU_DB_USER ?? \"postgres\",\n  password: process.env.SONAMU_DB_PASSWORD ?? \"postgres\",\n  database: process.env.SONAMU_DB_NAME ?? \"qgrid\",\n};\n\nexport default defineConfig({\n  projectName: process.env.PROJECT_NAME ?? \"Qgrid\",\n  database: {\n    defaultOptions: {\n      connection: {\n        ...connConfig,\n        keepAlive: true,\n        keepAliveInitialDelayMillis: 10000,\n      },\n    },\n  },\n  api: {\n    dir: \"api\",\n    timezone: \"Asia/Seoul\",\n    route: {\n      prefix: \"/api\",\n    },\n  },\n  i18n: {\n    defaultLocale: \"ko\",\n    supportedLocales: [\"ko\", \"en\"],\n  },\n  sync: {\n    targets: [\"web\"],\n  },\n  test: {\n    parallel: true,\n    maxWorkers: 4,\n    devRunner: { enabled: true },\n  },\n  logging: {\n    sinks: {\n      console: getConsoleSink({\n        formatter: getPrettyFormatter({\n          timestamp: \"time\",\n          categoryWidth: 20,\n          categoryTruncate: \"middle\",\n        }),\n      }),\n      // Monit 탭용 in-memory ring buffer. 포맷은 sink 별 — 콘솔 출력은 그대로다.\n      monit: monitLogSink,\n    },\n    loggers: [\n      // qgrid 로그 (요청 분배, oauth/usage API)\n      { category: [\"qgrid\"], sinks: [\"console\", \"monit\"], lowestLevel: \"info\" },\n      // sonamu 로그는 warning 이상만\n      { category: [\"sonamu\"], sinks: [\"console\", \"monit\"], lowestLevel: \"warning\" },\n      // fastify 로그 차단\n      { category: [\"fastify\"], sinks: [], lowestLevel: \"fatal\" },\n    ],\n  },\n  server: {\n    listen: { port, host },\n    fastify: {\n      bodyLimit: 10 * 1024 * 1024,\n    },\n    plugins: {\n      formbody: true,\n      qs: true,\n      sse: true,\n      multipart: { limits: { fileSize: 1024 * 1024 * 30 } },\n      static: {\n        root: path.join(import.meta.dirname, \"/../\", \"public\"),\n        prefix: \"/api/public\",\n      },\n      custom: (server) => {\n        // OAuth 콜백 — Anthropic이 /callback으로 리다이렉트\n        server.get(\"/callback\", async (request, reply) => {\n          const { code, state } = request.query as { code?: string; state?: string };\n          if (!code || !state) {\n            return reply.redirect(\"/?oauth=error&reason=missing_params\");\n          }\n          try {\n            return QgridFrame.handleOAuthCallback(code, state, reply);\n          } catch (e) {\n            return reply.redirect(\n              `/?oauth=error&reason=${encodeURIComponent((e as Error).message)}`,\n            );\n          }\n        });\n\n        // OpenAI OAuth 는 codex app-server 가 자체 callback 서버를 올림\n        // handleOpenAICallback 불필요 — oauthCompleteOpenAI API 로 완료 확인\n      },\n    },\n    apiConfig: {\n      contextProvider: (defaultContext, request) => {\n        return {\n          ...defaultContext,\n          ip: request.ip,\n          body: request.body,\n        };\n      },\n      guardHandler: () => {},\n      cacheControlHandler: (req) => {\n        switch (req.type) {\n          case \"assets\":\n            // Hash 포함된 파일: 영구 캐시\n            if (req.path.match(/-[a-f0-9]+\\./)) {\n              return CachePresets.immutable;\n            }\n            return CachePresets.longLived;\n\n          case \"api\":\n            // GET 요청만 캐싱 고려\n            if (req.method === \"GET\") {\n              // 특정 경로는 짧은 캐시\n              if (req.path.startsWith(\"/api/static-data\")) {\n                return CachePresets.shortLived;\n              }\n              if (req.path.startsWith(\"/api/terms\")) {\n                return CachePresets.mediumLived;\n              }\n            }\n            // 기본: 캐시 없음\n            return CachePresets.noCache;\n\n          case \"ssr\":\n            // SSR 페이지: 10초 캐시\n            return CachePresets.ssr;\n\n          case \"csr\":\n            // CSR fallback (index.html): 1분 캐시\n            return CachePresets.shortLived;\n        }\n        return CachePresets.noCache;\n      },\n    },\n    cache: {\n      default: \"main\",\n      stores: {\n        main: store().useL1Layer(cacheDrivers.memory({ maxSize: \"50mb\" })),\n      },\n      ttl: \"5m\",\n      prefix: \"\",\n    },\n    lifecycle: {\n      onStart: async () => {\n        const log = getLogger([\"qgrid\", \"startup\"]);\n\n        let triggerReady = true;\n        try {\n          await ensureTokensTrigger(connConfig);\n        } catch (e) {\n          triggerReady = false;\n          log.warn(`trigger setup failed: ${(e as Error).message}`);\n        }\n\n        const subscriber = new TokenSubscriber(connConfig, QgridDispatcher);\n        QgridDispatcher.subscriber = subscriber;\n\n        const started = await subscriber.start();\n\n        try {\n          const openaiDispatcher = new OpenAIDispatcher();\n          await openaiDispatcher.start();\n          QgridDispatcher.openaiDispatcher = openaiDispatcher;\n        } catch (e) {\n          log.warn(`openai dispatcher failed: ${(e as Error).message}`);\n        }\n\n        try {\n          const anthropicDispatcher = new AnthropicDispatcher();\n          await anthropicDispatcher.start();\n          QgridDispatcher.anthropicDispatcher = anthropicDispatcher;\n        } catch (e) {\n          log.warn(`anthropic dispatcher failed: ${(e as Error).message}`);\n        }\n\n        const anthropicCount = QgridDispatcher.anthropicDispatcher?.tokenCount ?? 0;\n        const openaiReady = QgridDispatcher.openaiDispatcher?.readyWorkerCount ?? 0;\n        const openaiTotal = QgridDispatcher.openaiDispatcher?.workerCount ?? 0;\n\n        log.info(`listening on http://${host}:${port}`);\n        log.info(`anthropic: ${anthropicCount} tokens ready`);\n        log.info(`openai: ${openaiReady}/${openaiTotal} tokens ready`);\n        log.info(\n          `subscriber: ${started ? \"LISTEN active\" : \"degraded\"}${triggerReady ? \"\" : \", trigger failed\"}`,\n        );\n      },\n      onShutdown: async () => {\n        const log = getLogger([\"qgrid\", \"startup\"]);\n        if (QgridDispatcher.openaiDispatcher) {\n          await QgridDispatcher.openaiDispatcher.stop();\n        }\n        if (QgridDispatcher.anthropicDispatcher) {\n          await QgridDispatcher.anthropicDispatcher.stop();\n        }\n        if (QgridDispatcher.subscriber) {\n          await QgridDispatcher.subscriber.stop();\n        }\n        log.info(\"graceful shutdown\");\n      },\n      onError: (error, _request, reply) => {\n        handleServerError(error, reply);\n      },\n    },\n  },\n});\n"],"mappings":"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"}