@cartanova/qgrid-cli 2.7.0 → 2.7.2

package/bundle/dist/utils/providers/anthropic/fence-strip.js

@@ -0,0 +1,83 @@
+//#region src/utils/providers/anthropic/fence-strip.ts
+/**
+* 코드펜스 스트리핑 (SON-532).
+*
+* anthropic 은 스키마/envelope 계약을 프롬프트로 안내하므로 응답은 평범한 텍스트다.
+* sonnet 계열이 지시에도 불구하고 ```json 펜스를 붙이는 실측이 있어, 서버가 펜스와
+* 양끝 공백만 벗겨 소비자(zod)/parseEnvelope/EnvelopeStreamParser 에 순수 JSON 을
+* 넘긴다. 머리말·후미 프로즈 구제는 하지 않는다 — 관용 복구는 2026-07 medpath 13.5k
+* 오염 사고로 기각된 원칙이며, 프로즈 응답은 다음 층에서 정직하게 실패한다.
+*
+* `stripFences` 는 stream-json-adapter 의 stripCodeFence(비스트림 result 경로)에서
+* 추출한 동일 시맨틱이다 — 스트림 델타 연결과 비스트림 최종 텍스트가 같은 결과여야
+* 클라이언트가 어느 쪽을 조립해도 어긋나지 않는다.
+*/
+function stripFences(s) {
+	return s.trim().replace(/^```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/i, "");
+}
+/**
+* 델타 스트림용 통과 필터. 불변식: 임의 절단 지점에 대해
+* `push(...) 들의 연결 + flush() == stripFences(전체 텍스트)`.
+*
+* tail 홀드백은 고정 크기가 아니라 계약 기반이다 — "공백·개행·백틱만으로 이루어진
+* suffix"(닫는 펜스 후보)를 스트림 완료까지 보류하고, 후보를 깨는 내용이 오면 즉시
+* 방출을 재개한다. 닫는 펜스 앞 공백은 임의 길이일 수 있어 고정 크기로는 "양끝 공백
+* 제거" 불변식이 성립하지 않는다.
+*/
+function createFenceStripTransform() {
+	let full = "";
+	let bodyStart = -1;
+	let emitted = 0;
+	return {
+		push(delta) {
+			full += delta;
+			if (bodyStart < 0) {
+				bodyStart = resolveLeadingOffset(full);
+				if (bodyStart < 0) return "";
+			}
+			const unemitted = full.slice(bodyStart).slice(emitted);
+			const safe = unemitted.length - trailingHoldLength(unemitted);
+			if (safe <= 0) return "";
+			const out = unemitted.slice(0, safe);
+			emitted += safe;
+			return out;
+		},
+		flush() {
+			return stripFences(full).slice(emitted);
+		}
+	};
+}
+/**
+* 여는 펜스 판정. 아직 "```json" 으로 자랄 수 있는 경계(백틱 1~2개, "```j(s(o))",
+* 펜스 직후 공백만 도착)면 -1 로 보류한다. stripFences 의 leading 정규식과 동일한
+* 소비 규칙: ```(json)? 뒤에 이어지는 공백 전부가 펜스에 붙어 떨어져 나간다.
+*/
+function resolveLeadingOffset(text) {
+	const trimmedStart = text.trimStart();
+	if (trimmedStart === "") return -1;
+	const ws = text.length - trimmedStart.length;
+	if (!trimmedStart.startsWith("`")) return ws;
+	if (/^`{1,2}$/.test(trimmedStart)) return -1;
+	const fence = /^```(?:json)?/i.exec(trimmedStart);
+	if (!fence) return ws;
+	if (/^```(?:j|js|jso)$/i.test(trimmedStart)) return -1;
+	const afterFence = trimmedStart.slice(fence[0].length);
+	const afterFenceBody = afterFence.trimStart();
+	if (afterFenceBody === "") return -1;
+	return ws + fence[0].length + (afterFence.length - afterFenceBody.length);
+}
+/**
+* 아직 방출하면 안 되는 suffix 길이. 닫는 펜스 후보는 "(개행?)(백틱 1~3)(공백*)" 또는
+* 순수 trailing 공백 — stripFences 의 trim + /\n?```\s*$/ 가 지울 수 있는 모든 형태를
+* 덮는다. 공백 클래스는 반드시 `\s`(+BOM) — trim() 은 NBSP·VT·FF·U+2028·U+2029 까지
+* 지우므로 ASCII 만 보류하면 그 문자들이 먼저 방출돼 "방출 == strip(전체)" 불변식이
+* 깨진다(2차 검토 #8 실측). 미방출 구간에만 적용하므로 비용은 (보류분+delta)에 비례.
+*/
+function trailingHoldLength(unemitted) {
+	const match = /(?:\n?`{1,3})?[\s]*$/.exec(unemitted);
+	return match ? match[0].length : 0;
+}
+//#endregion
+export { createFenceStripTransform, stripFences };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"fence-strip.js","names":[],"sources":["../../../../src/utils/providers/anthropic/fence-strip.ts"],"sourcesContent":["/**\n * 코드펜스 스트리핑 (SON-532).\n *\n * anthropic 은 스키마/envelope 계약을 프롬프트로 안내하므로 응답은 평범한 텍스트다.\n * sonnet 계열이 지시에도 불구하고 ```json 펜스를 붙이는 실측이 있어, 서버가 펜스와\n * 양끝 공백만 벗겨 소비자(zod)/parseEnvelope/EnvelopeStreamParser 에 순수 JSON 을\n * 넘긴다. 머리말·후미 프로즈 구제는 하지 않는다 — 관용 복구는 2026-07 medpath 13.5k\n * 오염 사고로 기각된 원칙이며, 프로즈 응답은 다음 층에서 정직하게 실패한다.\n *\n * `stripFences` 는 stream-json-adapter 의 stripCodeFence(비스트림 result 경로)에서\n * 추출한 동일 시맨틱이다 — 스트림 델타 연결과 비스트림 최종 텍스트가 같은 결과여야\n * 클라이언트가 어느 쪽을 조립해도 어긋나지 않는다.\n */\n\nexport function stripFences(s: string): string {\n  return s\n    .trim()\n    .replace(/^```(?:json)?\\s*\\n?/i, \"\")\n    .replace(/\\n?```\\s*$/i, \"\");\n}\n\ninterface FenceStripTransform {\n  /** delta 를 넣고 지금 방출해도 안전한 조각을 돌려받는다. */\n  push(delta: string): string;\n  /** 스트림 종료. 보류분 중 펜스·trailing 공백이 아닌 잔여를 돌려준다. */\n  flush(): string;\n}\n\n/**\n * 델타 스트림용 통과 필터. 불변식: 임의 절단 지점에 대해\n * `push(...) 들의 연결 + flush() == stripFences(전체 텍스트)`.\n *\n * tail 홀드백은 고정 크기가 아니라 계약 기반이다 — \"공백·개행·백틱만으로 이루어진\n * suffix\"(닫는 펜스 후보)를 스트림 완료까지 보류하고, 후보를 깨는 내용이 오면 즉시\n * 방출을 재개한다. 닫는 펜스 앞 공백은 임의 길이일 수 있어 고정 크기로는 \"양끝 공백\n * 제거\" 불변식이 성립하지 않는다.\n */\nexport function createFenceStripTransform(): FenceStripTransform {\n  let full = \"\";\n  // full 에서 본문(leading trim + 여는 펜스 이후)이 시작하는 인덱스. -1 = 아직 미확정.\n  let bodyStart = -1;\n  // 본문 기준으로 이미 방출한 문자 수. 방출분은 최종 결과의 prefix 임이 보장된다 —\n  // 공백은 비공백 내용이 뒤따르기 전까지 항상 보류되므로, 나중에 닫는 펜스의 일부로\n  // 판명될 문자가 미리 방출되는 일이 없다.\n  let emitted = 0;\n\n  return {\n    push(delta: string): string {\n      full += delta;\n      if (bodyStart < 0) {\n        bodyStart = resolveLeadingOffset(full);\n        if (bodyStart < 0) return \"\";\n      }\n\n      const body = full.slice(bodyStart);\n      const unemitted = body.slice(emitted);\n      const safe = unemitted.length - trailingHoldLength(unemitted);\n      if (safe <= 0) return \"\";\n\n      const out = unemitted.slice(0, safe);\n      emitted += safe;\n      return out;\n    },\n\n    flush(): string {\n      // 방출분이 최종 결과의 prefix 라는 불변식 위에서, 잔여만 잘라 돌려준다.\n      return stripFences(full).slice(emitted);\n    },\n  };\n}\n\n/**\n * 여는 펜스 판정. 아직 \"```json\" 으로 자랄 수 있는 경계(백틱 1~2개, \"```j(s(o))\",\n * 펜스 직후 공백만 도착)면 -1 로 보류한다. stripFences 의 leading 정규식과 동일한\n * 소비 규칙: ```(json)? 뒤에 이어지는 공백 전부가 펜스에 붙어 떨어져 나간다.\n */\nfunction resolveLeadingOffset(text: string): number {\n  const trimmedStart = text.trimStart();\n  if (trimmedStart === \"\") return -1; // 아직 공백뿐 — flush 가 정리한다\n  const ws = text.length - trimmedStart.length;\n\n  if (!trimmedStart.startsWith(\"`\")) return ws;\n  if (/^`{1,2}$/.test(trimmedStart)) return -1; // \"```\" 로 자랄 수 있음\n\n  const fence = /^```(?:json)?/i.exec(trimmedStart);\n  if (!fence) return ws; // \"`x\", \"``x\" — 펜스가 아니라 본문\n  if (/^```(?:j|js|jso)$/i.test(trimmedStart)) return -1; // \"json\" 태그가 자라는 중\n\n  const afterFence = trimmedStart.slice(fence[0].length);\n  const afterFenceBody = afterFence.trimStart();\n  if (afterFenceBody === \"\") return -1; // 펜스 뒤 공백만 — 본문 첫 글자 대기\n  return ws + fence[0].length + (afterFence.length - afterFenceBody.length);\n}\n\n/**\n * 아직 방출하면 안 되는 suffix 길이. 닫는 펜스 후보는 \"(개행?)(백틱 1~3)(공백*)\" 또는\n * 순수 trailing 공백 — stripFences 의 trim + /\\n?```\\s*$/ 가 지울 수 있는 모든 형태를\n * 덮는다. 공백 클래스는 반드시 `\\s`(+BOM) — trim() 은 NBSP·VT·FF·U+2028·U+2029 까지\n * 지우므로 ASCII 만 보류하면 그 문자들이 먼저 방출돼 \"방출 == strip(전체)\" 불변식이\n * 깨진다(2차 검토 #8 실측). 미방출 구간에만 적용하므로 비용은 (보류분+delta)에 비례.\n */\nfunction trailingHoldLength(unemitted: string): number {\n  const match = /(?:\\n?`{1,3})?[\\s﻿]*$/.exec(unemitted);\n  return match ? match[0].length : 0;\n}\n"],"mappings":";;;;;;;;;;;;;;AAcA,SAAgB,YAAY,GAAmB;CAC7C,OAAO,EACJ,KAAK,CAAC,CACN,QAAQ,wBAAwB,EAAE,CAAC,CACnC,QAAQ,eAAe,EAAE;AAC9B;;;;;;;;;;AAkBA,SAAgB,4BAAiD;CAC/D,IAAI,OAAO;CAEX,IAAI,YAAY;CAIhB,IAAI,UAAU;CAEd,OAAO;EACL,KAAK,OAAuB;GAC1B,QAAQ;GACR,IAAI,YAAY,GAAG;IACjB,YAAY,qBAAqB,IAAI;IACrC,IAAI,YAAY,GAAG,OAAO;GAC5B;GAGA,MAAM,YADO,KAAK,MAAM,SACN,CAAA,CAAK,MAAM,OAAO;GACpC,MAAM,OAAO,UAAU,SAAS,mBAAmB,SAAS;GAC5D,IAAI,QAAQ,GAAG,OAAO;GAEtB,MAAM,MAAM,UAAU,MAAM,GAAG,IAAI;GACnC,WAAW;GACX,OAAO;EACT;EAEA,QAAgB;GAEd,OAAO,YAAY,IAAI,CAAC,CAAC,MAAM,OAAO;EACxC;CACF;AACF;;;;;;AAOA,SAAS,qBAAqB,MAAsB;CAClD,MAAM,eAAe,KAAK,UAAU;CACpC,IAAI,iBAAiB,IAAI,OAAO;CAChC,MAAM,KAAK,KAAK,SAAS,aAAa;CAEtC,IAAI,CAAC,aAAa,WAAW,GAAG,GAAG,OAAO;CAC1C,IAAI,WAAW,KAAK,YAAY,GAAG,OAAO;CAE1C,MAAM,QAAQ,iBAAiB,KAAK,YAAY;CAChD,IAAI,CAAC,OAAO,OAAO;CACnB,IAAI,qBAAqB,KAAK,YAAY,GAAG,OAAO;CAEpD,MAAM,aAAa,aAAa,MAAM,MAAM,EAAE,CAAC,MAAM;CACrD,MAAM,iBAAiB,WAAW,UAAU;CAC5C,IAAI,mBAAmB,IAAI,OAAO;CAClC,OAAO,KAAK,MAAM,EAAE,CAAC,UAAU,WAAW,SAAS,eAAe;AACpE;;;;;;;;AASA,SAAS,mBAAmB,WAA2B;CACrD,MAAM,QAAQ,wBAAwB,KAAK,SAAS;CACpD,OAAO,QAAQ,MAAM,EAAE,CAAC,SAAS;AACnC"}

package/bundle/dist/utils/providers/anthropic/stream-json-adapter.js

@@ -1,3 +1,4 @@
+import { stripFences } from "./fence-strip.js";
 //#region src/utils/providers/anthropic/stream-json-adapter.ts
 function userInputToText(input) {
 	return input.filter((i) => i.type === "text").map((i) => i.text).join("\n");
@@ -80,9 +81,6 @@ function toUsageBreakdown(u) {
 		reasoningOutputTokens: 0
 	};
 }
-function stripCodeFence(s) {
-	return s.trim().replace(/^```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/i, "");
-}
 function structuredOutputToolUseText(j) {
 	const content = asObject(j.message)?.content;
 	if (!Array.isArray(content)) return void 0;
@@ -222,7 +220,7 @@ function handleStreamJsonLine(line, onDelta, opts) {
 		if (structuredOutput && resultSucceeded && j.structured_output !== void 0) text = JSON.stringify(j.structured_output);
 		else if (preservedStructuredOutput !== void 0) text = preservedStructuredOutput;
 		else if (j.structured_output !== void 0) text = JSON.stringify(j.structured_output);
-		else text = stripCodeFence(typeof j.result === "string" ? j.result : "");
+		else text = stripFences(typeof j.result === "string" ? j.result : "");
 		const rawUsage = asObject(j.usage) ?? {};
 		updateRoutingFromUsage(rawUsage, state);
 		const resultModel = optionalString(j.model);
@@ -255,4 +253,4 @@ function handleStreamJsonLine(line, onDelta, opts) {
 //#endregion
 export { buildStreamJsonInput, handleStreamJsonLine, serializeStreamJsonInput };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"stream-json-adapter.js","names":[],"sources":["../../../../src/utils/providers/anthropic/stream-json-adapter.ts"],"sourcesContent":["/**\n * Claude CLI stream-json adapter.\n *\n * Input: qgrid history/input -> Claude JSONL stdin.\n * Output: Claude JSONL stdout -> qgrid deltas + final result metadata.\n *\n * Previous conversation items are flattened into one assistant context line.\n * The only executable user line is the current input.\n */\n\nimport { type JsonValue } from \"../../../codex-protocol/serde_json/JsonValue\";\nimport { type UserInput } from \"../../../codex-protocol/v2/UserInput\";\nimport {\n  type ModelFallback,\n  type ProviderTokenUsageBreakdown,\n} from \"../common/provider-dispatcher\";\n\n// ── 입력 어댑터 ────────────────────────────────────────────────────\n\n// Claude stream-json 입력 한 줄(JSONL). Envelope fields are added in claude-session.\nexport interface ClaudeStreamJsonLine {\n  type: \"user\" | \"assistant\";\n  message: {\n    role: \"user\" | \"assistant\";\n    content: Array<{ type: \"text\"; text: string }>;\n  };\n}\n\nfunction userInputToText(input: Array<UserInput>): string {\n  return input\n    .filter((i): i is Extract<UserInput, { type: \"text\" }> => i.type === \"text\")\n    .map((i) => i.text)\n    .join(\"\\n\");\n}\n\nfunction textBlock(text: string): Array<{ type: \"text\"; text: string }> {\n  return [{ type: \"text\", text }];\n}\n\n// codex ResponseItem(coldHistory item) 최소 shape.\n// extractPromptAndHistory(ai-sdk/utils.ts) 가 만드는 형식:\n//   { type:\"message\", role:\"user\", content:[{type:\"input_text\", text}] }\n//   { type:\"message\", role:\"assistant\", content:[{type:\"output_text\", text}] }\n//   { type:\"function_call\", name, arguments, call_id }\n//   { type:\"function_call_output\", call_id, output }\ntype ResponseItem = { [key: string]: JsonValue | undefined };\n\nfunction asObject(v: JsonValue | undefined): ResponseItem | null {\n  return typeof v === \"object\" && v !== null && !Array.isArray(v) ? (v as ResponseItem) : null;\n}\n\nfunction responseItemText(item: ResponseItem): string {\n  const content = item.content;\n  if (!Array.isArray(content)) return \"\";\n  return content\n    .map((c) => {\n      const obj = asObject(c);\n      return obj && typeof obj.text === \"string\" ? obj.text : \"\";\n    })\n    .filter(Boolean)\n    .join(\"\\n\");\n}\n\nfunction flattenColdHistory(coldHistory: Array<JsonValue>): string {\n  const parts: Array<string> = [];\n  for (const raw of coldHistory) {\n    const item = asObject(raw);\n    if (!item) continue;\n\n    if (item.type === \"message\" && item.role === \"assistant\") {\n      parts.push(`Assistant: ${responseItemText(item)}`);\n    } else if (item.type === \"message\" && item.role === \"user\") {\n      parts.push(`User: ${responseItemText(item)}`);\n    } else if (item.type === \"function_call\") {\n      const name = typeof item.name === \"string\" ? item.name : \"\";\n      const args =\n        typeof item.arguments === \"string\" ? item.arguments : JSON.stringify(item.arguments ?? {});\n      parts.push(`Tool call: ${name}(${args})`);\n    } else if (item.type === \"function_call_output\") {\n      const output =\n        typeof item.output === \"string\" ? item.output : JSON.stringify(item.output ?? \"\");\n      parts.push(`Tool result: ${output}`);\n    }\n  }\n  return parts.join(\"\\n\");\n}\n\nexport function buildStreamJsonInput(opts: {\n  coldHistory?: Array<JsonValue>;\n  input: Array<UserInput>;\n}): Array<ClaudeStreamJsonLine> {\n  const lines: Array<ClaudeStreamJsonLine> = [];\n\n  if (opts.coldHistory && opts.coldHistory.length > 0) {\n    const flattened = flattenColdHistory(opts.coldHistory);\n    if (flattened) {\n      lines.push({\n        type: \"assistant\",\n        message: {\n          role: \"assistant\",\n          content: textBlock(`Prior conversation context:\\n${flattened}`),\n        },\n      });\n    }\n  }\n\n  lines.push({\n    type: \"user\",\n    message: { role: \"user\", content: textBlock(userInputToText(opts.input)) },\n  });\n\n  return lines;\n}\n\nexport function serializeStreamJsonInput(lines: Array<ClaudeStreamJsonLine>): string {\n  return lines.map((l) => JSON.stringify(l)).join(\"\\n\") + \"\\n\";\n}\n\n// ── 출력 어댑터 ────────────────────────────────────────────────────\n//\n// Claude stdout(JSONL)을 qgrid deltas + final result 로 변환한다.\n\ninterface ClaudeUsage {\n  input_tokens?: number;\n  output_tokens?: number;\n  cache_creation_input_tokens?: number;\n  cache_read_input_tokens?: number;\n  cache_creation?: {\n    ephemeral_5m_input_tokens?: number;\n    ephemeral_1h_input_tokens?: number;\n  };\n  iterations?: Array<{\n    type?: string;\n    model?: string;\n  }>;\n}\n\nexport interface ClaudeStreamResult {\n  text: string;\n  usage: ProviderTokenUsageBreakdown;\n  durationMs: number;\n  costUsd: number;\n  // quota 소진(\"You've hit ...\") 감지. dispatcher 가 QuotaError 로 변환.\n  quotaExhausted: boolean;\n  // result.is_error / terminal model_error 등. dispatcher 가 에러로 변환.\n  isError: boolean;\n  // 진단용: CC result 라인의 subtype(\"success\" | \"error_max_turns\" | ...) 과 terminal_reason.\n  // isError 판정 사유를 에러 메시지에 드러내기 위해 보존한다(SON-495).\n  subtype?: string;\n  terminalReason?: string;\n  // 실제 최종 응답을 만든 모델. Fable refusal fallback 때 requested model 과 다르다.\n  servedModel?: string;\n  stopReason?: string;\n  refusal?: {\n    category?: string;\n    explanation?: string;\n  };\n  modelFallbacks?: Array<ModelFallback>;\n}\n\nexport interface ClaudeStreamJsonState {\n  structuredOutputText?: string;\n  servedModel?: string;\n  stopReason?: string;\n  refusal?: {\n    category?: string;\n    explanation?: string;\n  };\n  modelFallbacks?: Array<ModelFallback>;\n  refusalWithoutFallback?: boolean;\n}\n\n// Anthropic usage 4 카테고리 → TokenUsageBreakdown.\n// Anthropic native usage 는 input/cache_creation/cache_read 를 서로 배타적인 카테고리로 준다.\n// 반면 qgrid 내부 표준(TokenUsageBreakdown)과 cost 계산은 inputTokens 를 \"전체 입력\n// (= non-cache input + cache creation + cache read)\" 으로 취급하고 cachedInputTokens/cacheCreationInputTokens\n// 를 그중 각 몫으로 다시 표시한다(OpenAI/Codex usage 와 같은 의미). 따라서 여기서 합쳐 표준화한다.\nfunction toUsageBreakdown(u: ClaudeUsage): ProviderTokenUsageBreakdown {\n  const input = u.input_tokens ?? 0;\n  const cacheCreate = u.cache_creation_input_tokens ?? 0;\n  const cacheRead = u.cache_read_input_tokens ?? 0;\n  const output = u.output_tokens ?? 0;\n  const totalInput = input + cacheCreate + cacheRead;\n  const cacheCreate5m = u.cache_creation?.ephemeral_5m_input_tokens;\n  const cacheCreate1h = u.cache_creation?.ephemeral_1h_input_tokens;\n  return {\n    totalTokens: totalInput + output,\n    inputTokens: totalInput,\n    cachedInputTokens: cacheRead,\n    cacheCreationInputTokens: cacheCreate,\n    ...(typeof cacheCreate5m === \"number\" ? { cacheCreationInputTokens5m: cacheCreate5m } : {}),\n    ...(typeof cacheCreate1h === \"number\" ? { cacheCreationInputTokens1h: cacheCreate1h } : {}),\n    outputTokens: output,\n    reasoningOutputTokens: 0,\n  };\n}\n\nfunction stripCodeFence(s: string): string {\n  return s\n    .trim()\n    .replace(/^```(?:json)?\\s*\\n?/i, \"\")\n    .replace(/\\n?```\\s*$/i, \"\");\n}\n\nfunction structuredOutputToolUseText(j: ResponseItem): string | undefined {\n  const message = asObject(j.message);\n  const content = message?.content;\n  if (!Array.isArray(content)) return undefined;\n\n  for (const raw of content) {\n    const block = asObject(raw);\n    if (!block) continue;\n    if (\n      block.type === \"tool_use\" &&\n      block.name === \"StructuredOutput\" &&\n      block.input !== undefined\n    ) {\n      return JSON.stringify(block.input);\n    }\n  }\n  return undefined;\n}\n\nfunction canonicalEventModel(model: string): string {\n  const withoutProvider = model.startsWith(\"anthropic/\") ? model.slice(\"anthropic/\".length) : model;\n  return withoutProvider.replace(/\\[1m\\]$/, \"\");\n}\n\nfunction optionalString(value: JsonValue | undefined): string | undefined {\n  return typeof value === \"string\" && value.length > 0 ? value : undefined;\n}\n\nfunction recordFallback(state: ClaudeStreamJsonState | undefined, fallback: ModelFallback): void {\n  if (!state) return;\n  const normalized: ModelFallback = {\n    ...fallback,\n    fromModel: canonicalEventModel(fallback.fromModel),\n    toModel: canonicalEventModel(fallback.toModel),\n  };\n  const existing = state.modelFallbacks?.find(\n    (item) =>\n      item.trigger === normalized.trigger &&\n      item.fromModel === normalized.fromModel &&\n      item.toModel === normalized.toModel,\n  );\n  if (existing) {\n    existing.category ??= normalized.category;\n    existing.explanation ??= normalized.explanation;\n  } else {\n    (state.modelFallbacks ??= []).push(normalized);\n  }\n  state.servedModel = normalized.toModel;\n  state.refusalWithoutFallback = false;\n}\n\nfunction updateRoutingFromUsage(\n  usage: ResponseItem | null,\n  state: ClaudeStreamJsonState | undefined,\n): void {\n  if (!state || !usage || !Array.isArray(usage.iterations)) return;\n\n  let previousModel: string | undefined;\n  for (const raw of usage.iterations) {\n    const iteration = asObject(raw);\n    if (!iteration) continue;\n    const model = optionalString(iteration.model);\n    const type = optionalString(iteration.type);\n    if (!model) continue;\n    const canonicalModel = canonicalEventModel(model);\n    if (type === \"fallback_message\" && previousModel) {\n      recordFallback(state, {\n        trigger: \"refusal\",\n        fromModel: previousModel,\n        toModel: canonicalModel,\n      });\n    }\n    previousModel = canonicalModel;\n    state.servedModel = canonicalModel;\n  }\n}\n\nfunction updateRoutingFromMessage(\n  message: ResponseItem | null,\n  state: ClaudeStreamJsonState | undefined,\n): void {\n  if (!state || !message) return;\n  const model = optionalString(message.model);\n  const canonicalModel = model ? canonicalEventModel(model) : undefined;\n  if (canonicalModel) state.servedModel = canonicalModel;\n  const stopReason = optionalString(message.stop_reason);\n  if (stopReason) {\n    state.stopReason = stopReason;\n    if (stopReason === \"refusal\") state.refusalWithoutFallback = true;\n    else if (state.modelFallbacks?.some((fallback) => fallback.toModel === canonicalModel)) {\n      state.refusalWithoutFallback = false;\n    }\n  }\n\n  const stopDetails = asObject(message.stop_details);\n  if (stopDetails?.type === \"refusal\" || stopReason === \"refusal\") {\n    state.refusal = {\n      category: optionalString(stopDetails?.category),\n      explanation: optionalString(stopDetails?.explanation),\n    };\n  }\n  updateRoutingFromUsage(asObject(message.usage), state);\n}\n\n// Processes one Claude stdout JSONL line. Returns final result on result event.\nexport function handleStreamJsonLine(\n  line: string,\n  onDelta: (text: string) => void,\n  opts?: { structuredOutput?: boolean; state?: ClaudeStreamJsonState },\n): ClaudeStreamResult | null {\n  const structuredOutput = opts?.structuredOutput ?? false;\n  const state = opts?.state;\n  const trimmed = line.trim();\n  if (!trimmed) return null;\n\n  let j: { [key: string]: JsonValue | undefined };\n  try {\n    j = JSON.parse(trimmed) as { [key: string]: JsonValue | undefined };\n  } catch {\n    return null;\n  }\n\n  if (j.type === \"stream_event\") {\n    const event = asObject(j.event);\n    if (event?.type === \"message_start\") {\n      updateRoutingFromMessage(asObject(event.message), state);\n    } else if (event?.type === \"message_delta\") {\n      const delta = asObject(event.delta);\n      const stopReason = optionalString(delta?.stop_reason);\n      if (state && stopReason) {\n        state.stopReason = stopReason;\n        if (stopReason === \"refusal\") state.refusalWithoutFallback = true;\n      }\n    }\n    if (event && event.type === \"content_block_delta\") {\n      const delta = asObject(event.delta);\n      if (delta) {\n        if (structuredOutput) {\n          if (delta.type === \"input_json_delta\" && typeof delta.partial_json === \"string\") {\n            onDelta(delta.partial_json);\n          }\n        } else {\n          if (delta.type === \"text_delta\" && typeof delta.text === \"string\") {\n            onDelta(delta.text);\n          }\n        }\n      }\n    }\n    return null;\n  }\n\n  if (j.type === \"system\") {\n    const subtype = optionalString(j.subtype);\n    if (subtype === \"model_refusal_fallback\") {\n      const fromModel = optionalString(j.originalModel) ?? optionalString(j.original_model);\n      const toModel = optionalString(j.fallbackModel) ?? optionalString(j.fallback_model);\n      if (fromModel && toModel) {\n        recordFallback(state, {\n          trigger: \"refusal\",\n          fromModel,\n          toModel,\n          category:\n            optionalString(j.apiRefusalCategory) ??\n            optionalString(j.api_refusal_category) ??\n            optionalString(j.refusalCategory) ??\n            optionalString(j.refusal_category),\n          explanation:\n            optionalString(j.apiRefusalExplanation) ??\n            optionalString(j.api_refusal_explanation) ??\n            optionalString(j.refusalExplanation) ??\n            optionalString(j.refusal_explanation),\n        });\n      }\n    } else if (subtype === \"model_refusal_no_fallback\" && state) {\n      const originalModel = optionalString(j.originalModel) ?? optionalString(j.original_model);\n      if (originalModel) state.servedModel = canonicalEventModel(originalModel);\n      state.stopReason = \"refusal\";\n      state.refusalWithoutFallback = true;\n      state.refusal = {\n        category:\n          optionalString(j.apiRefusalCategory) ??\n          optionalString(j.api_refusal_category) ??\n          optionalString(j.refusalCategory) ??\n          optionalString(j.refusal_category),\n        explanation:\n          optionalString(j.apiRefusalExplanation) ??\n          optionalString(j.api_refusal_explanation) ??\n          optionalString(j.refusalExplanation) ??\n          optionalString(j.refusal_explanation),\n      };\n    }\n    return null;\n  }\n\n  if (j.type === \"assistant\") {\n    updateRoutingFromMessage(asObject(j.message), state);\n    if (structuredOutput && state && state.structuredOutputText === undefined) {\n      const text = structuredOutputToolUseText(j);\n      if (text !== undefined) state.structuredOutputText = text;\n    }\n    return null;\n  }\n\n  if (j.type === \"result\") {\n    const subtype = typeof j.subtype === \"string\" ? j.subtype : undefined;\n    const terminalReason = typeof j.terminal_reason === \"string\" ? j.terminal_reason : undefined;\n    const resultSucceeded =\n      j.is_error !== true &&\n      terminalReason !== \"model_error\" &&\n      (subtype === undefined || subtype === \"success\");\n    let text: string;\n    const preservedStructuredOutput = structuredOutput ? state?.structuredOutputText : undefined;\n    // Claude Code는 StructuredOutput 스키마 검증 실패 후 내부 재시도를 할 수 있다. assistant\n    // 이벤트의 첫 tool input은 거절된 시도일 수 있으므로, 성공 result가 제공한 최종 검증값을\n    // 우선한다. 첫 입력 보존값은 max_turns/retry 초과처럼 성공 result가 없는 진단 경로용이다.\n    if (structuredOutput && resultSucceeded && j.structured_output !== undefined) {\n      text = JSON.stringify(j.structured_output);\n    } else if (preservedStructuredOutput !== undefined) {\n      text = preservedStructuredOutput;\n    } else if (j.structured_output !== undefined) {\n      text = JSON.stringify(j.structured_output);\n    } else {\n      text = stripCodeFence(typeof j.result === \"string\" ? j.result : \"\");\n    }\n\n    const rawUsage = asObject(j.usage) ?? {};\n    updateRoutingFromUsage(rawUsage, state);\n    const resultModel = optionalString(j.model);\n    if (state && resultModel && !state.servedModel) {\n      state.servedModel = canonicalEventModel(resultModel);\n    }\n    const resultStopReason = optionalString(j.stop_reason);\n    if (state && resultStopReason) {\n      state.stopReason = resultStopReason;\n      if (resultStopReason === \"refusal\") state.refusalWithoutFallback = true;\n    }\n    const usage = toUsageBreakdown(rawUsage as ClaudeUsage);\n    const quotaExhausted = text.startsWith(\"You've hit\");\n\n    // SON-495: 비정상 종료(error_max_structured_output_retries 등)는 정직하게 에러로 처리한다.\n    // CC structured output 은 constrained decoding 이 아니라 \"tool input 생성 후 사후 AJV 검증\"이라\n    // 모델이 가끔 placeholder($PARAMETER_NAME)·거부(\"just kidding\")·필드 누락(advance) 같은 발작/\n    // 불완전 출력을 낸다. 이를 \"거의 맞았으니 살리자\"고 흘리면 클라이언트 검증에서 깨지거나(필드 누락)\n    // 쓰레기가 새어 나간다(실측 11674/11675). 알려진 best practice(refusal/degenerate output 은 살리지\n    // 말고 graceful error)대로, subtype != success 는 그대로 에러로 둔다. 클라이언트가 그 턴을 실패로\n    // 다루게 한다(스트림이라 자동 재시도 없음 — 시간 2배 방지).\n    const isError =\n      j.is_error === true ||\n      j.terminal_reason === \"model_error\" ||\n      (subtype !== undefined && subtype !== \"success\") ||\n      state?.refusalWithoutFallback === true;\n\n    return {\n      text,\n      usage,\n      durationMs: typeof j.duration_ms === \"number\" ? j.duration_ms : 0,\n      costUsd: typeof j.total_cost_usd === \"number\" ? j.total_cost_usd : 0,\n      quotaExhausted,\n      isError,\n      subtype,\n      terminalReason,\n      servedModel: state?.servedModel,\n      stopReason: state?.stopReason,\n      refusal: state?.refusal,\n      modelFallbacks: state?.modelFallbacks,\n    };\n  }\n\n  return null;\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"stream-json-adapter.js","names":[],"sources":["../../../../src/utils/providers/anthropic/stream-json-adapter.ts"],"sourcesContent":["/**\n * Claude CLI stream-json adapter.\n *\n * Input: qgrid history/input -> Claude JSONL stdin.\n * Output: Claude JSONL stdout -> qgrid deltas + final result metadata.\n *\n * Previous conversation items are flattened into one assistant context line.\n * The only executable user line is the current input.\n */\n\nimport {\n  type ModelFallback,\n  type ProviderTokenUsageBreakdown,\n} from \"../common/provider-dispatcher\";\nimport { type JsonValue, type UserInput } from \"../common/provider-types\";\nimport { stripFences } from \"./fence-strip\";\n\n// ── 입력 어댑터 ────────────────────────────────────────────────────\n\n// Claude stream-json 입력 한 줄(JSONL). Envelope fields are added in claude-session.\nexport interface ClaudeStreamJsonLine {\n  type: \"user\" | \"assistant\";\n  message: {\n    role: \"user\" | \"assistant\";\n    content: Array<{ type: \"text\"; text: string }>;\n  };\n}\n\nfunction userInputToText(input: Array<UserInput>): string {\n  return input\n    .filter((i): i is Extract<UserInput, { type: \"text\" }> => i.type === \"text\")\n    .map((i) => i.text)\n    .join(\"\\n\");\n}\n\nfunction textBlock(text: string): Array<{ type: \"text\"; text: string }> {\n  return [{ type: \"text\", text }];\n}\n\n// OpenAI Responses item(coldHistory item) 최소 shape.\n// extractPromptAndHistory(ai-sdk/utils.ts) 가 만드는 형식:\n//   { type:\"message\", role:\"user\", content:[{type:\"input_text\", text}] }\n//   { type:\"message\", role:\"assistant\", content:[{type:\"output_text\", text}] }\n//   { type:\"function_call\", name, arguments, call_id }\n//   { type:\"function_call_output\", call_id, output }\ntype ResponseItem = { [key: string]: JsonValue | undefined };\n\nfunction asObject(v: JsonValue | undefined): ResponseItem | null {\n  return typeof v === \"object\" && v !== null && !Array.isArray(v) ? (v as ResponseItem) : null;\n}\n\nfunction responseItemText(item: ResponseItem): string {\n  const content = item.content;\n  if (!Array.isArray(content)) return \"\";\n  return content\n    .map((c) => {\n      const obj = asObject(c);\n      return obj && typeof obj.text === \"string\" ? obj.text : \"\";\n    })\n    .filter(Boolean)\n    .join(\"\\n\");\n}\n\nfunction flattenColdHistory(coldHistory: Array<JsonValue>): string {\n  const parts: Array<string> = [];\n  for (const raw of coldHistory) {\n    const item = asObject(raw);\n    if (!item) continue;\n\n    if (item.type === \"message\" && item.role === \"assistant\") {\n      parts.push(`Assistant: ${responseItemText(item)}`);\n    } else if (item.type === \"message\" && item.role === \"user\") {\n      parts.push(`User: ${responseItemText(item)}`);\n    } else if (item.type === \"function_call\") {\n      const name = typeof item.name === \"string\" ? item.name : \"\";\n      const args =\n        typeof item.arguments === \"string\" ? item.arguments : JSON.stringify(item.arguments ?? {});\n      parts.push(`Tool call: ${name}(${args})`);\n    } else if (item.type === \"function_call_output\") {\n      const output =\n        typeof item.output === \"string\" ? item.output : JSON.stringify(item.output ?? \"\");\n      parts.push(`Tool result: ${output}`);\n    }\n  }\n  return parts.join(\"\\n\");\n}\n\nexport function buildStreamJsonInput(opts: {\n  coldHistory?: Array<JsonValue>;\n  input: Array<UserInput>;\n}): Array<ClaudeStreamJsonLine> {\n  const lines: Array<ClaudeStreamJsonLine> = [];\n\n  if (opts.coldHistory && opts.coldHistory.length > 0) {\n    const flattened = flattenColdHistory(opts.coldHistory);\n    if (flattened) {\n      lines.push({\n        type: \"assistant\",\n        message: {\n          role: \"assistant\",\n          content: textBlock(`Prior conversation context:\\n${flattened}`),\n        },\n      });\n    }\n  }\n\n  lines.push({\n    type: \"user\",\n    message: { role: \"user\", content: textBlock(userInputToText(opts.input)) },\n  });\n\n  return lines;\n}\n\nexport function serializeStreamJsonInput(lines: Array<ClaudeStreamJsonLine>): string {\n  return lines.map((l) => JSON.stringify(l)).join(\"\\n\") + \"\\n\";\n}\n\n// ── 출력 어댑터 ────────────────────────────────────────────────────\n//\n// Claude stdout(JSONL)을 qgrid deltas + final result 로 변환한다.\n\ninterface ClaudeUsage {\n  input_tokens?: number;\n  output_tokens?: number;\n  cache_creation_input_tokens?: number;\n  cache_read_input_tokens?: number;\n  cache_creation?: {\n    ephemeral_5m_input_tokens?: number;\n    ephemeral_1h_input_tokens?: number;\n  };\n  iterations?: Array<{\n    type?: string;\n    model?: string;\n  }>;\n}\n\nexport interface ClaudeStreamResult {\n  text: string;\n  usage: ProviderTokenUsageBreakdown;\n  durationMs: number;\n  costUsd: number;\n  // quota 소진(\"You've hit ...\") 감지. dispatcher 가 QuotaError 로 변환.\n  quotaExhausted: boolean;\n  // result.is_error / terminal model_error 등. dispatcher 가 에러로 변환.\n  isError: boolean;\n  // 진단용: CC result 라인의 subtype(\"success\" | \"error_max_turns\" | ...) 과 terminal_reason.\n  // isError 판정 사유를 에러 메시지에 드러내기 위해 보존한다(SON-495).\n  subtype?: string;\n  terminalReason?: string;\n  // 실제 최종 응답을 만든 모델. Fable refusal fallback 때 requested model 과 다르다.\n  servedModel?: string;\n  stopReason?: string;\n  refusal?: {\n    category?: string;\n    explanation?: string;\n  };\n  modelFallbacks?: Array<ModelFallback>;\n}\n\nexport interface ClaudeStreamJsonState {\n  structuredOutputText?: string;\n  servedModel?: string;\n  stopReason?: string;\n  refusal?: {\n    category?: string;\n    explanation?: string;\n  };\n  modelFallbacks?: Array<ModelFallback>;\n  refusalWithoutFallback?: boolean;\n}\n\n// Anthropic usage 4 카테고리 → TokenUsageBreakdown.\n// Anthropic native usage 는 input/cache_creation/cache_read 를 서로 배타적인 카테고리로 준다.\n// 반면 qgrid 내부 표준(TokenUsageBreakdown)과 cost 계산은 inputTokens 를 \"전체 입력\n// (= non-cache input + cache creation + cache read)\" 으로 취급하고 cachedInputTokens/cacheCreationInputTokens\n// 를 그중 각 몫으로 다시 표시한다(OpenAI/Codex usage 와 같은 의미). 따라서 여기서 합쳐 표준화한다.\nfunction toUsageBreakdown(u: ClaudeUsage): ProviderTokenUsageBreakdown {\n  const input = u.input_tokens ?? 0;\n  const cacheCreate = u.cache_creation_input_tokens ?? 0;\n  const cacheRead = u.cache_read_input_tokens ?? 0;\n  const output = u.output_tokens ?? 0;\n  const totalInput = input + cacheCreate + cacheRead;\n  const cacheCreate5m = u.cache_creation?.ephemeral_5m_input_tokens;\n  const cacheCreate1h = u.cache_creation?.ephemeral_1h_input_tokens;\n  return {\n    totalTokens: totalInput + output,\n    inputTokens: totalInput,\n    cachedInputTokens: cacheRead,\n    cacheCreationInputTokens: cacheCreate,\n    ...(typeof cacheCreate5m === \"number\" ? { cacheCreationInputTokens5m: cacheCreate5m } : {}),\n    ...(typeof cacheCreate1h === \"number\" ? { cacheCreationInputTokens1h: cacheCreate1h } : {}),\n    outputTokens: output,\n    reasoningOutputTokens: 0,\n  };\n}\n\nfunction structuredOutputToolUseText(j: ResponseItem): string | undefined {\n  const message = asObject(j.message);\n  const content = message?.content;\n  if (!Array.isArray(content)) return undefined;\n\n  for (const raw of content) {\n    const block = asObject(raw);\n    if (!block) continue;\n    if (\n      block.type === \"tool_use\" &&\n      block.name === \"StructuredOutput\" &&\n      block.input !== undefined\n    ) {\n      return JSON.stringify(block.input);\n    }\n  }\n  return undefined;\n}\n\nfunction canonicalEventModel(model: string): string {\n  const withoutProvider = model.startsWith(\"anthropic/\") ? model.slice(\"anthropic/\".length) : model;\n  return withoutProvider.replace(/\\[1m\\]$/, \"\");\n}\n\nfunction optionalString(value: JsonValue | undefined): string | undefined {\n  return typeof value === \"string\" && value.length > 0 ? value : undefined;\n}\n\nfunction recordFallback(state: ClaudeStreamJsonState | undefined, fallback: ModelFallback): void {\n  if (!state) return;\n  const normalized: ModelFallback = {\n    ...fallback,\n    fromModel: canonicalEventModel(fallback.fromModel),\n    toModel: canonicalEventModel(fallback.toModel),\n  };\n  const existing = state.modelFallbacks?.find(\n    (item) =>\n      item.trigger === normalized.trigger &&\n      item.fromModel === normalized.fromModel &&\n      item.toModel === normalized.toModel,\n  );\n  if (existing) {\n    existing.category ??= normalized.category;\n    existing.explanation ??= normalized.explanation;\n  } else {\n    (state.modelFallbacks ??= []).push(normalized);\n  }\n  state.servedModel = normalized.toModel;\n  state.refusalWithoutFallback = false;\n}\n\nfunction updateRoutingFromUsage(\n  usage: ResponseItem | null,\n  state: ClaudeStreamJsonState | undefined,\n): void {\n  if (!state || !usage || !Array.isArray(usage.iterations)) return;\n\n  let previousModel: string | undefined;\n  for (const raw of usage.iterations) {\n    const iteration = asObject(raw);\n    if (!iteration) continue;\n    const model = optionalString(iteration.model);\n    const type = optionalString(iteration.type);\n    if (!model) continue;\n    const canonicalModel = canonicalEventModel(model);\n    if (type === \"fallback_message\" && previousModel) {\n      recordFallback(state, {\n        trigger: \"refusal\",\n        fromModel: previousModel,\n        toModel: canonicalModel,\n      });\n    }\n    previousModel = canonicalModel;\n    state.servedModel = canonicalModel;\n  }\n}\n\nfunction updateRoutingFromMessage(\n  message: ResponseItem | null,\n  state: ClaudeStreamJsonState | undefined,\n): void {\n  if (!state || !message) return;\n  const model = optionalString(message.model);\n  const canonicalModel = model ? canonicalEventModel(model) : undefined;\n  if (canonicalModel) state.servedModel = canonicalModel;\n  const stopReason = optionalString(message.stop_reason);\n  if (stopReason) {\n    state.stopReason = stopReason;\n    if (stopReason === \"refusal\") state.refusalWithoutFallback = true;\n    else if (state.modelFallbacks?.some((fallback) => fallback.toModel === canonicalModel)) {\n      state.refusalWithoutFallback = false;\n    }\n  }\n\n  const stopDetails = asObject(message.stop_details);\n  if (stopDetails?.type === \"refusal\" || stopReason === \"refusal\") {\n    state.refusal = {\n      category: optionalString(stopDetails?.category),\n      explanation: optionalString(stopDetails?.explanation),\n    };\n  }\n  updateRoutingFromUsage(asObject(message.usage), state);\n}\n\n// Processes one Claude stdout JSONL line. Returns final result on result event.\nexport function handleStreamJsonLine(\n  line: string,\n  onDelta: (text: string) => void,\n  opts?: { structuredOutput?: boolean; state?: ClaudeStreamJsonState },\n): ClaudeStreamResult | null {\n  const structuredOutput = opts?.structuredOutput ?? false;\n  const state = opts?.state;\n  const trimmed = line.trim();\n  if (!trimmed) return null;\n\n  let j: { [key: string]: JsonValue | undefined };\n  try {\n    j = JSON.parse(trimmed) as { [key: string]: JsonValue | undefined };\n  } catch {\n    return null;\n  }\n\n  if (j.type === \"stream_event\") {\n    const event = asObject(j.event);\n    if (event?.type === \"message_start\") {\n      updateRoutingFromMessage(asObject(event.message), state);\n    } else if (event?.type === \"message_delta\") {\n      const delta = asObject(event.delta);\n      const stopReason = optionalString(delta?.stop_reason);\n      if (state && stopReason) {\n        state.stopReason = stopReason;\n        if (stopReason === \"refusal\") state.refusalWithoutFallback = true;\n      }\n    }\n    if (event && event.type === \"content_block_delta\") {\n      const delta = asObject(event.delta);\n      if (delta) {\n        if (structuredOutput) {\n          if (delta.type === \"input_json_delta\" && typeof delta.partial_json === \"string\") {\n            onDelta(delta.partial_json);\n          }\n        } else {\n          if (delta.type === \"text_delta\" && typeof delta.text === \"string\") {\n            onDelta(delta.text);\n          }\n        }\n      }\n    }\n    return null;\n  }\n\n  if (j.type === \"system\") {\n    const subtype = optionalString(j.subtype);\n    if (subtype === \"model_refusal_fallback\") {\n      const fromModel = optionalString(j.originalModel) ?? optionalString(j.original_model);\n      const toModel = optionalString(j.fallbackModel) ?? optionalString(j.fallback_model);\n      if (fromModel && toModel) {\n        recordFallback(state, {\n          trigger: \"refusal\",\n          fromModel,\n          toModel,\n          category:\n            optionalString(j.apiRefusalCategory) ??\n            optionalString(j.api_refusal_category) ??\n            optionalString(j.refusalCategory) ??\n            optionalString(j.refusal_category),\n          explanation:\n            optionalString(j.apiRefusalExplanation) ??\n            optionalString(j.api_refusal_explanation) ??\n            optionalString(j.refusalExplanation) ??\n            optionalString(j.refusal_explanation),\n        });\n      }\n    } else if (subtype === \"model_refusal_no_fallback\" && state) {\n      const originalModel = optionalString(j.originalModel) ?? optionalString(j.original_model);\n      if (originalModel) state.servedModel = canonicalEventModel(originalModel);\n      state.stopReason = \"refusal\";\n      state.refusalWithoutFallback = true;\n      state.refusal = {\n        category:\n          optionalString(j.apiRefusalCategory) ??\n          optionalString(j.api_refusal_category) ??\n          optionalString(j.refusalCategory) ??\n          optionalString(j.refusal_category),\n        explanation:\n          optionalString(j.apiRefusalExplanation) ??\n          optionalString(j.api_refusal_explanation) ??\n          optionalString(j.refusalExplanation) ??\n          optionalString(j.refusal_explanation),\n      };\n    }\n    return null;\n  }\n\n  if (j.type === \"assistant\") {\n    updateRoutingFromMessage(asObject(j.message), state);\n    if (structuredOutput && state && state.structuredOutputText === undefined) {\n      const text = structuredOutputToolUseText(j);\n      if (text !== undefined) state.structuredOutputText = text;\n    }\n    return null;\n  }\n\n  if (j.type === \"result\") {\n    const subtype = typeof j.subtype === \"string\" ? j.subtype : undefined;\n    const terminalReason = typeof j.terminal_reason === \"string\" ? j.terminal_reason : undefined;\n    const resultSucceeded =\n      j.is_error !== true &&\n      terminalReason !== \"model_error\" &&\n      (subtype === undefined || subtype === \"success\");\n    let text: string;\n    const preservedStructuredOutput = structuredOutput ? state?.structuredOutputText : undefined;\n    // Claude Code는 StructuredOutput 스키마 검증 실패 후 내부 재시도를 할 수 있다. assistant\n    // 이벤트의 첫 tool input은 거절된 시도일 수 있으므로, 성공 result가 제공한 최종 검증값을\n    // 우선한다. 첫 입력 보존값은 max_turns/retry 초과처럼 성공 result가 없는 진단 경로용이다.\n    if (structuredOutput && resultSucceeded && j.structured_output !== undefined) {\n      text = JSON.stringify(j.structured_output);\n    } else if (preservedStructuredOutput !== undefined) {\n      text = preservedStructuredOutput;\n    } else if (j.structured_output !== undefined) {\n      text = JSON.stringify(j.structured_output);\n    } else {\n      text = stripFences(typeof j.result === \"string\" ? j.result : \"\");\n    }\n\n    const rawUsage = asObject(j.usage) ?? {};\n    updateRoutingFromUsage(rawUsage, state);\n    const resultModel = optionalString(j.model);\n    if (state && resultModel && !state.servedModel) {\n      state.servedModel = canonicalEventModel(resultModel);\n    }\n    const resultStopReason = optionalString(j.stop_reason);\n    if (state && resultStopReason) {\n      state.stopReason = resultStopReason;\n      if (resultStopReason === \"refusal\") state.refusalWithoutFallback = true;\n    }\n    const usage = toUsageBreakdown(rawUsage as ClaudeUsage);\n    const quotaExhausted = text.startsWith(\"You've hit\");\n\n    // SON-495: 비정상 종료(error_max_structured_output_retries 등)는 정직하게 에러로 처리한다.\n    // CC structured output 은 constrained decoding 이 아니라 \"tool input 생성 후 사후 AJV 검증\"이라\n    // 모델이 가끔 placeholder($PARAMETER_NAME)·거부(\"just kidding\")·필드 누락(advance) 같은 발작/\n    // 불완전 출력을 낸다. 이를 \"거의 맞았으니 살리자\"고 흘리면 클라이언트 검증에서 깨지거나(필드 누락)\n    // 쓰레기가 새어 나간다(실측 11674/11675). 알려진 best practice(refusal/degenerate output 은 살리지\n    // 말고 graceful error)대로, subtype != success 는 그대로 에러로 둔다. 클라이언트가 그 턴을 실패로\n    // 다루게 한다(스트림이라 자동 재시도 없음 — 시간 2배 방지).\n    const isError =\n      j.is_error === true ||\n      j.terminal_reason === \"model_error\" ||\n      (subtype !== undefined && subtype !== \"success\") ||\n      state?.refusalWithoutFallback === true;\n\n    return {\n      text,\n      usage,\n      durationMs: typeof j.duration_ms === \"number\" ? j.duration_ms : 0,\n      costUsd: typeof j.total_cost_usd === \"number\" ? j.total_cost_usd : 0,\n      quotaExhausted,\n      isError,\n      subtype,\n      terminalReason,\n      servedModel: state?.servedModel,\n      stopReason: state?.stopReason,\n      refusal: state?.refusal,\n      modelFallbacks: state?.modelFallbacks,\n    };\n  }\n\n  return null;\n}\n"],"mappings":"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"}

package/bundle/dist/utils/providers/common/model-cost.js

@@ -120,4 +120,4 @@ function calculateCostUsd(model, usage, atMs = Date.now()) {
 //#endregion
 export { calculateCostUsd, getModelCosts };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"model-cost.js","names":[],"sources":["../../../../src/utils/providers/common/model-cost.ts"],"sourcesContent":["/**\n * 모델별 토큰 가격 테이블 + cost 계산.\n *\n * claude code 와 동일 패턴: 클라이언트에서 가격 테이블로 직접 계산.\n * 가격 단위: USD per 1M tokens.\n *\n * OpenAI 모델 목록: codex app-server model/list RPC 로 실측 (2026-05-18)\n *\n * @see https://platform.openai.com/docs/pricing\n * @see https://platform.claude.com/docs/en/about-claude/pricing\n */\n\nexport interface ModelCosts {\n  inputTokens: number;\n  outputTokens: number;\n  cachedInputTokens: number;\n  /** TTL breakdown 이 없는 usage 에 적용할 cache write fallback 단가. */\n  cacheCreationInputTokens?: number;\n  cacheCreationInputTokens5m?: number;\n  cacheCreationInputTokens1h?: number;\n  /**\n   * long-context 할증. 전체 입력 토큰(input_tokens, cache_read 포함)이 threshold 초과 시\n   * 초과분만이 아니라 요청 전체(full session)에 배율 적용.\n   */\n  longContext?: {\n    threshold: number;\n    inputMultiplier: number;\n    cachedInputMultiplier: number;\n    outputMultiplier: number;\n  };\n}\n\n// ── OpenAI — codex app-server 에서 사용 가능한 모델 ─────────────────\n//\n// 가격 출처: https://developers.openai.com/api/docs/models (2026-07-18 확인)\n// 신모델 출시마다 단가가 바뀌므로(5.2→5.4→5.5) 모델 추가 시 반드시 공식 페이지 재확인해야함\n\n// GPT-5.4에서 처음 도입된 long-context 할증 (5.2/5.3-codex는 해당 없음, 5.4-mini/nano는 공식 표에서 long-context 단가 없음)\n// 272K 초과 시 input 2x / cached 2x / output 1.5x — 초과분만이 아닌 세션 전체에 적용됨\n// @see https://developers.openai.com/api/docs/models/gpt-5.5 (\"prompts with >272K input tokens\")\nconst LONG_CONTEXT_272K: NonNullable<ModelCosts[\"longContext\"]> = {\n  threshold: 272_000,\n  inputMultiplier: 2,\n  cachedInputMultiplier: 2,\n  outputMultiplier: 1.5,\n};\n\nconst OPENAI_COSTS: Record<string, ModelCosts> = {\n  // GPT-5.6 Sol, Terra, Luna. OpenAI native API 는 1.05M context / 128K max output 이지만,\n  // qgrid 의 codex app-server 경로는 context_window=372K (max_context_window 도 372K,\n  // effective 95% ≈ 353K) 로 제한된다 — codex 0.144.1 models_cache 실측 (2026-07-10).\n  // cache write 는 uncached input 의 1.25x 로 과금되지만, codex app-server usage\n  // (TokenUsageBreakdown) 에 cache write 토큰 필드가 없어 현재 OpenAI 실행 경로의\n  // cost 계산에서는 항상 0 으로 잡힌다 → 그만큼 과소집계. 단가는 외부 logger/manual\n  // usage 입력과 향후 프로토콜 확장을 위해 유지한다.\n  // @see https://developers.openai.com/api/docs/models/gpt-5.6-sol\n  // @see https://developers.openai.com/api/docs/models/gpt-5.6-terra\n  // @see https://developers.openai.com/api/docs/models/gpt-5.6-luna\n  \"gpt-5.6-sol\": {\n    inputTokens: 5,\n    outputTokens: 30,\n    cachedInputTokens: 0.5,\n    cacheCreationInputTokens: 6.25,\n    longContext: LONG_CONTEXT_272K,\n  },\n  \"gpt-5.6-terra\": {\n    inputTokens: 2.5,\n    outputTokens: 15,\n    cachedInputTokens: 0.25,\n    cacheCreationInputTokens: 3.125,\n    longContext: LONG_CONTEXT_272K,\n  },\n  \"gpt-5.6-luna\": {\n    inputTokens: 1,\n    outputTokens: 6,\n    cachedInputTokens: 0.1,\n    cacheCreationInputTokens: 1.25,\n    longContext: LONG_CONTEXT_272K,\n  },\n  // https://openai.com/index/introducing-gpt-5-5/ (2026-04 출시)\n  \"gpt-5.5\": {\n    inputTokens: 5,\n    outputTokens: 30,\n    cachedInputTokens: 0.5,\n    longContext: LONG_CONTEXT_272K,\n  },\n  // https://openai.com/index/introducing-gpt-5-4/ (2026-03 출시)\n  \"gpt-5.4\": {\n    inputTokens: 2.5,\n    outputTokens: 15,\n    cachedInputTokens: 0.25,\n    longContext: LONG_CONTEXT_272K,\n  },\n  \"gpt-5.4-mini\": { inputTokens: 0.75, outputTokens: 4.5, cachedInputTokens: 0.075 },\n  // gpt-5.2와 동일 단가 (cached = input의 10%)\n  \"gpt-5.3-codex\": { inputTokens: 1.75, outputTokens: 14, cachedInputTokens: 0.175 },\n  // https://openai.com/index/introducing-gpt-5-2/ (cached input 90% 할인 명시)\n  \"gpt-5.2\": { inputTokens: 1.75, outputTokens: 14, cachedInputTokens: 0.175 },\n};\n\n// ── Anthropic ───────────────────────────────────────────────────────\n\nfunction anthropicCosts(inputTokens: number, outputTokens: number): ModelCosts {\n  return {\n    inputTokens,\n    outputTokens,\n    cachedInputTokens: inputTokens / 10,\n    // Claude Code subscription OAuth 는 1h TTL 을 자동 선택한다. 구버전처럼 응답에\n    // TTL breakdown 이 없을 때만 이 1h 단가를 fallback 으로 사용한다.\n    cacheCreationInputTokens: inputTokens * 2,\n    cacheCreationInputTokens5m: inputTokens * 1.25,\n    cacheCreationInputTokens1h: inputTokens * 2,\n  };\n}\n\nconst ANTHROPIC_COSTS: Record<string, ModelCosts> = {\n  \"claude-fable-5\": anthropicCosts(10, 50),\n  sonnet: anthropicCosts(3, 15),\n  \"claude-3-5-haiku\": anthropicCosts(0.8, 4),\n  \"claude-haiku-4-5\": anthropicCosts(1, 5),\n  \"claude-3-5-sonnet\": anthropicCosts(3, 15),\n  \"claude-3-7-sonnet\": anthropicCosts(3, 15),\n  \"claude-sonnet-4\": anthropicCosts(3, 15),\n  \"claude-sonnet-4-5\": anthropicCosts(3, 15),\n  \"claude-sonnet-4-6\": anthropicCosts(3, 15),\n  \"claude-sonnet-4-7\": anthropicCosts(3, 15),\n  \"claude-opus-4\": anthropicCosts(15, 75),\n  \"claude-opus-4-1\": anthropicCosts(15, 75),\n  \"claude-opus-4-5\": anthropicCosts(5, 25),\n  \"claude-opus-4-6\": anthropicCosts(5, 25),\n  \"claude-opus-4-7\": anthropicCosts(5, 25),\n  \"claude-opus-4-8\": anthropicCosts(5, 25),\n  \"claude-opus-5\": anthropicCosts(5, 25),\n};\n\n// Anthropic 공식 introductory pricing: 2026-08-31까지 $2/$10, 이후 $3/$15.\n// qgrid 는 요청 시점에 계산하므로 배포를 다시 하지 않아도 2026-09-01 UTC부터 표준 단가로 전환한다.\nconst CLAUDE_SONNET_5_INTRO_PRICING_END_MS = Date.UTC(2026, 8, 1);\nconst CLAUDE_SONNET_5_INTRO_COSTS = anthropicCosts(2, 10);\nconst CLAUDE_SONNET_5_STANDARD_COSTS = anthropicCosts(3, 15);\n\n// gpt-5.3-codex-spark 는 research preview 로 공식 token 단가가 아직 final 이 아니다.\n// 지원 타입은 유지하되, 공식 단가가 공개될 때까지 아래 generic estimate 로 계산한다.\n// @see https://help.openai.com/en/articles/20001106-codex-rate-card\nconst DEFAULT_COSTS: ModelCosts = { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 };\n\nexport function getModelCosts(model: string, atMs = Date.now()): ModelCosts {\n  const normalizedModel = (model.split(\"/\").pop() ?? model).replace(/\\[1m\\]$/i, \"\");\n  if (normalizedModel === \"claude-sonnet-5\") {\n    return atMs < CLAUDE_SONNET_5_INTRO_PRICING_END_MS\n      ? CLAUDE_SONNET_5_INTRO_COSTS\n      : CLAUDE_SONNET_5_STANDARD_COSTS;\n  }\n  return OPENAI_COSTS[normalizedModel] ?? ANTHROPIC_COSTS[normalizedModel] ?? DEFAULT_COSTS;\n}\n\nexport function calculateCostUsd(\n  model: string,\n  usage: {\n    inputTokens: number;\n    outputTokens: number;\n    cachedInputTokens?: number;\n    cacheCreationInputTokens?: number;\n    cacheCreationInputTokens5m?: number;\n    cacheCreationInputTokens1h?: number;\n  },\n  atMs = Date.now(),\n): number {\n  const costs = getModelCosts(model, atMs);\n  const cachedInput = usage.cachedInputTokens ?? 0;\n  const cacheCreationInput5m = Math.max(usage.cacheCreationInputTokens5m ?? 0, 0);\n  const cacheCreationInput1h = Math.max(usage.cacheCreationInputTokens1h ?? 0, 0);\n  const cacheCreationInput = Math.max(\n    usage.cacheCreationInputTokens ?? 0,\n    cacheCreationInput5m + cacheCreationInput1h,\n  );\n  const classifiedCacheCreationInput5m = Math.min(cacheCreationInput5m, cacheCreationInput);\n  const classifiedCacheCreationInput1h = Math.min(\n    cacheCreationInput1h,\n    cacheCreationInput - classifiedCacheCreationInput5m,\n  );\n  const unclassifiedCacheCreationInput =\n    cacheCreationInput - classifiedCacheCreationInput5m - classifiedCacheCreationInput1h;\n  const nonCachedInput = Math.max(usage.inputTokens - cachedInput - cacheCreationInput, 0);\n\n  // long-context 할증: 전체 입력(input_tokens, cache 포함)이 threshold 초과 시 요청 전체에 배율 적용\n  const lc = costs.longContext;\n  const isLongContext = lc !== undefined && usage.inputTokens > lc.threshold;\n  const inputRate = costs.inputTokens * (isLongContext ? lc.inputMultiplier : 1);\n  const cachedRate = costs.cachedInputTokens * (isLongContext ? lc.cachedInputMultiplier : 1);\n  const cacheCreationFallbackRate =\n    (costs.cacheCreationInputTokens ?? costs.inputTokens) *\n    (isLongContext ? lc.inputMultiplier : 1);\n  const cacheCreation5mRate =\n    (costs.cacheCreationInputTokens5m ?? costs.cacheCreationInputTokens ?? costs.inputTokens) *\n    (isLongContext ? lc.inputMultiplier : 1);\n  const cacheCreation1hRate =\n    (costs.cacheCreationInputTokens1h ?? costs.cacheCreationInputTokens ?? costs.inputTokens) *\n    (isLongContext ? lc.inputMultiplier : 1);\n  const outputRate = costs.outputTokens * (isLongContext ? lc.outputMultiplier : 1);\n\n  return (\n    (nonCachedInput / 1_000_000) * inputRate +\n    (usage.outputTokens / 1_000_000) * outputRate +\n    (cachedInput / 1_000_000) * cachedRate +\n    (unclassifiedCacheCreationInput / 1_000_000) * cacheCreationFallbackRate +\n    (classifiedCacheCreationInput5m / 1_000_000) * cacheCreation5mRate +\n    (classifiedCacheCreationInput1h / 1_000_000) * cacheCreation1hRate\n  );\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"model-cost.js","names":[],"sources":["../../../../src/utils/providers/common/model-cost.ts"],"sourcesContent":["/**\n * 모델별 토큰 가격 테이블 + cost 계산.\n *\n * claude code 와 동일 패턴: 클라이언트에서 가격 테이블로 직접 계산.\n * 가격 단위: USD per 1M tokens.\n *\n * OpenAI 모델 목록은 OpenAI 모델 문서와 현재 지원 목록을 기준으로 관리한다.\n *\n * @see https://platform.openai.com/docs/pricing\n * @see https://platform.claude.com/docs/en/about-claude/pricing\n */\n\nexport interface ModelCosts {\n  inputTokens: number;\n  outputTokens: number;\n  cachedInputTokens: number;\n  /** TTL breakdown 이 없는 usage 에 적용할 cache write fallback 단가. */\n  cacheCreationInputTokens?: number;\n  cacheCreationInputTokens5m?: number;\n  cacheCreationInputTokens1h?: number;\n  /**\n   * long-context 할증. 전체 입력 토큰(input_tokens, cache_read 포함)이 threshold 초과 시\n   * 초과분만이 아니라 요청 전체(full session)에 배율 적용.\n   */\n  longContext?: {\n    threshold: number;\n    inputMultiplier: number;\n    cachedInputMultiplier: number;\n    outputMultiplier: number;\n  };\n}\n\n// ── OpenAI ─────────────────────────────────────────────────────────\n//\n// 가격 출처: https://developers.openai.com/api/docs/models (2026-07-18 확인)\n// 신모델 출시마다 단가가 바뀌므로(5.2→5.4→5.5) 모델 추가 시 반드시 공식 페이지 재확인해야함\n\n// GPT-5.4에서 처음 도입된 long-context 할증 (5.2/5.3-codex는 해당 없음, 5.4-mini/nano는 공식 표에서 long-context 단가 없음)\n// 272K 초과 시 input 2x / cached 2x / output 1.5x — 초과분만이 아닌 세션 전체에 적용됨\n// @see https://developers.openai.com/api/docs/models/gpt-5.5 (\"prompts with >272K input tokens\")\nconst LONG_CONTEXT_272K: NonNullable<ModelCosts[\"longContext\"]> = {\n  threshold: 272_000,\n  inputMultiplier: 2,\n  cachedInputMultiplier: 2,\n  outputMultiplier: 1.5,\n};\n\nconst OPENAI_COSTS: Record<string, ModelCosts> = {\n  // GPT-5.6 Sol, Terra, Luna. cache write 단가는 외부 logger/manual usage 입력을 위해\n  // 유지한다. 현재 OpenAI 응답 usage 에 cache write 토큰 필드가 없으면 비용은 0으로 계산된다.\n  // @see https://developers.openai.com/api/docs/models/gpt-5.6-sol\n  // @see https://developers.openai.com/api/docs/models/gpt-5.6-terra\n  // @see https://developers.openai.com/api/docs/models/gpt-5.6-luna\n  \"gpt-5.6-sol\": {\n    inputTokens: 5,\n    outputTokens: 30,\n    cachedInputTokens: 0.5,\n    cacheCreationInputTokens: 6.25,\n    longContext: LONG_CONTEXT_272K,\n  },\n  \"gpt-5.6-terra\": {\n    inputTokens: 2.5,\n    outputTokens: 15,\n    cachedInputTokens: 0.25,\n    cacheCreationInputTokens: 3.125,\n    longContext: LONG_CONTEXT_272K,\n  },\n  \"gpt-5.6-luna\": {\n    inputTokens: 1,\n    outputTokens: 6,\n    cachedInputTokens: 0.1,\n    cacheCreationInputTokens: 1.25,\n    longContext: LONG_CONTEXT_272K,\n  },\n  // https://openai.com/index/introducing-gpt-5-5/ (2026-04 출시)\n  \"gpt-5.5\": {\n    inputTokens: 5,\n    outputTokens: 30,\n    cachedInputTokens: 0.5,\n    longContext: LONG_CONTEXT_272K,\n  },\n  // https://openai.com/index/introducing-gpt-5-4/ (2026-03 출시)\n  \"gpt-5.4\": {\n    inputTokens: 2.5,\n    outputTokens: 15,\n    cachedInputTokens: 0.25,\n    longContext: LONG_CONTEXT_272K,\n  },\n  \"gpt-5.4-mini\": { inputTokens: 0.75, outputTokens: 4.5, cachedInputTokens: 0.075 },\n  // gpt-5.2와 동일 단가 (cached = input의 10%)\n  \"gpt-5.3-codex\": { inputTokens: 1.75, outputTokens: 14, cachedInputTokens: 0.175 },\n  // https://openai.com/index/introducing-gpt-5-2/ (cached input 90% 할인 명시)\n  \"gpt-5.2\": { inputTokens: 1.75, outputTokens: 14, cachedInputTokens: 0.175 },\n};\n\n// ── Anthropic ───────────────────────────────────────────────────────\n\nfunction anthropicCosts(inputTokens: number, outputTokens: number): ModelCosts {\n  return {\n    inputTokens,\n    outputTokens,\n    cachedInputTokens: inputTokens / 10,\n    // Claude Code subscription OAuth 는 1h TTL 을 자동 선택한다. 구버전처럼 응답에\n    // TTL breakdown 이 없을 때만 이 1h 단가를 fallback 으로 사용한다.\n    cacheCreationInputTokens: inputTokens * 2,\n    cacheCreationInputTokens5m: inputTokens * 1.25,\n    cacheCreationInputTokens1h: inputTokens * 2,\n  };\n}\n\nconst ANTHROPIC_COSTS: Record<string, ModelCosts> = {\n  \"claude-fable-5\": anthropicCosts(10, 50),\n  sonnet: anthropicCosts(3, 15),\n  \"claude-3-5-haiku\": anthropicCosts(0.8, 4),\n  \"claude-haiku-4-5\": anthropicCosts(1, 5),\n  \"claude-3-5-sonnet\": anthropicCosts(3, 15),\n  \"claude-3-7-sonnet\": anthropicCosts(3, 15),\n  \"claude-sonnet-4\": anthropicCosts(3, 15),\n  \"claude-sonnet-4-5\": anthropicCosts(3, 15),\n  \"claude-sonnet-4-6\": anthropicCosts(3, 15),\n  \"claude-sonnet-4-7\": anthropicCosts(3, 15),\n  \"claude-opus-4\": anthropicCosts(15, 75),\n  \"claude-opus-4-1\": anthropicCosts(15, 75),\n  \"claude-opus-4-5\": anthropicCosts(5, 25),\n  \"claude-opus-4-6\": anthropicCosts(5, 25),\n  \"claude-opus-4-7\": anthropicCosts(5, 25),\n  \"claude-opus-4-8\": anthropicCosts(5, 25),\n  \"claude-opus-5\": anthropicCosts(5, 25),\n};\n\n// Anthropic 공식 introductory pricing: 2026-08-31까지 $2/$10, 이후 $3/$15.\n// qgrid 는 요청 시점에 계산하므로 배포를 다시 하지 않아도 2026-09-01 UTC부터 표준 단가로 전환한다.\nconst CLAUDE_SONNET_5_INTRO_PRICING_END_MS = Date.UTC(2026, 8, 1);\nconst CLAUDE_SONNET_5_INTRO_COSTS = anthropicCosts(2, 10);\nconst CLAUDE_SONNET_5_STANDARD_COSTS = anthropicCosts(3, 15);\n\n// gpt-5.3-codex-spark 는 research preview 로 공식 token 단가가 아직 final 이 아니다.\n// 지원 타입은 유지하되, 공식 단가가 공개될 때까지 아래 generic estimate 로 계산한다.\n// @see https://help.openai.com/en/articles/20001106-codex-rate-card\nconst DEFAULT_COSTS: ModelCosts = { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 };\n\nexport function getModelCosts(model: string, atMs = Date.now()): ModelCosts {\n  const normalizedModel = (model.split(\"/\").pop() ?? model).replace(/\\[1m\\]$/i, \"\");\n  if (normalizedModel === \"claude-sonnet-5\") {\n    return atMs < CLAUDE_SONNET_5_INTRO_PRICING_END_MS\n      ? CLAUDE_SONNET_5_INTRO_COSTS\n      : CLAUDE_SONNET_5_STANDARD_COSTS;\n  }\n  return OPENAI_COSTS[normalizedModel] ?? ANTHROPIC_COSTS[normalizedModel] ?? DEFAULT_COSTS;\n}\n\nexport function calculateCostUsd(\n  model: string,\n  usage: {\n    inputTokens: number;\n    outputTokens: number;\n    cachedInputTokens?: number;\n    cacheCreationInputTokens?: number;\n    cacheCreationInputTokens5m?: number;\n    cacheCreationInputTokens1h?: number;\n  },\n  atMs = Date.now(),\n): number {\n  const costs = getModelCosts(model, atMs);\n  const cachedInput = usage.cachedInputTokens ?? 0;\n  const cacheCreationInput5m = Math.max(usage.cacheCreationInputTokens5m ?? 0, 0);\n  const cacheCreationInput1h = Math.max(usage.cacheCreationInputTokens1h ?? 0, 0);\n  const cacheCreationInput = Math.max(\n    usage.cacheCreationInputTokens ?? 0,\n    cacheCreationInput5m + cacheCreationInput1h,\n  );\n  const classifiedCacheCreationInput5m = Math.min(cacheCreationInput5m, cacheCreationInput);\n  const classifiedCacheCreationInput1h = Math.min(\n    cacheCreationInput1h,\n    cacheCreationInput - classifiedCacheCreationInput5m,\n  );\n  const unclassifiedCacheCreationInput =\n    cacheCreationInput - classifiedCacheCreationInput5m - classifiedCacheCreationInput1h;\n  const nonCachedInput = Math.max(usage.inputTokens - cachedInput - cacheCreationInput, 0);\n\n  // long-context 할증: 전체 입력(input_tokens, cache 포함)이 threshold 초과 시 요청 전체에 배율 적용\n  const lc = costs.longContext;\n  const isLongContext = lc !== undefined && usage.inputTokens > lc.threshold;\n  const inputRate = costs.inputTokens * (isLongContext ? lc.inputMultiplier : 1);\n  const cachedRate = costs.cachedInputTokens * (isLongContext ? lc.cachedInputMultiplier : 1);\n  const cacheCreationFallbackRate =\n    (costs.cacheCreationInputTokens ?? costs.inputTokens) *\n    (isLongContext ? lc.inputMultiplier : 1);\n  const cacheCreation5mRate =\n    (costs.cacheCreationInputTokens5m ?? costs.cacheCreationInputTokens ?? costs.inputTokens) *\n    (isLongContext ? lc.inputMultiplier : 1);\n  const cacheCreation1hRate =\n    (costs.cacheCreationInputTokens1h ?? costs.cacheCreationInputTokens ?? costs.inputTokens) *\n    (isLongContext ? lc.inputMultiplier : 1);\n  const outputRate = costs.outputTokens * (isLongContext ? lc.outputMultiplier : 1);\n\n  return (\n    (nonCachedInput / 1_000_000) * inputRate +\n    (usage.outputTokens / 1_000_000) * outputRate +\n    (cachedInput / 1_000_000) * cachedRate +\n    (unclassifiedCacheCreationInput / 1_000_000) * cacheCreationFallbackRate +\n    (classifiedCacheCreationInput5m / 1_000_000) * cacheCreation5mRate +\n    (classifiedCacheCreationInput1h / 1_000_000) * cacheCreation1hRate\n  );\n}\n"],"mappings":"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"}

package/bundle/dist/utils/providers/common/schema-validation.js

@@ -175,4 +175,4 @@ function isRecord(value) {
 //#endregion
 export { ANTHROPIC_SCHEMA_ARGV_MAX_UTF8_BYTES, ARGV_SAFE_MAX_UTF8_BYTES, CALLER_SCHEMA_LIMITS, CallerSchemaValidationError, assertAnthropicSchemaArgvSize, parseAndValidateCallerSchemas, serializeAndValidateDispatchSchema };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"schema-validation.js","names":[],"sources":["../../../../src/utils/providers/common/schema-validation.ts"],"sourcesContent":["import { Buffer } from \"node:buffer\";\n\nimport { type JsonValue } from \"../../../codex-protocol/serde_json/JsonValue\";\n\n/**\n * Caller-provided schemas are serialized, copied, and recursively normalized before dispatch.\n * Keep these limits comfortably above normal generated schemas while bounding that preprocessing\n * well below the API's 10 MiB request-body ceiling.\n */\nexport const CALLER_SCHEMA_LIMITS = {\n  maxUtf8Bytes: 512 * 1024,\n  maxNodes: 20_000,\n  maxDepth: 128,\n} as const;\n\n// Linux permits at most 128 KiB (MAX_ARG_STRLEN) for one argv value. qgrid uses a 50% safety\n// margin for every argv-delivered payload — Claude Code --json-schema here and the system-prompt\n// transport (claude-session) both derive from this single constant.\nexport const ARGV_SAFE_MAX_UTF8_BYTES = 64 * 1024;\nexport const ANTHROPIC_SCHEMA_ARGV_MAX_UTF8_BYTES = ARGV_SAFE_MAX_UTF8_BYTES;\n\nexport class CallerSchemaValidationError extends Error {\n  constructor(message: string) {\n    super(`qgrid: ${message}`);\n    this.name = \"CallerSchemaValidationError\";\n  }\n}\n\nexport interface CallerSchemasInput {\n  jsonSchema?: string;\n  tools?: Array<{ name: string; description?: string; inputSchema: unknown }>;\n}\n\ninterface ComplexityState {\n  utf8Bytes: number;\n  nodes: number;\n  schemas: number;\n}\n\nexport function parseAndValidateCallerSchemas(input: CallerSchemasInput): JsonValue | undefined {\n  const state: ComplexityState = {\n    utf8Bytes: 0,\n    nodes: 0,\n    schemas: 0,\n  };\n  let outputSchema: JsonValue | undefined;\n\n  if (input.jsonSchema !== undefined) {\n    addUtf8Bytes(Buffer.byteLength(input.jsonSchema, \"utf8\"), \"jsonSchema\", state);\n\n    let parsed: unknown;\n    try {\n      parsed = JSON.parse(input.jsonSchema);\n    } catch {\n      throw new CallerSchemaValidationError(\"jsonSchema must contain valid JSON\");\n    }\n\n    if (!isRecord(parsed) || parsed.type !== \"object\") {\n      throw new CallerSchemaValidationError('jsonSchema top-level type must be \"object\"');\n    }\n\n    addComplexity(parsed, \"jsonSchema\", state);\n    state.schemas += 1;\n    outputSchema = parsed as JsonValue;\n  }\n\n  for (const [index, tool] of (input.tools ?? []).entries()) {\n    addToolMetadataUtf8Bytes(tool, index, state);\n\n    const path = `tools[${index}].inputSchema`;\n    addComplexity(tool.inputSchema, path, state, true);\n\n    const serialized = stringifyJsonOrThrow(tool.inputSchema, path);\n\n    // buildToolCallSchema embeds this serialization inside another JSON string. Charge the\n    // escaped outer-string representation before that composed description is materialized.\n    addUtf8Bytes(jsonStringContentUtf8ByteUpperBound(serialized), path, state);\n    state.schemas += 1;\n  }\n\n  return outputSchema;\n}\n\nexport function serializeAndValidateDispatchSchema(\n  schema: unknown,\n  provider?: string,\n): string | undefined {\n  if (schema === undefined) return undefined;\n\n  const serialized = stringifyJsonOrThrow(schema, \"dispatch schema\");\n\n  const byteLength = Buffer.byteLength(serialized, \"utf8\");\n  if (byteLength > CALLER_SCHEMA_LIMITS.maxUtf8Bytes) {\n    throw new CallerSchemaValidationError(\n      `dispatch schema exceeds UTF-8 byte limit of ${CALLER_SCHEMA_LIMITS.maxUtf8Bytes}`,\n    );\n  }\n  if (provider === \"anthropic\") {\n    assertAnthropicSchemaArgvSize(serialized);\n  }\n\n  return serialized;\n}\n\nexport function assertAnthropicSchemaArgvSize(jsonSchema: string): void {\n  if (Buffer.byteLength(jsonSchema, \"utf8\") > ANTHROPIC_SCHEMA_ARGV_MAX_UTF8_BYTES) {\n    throw new CallerSchemaValidationError(\n      `Anthropic dispatch schema exceeds argv UTF-8 byte limit of ${ANTHROPIC_SCHEMA_ARGV_MAX_UTF8_BYTES}`,\n    );\n  }\n}\n\nfunction stringifyJsonOrThrow(value: unknown, subject: string): string {\n  let serialized: string | undefined;\n  try {\n    serialized = JSON.stringify(value);\n  } catch {\n    throw new CallerSchemaValidationError(`${subject} must be JSON-serializable`);\n  }\n  if (serialized === undefined) {\n    throw new CallerSchemaValidationError(`${subject} must be JSON-serializable`);\n  }\n  return serialized;\n}\n\nfunction addUtf8Bytes(byteLength: number, path: string, state: ComplexityState): void {\n  state.utf8Bytes += byteLength;\n  if (state.utf8Bytes > CALLER_SCHEMA_LIMITS.maxUtf8Bytes) {\n    throwLimitError(path, \"UTF-8 byte\", CALLER_SCHEMA_LIMITS.maxUtf8Bytes, state);\n  }\n}\n\nconst TOOL_DESCRIPTION_ENTRY_PREFIX = \"- \";\nconst TOOL_DESCRIPTION_NAME_SEPARATOR = \": \";\nconst TOOL_DESCRIPTION_INPUT_SCHEMA_PREFIX = \"\\n  inputSchema: \";\nconst TOOL_DESCRIPTION_ENTRY_SEPARATOR = \"\\n\";\n\nfunction addToolMetadataUtf8Bytes(\n  tool: NonNullable<CallerSchemasInput[\"tools\"]>[number],\n  index: number,\n  state: ComplexityState,\n): void {\n  const toolPath = `tools[${index}]`;\n\n  // buildToolCallSchema places every tool name in both the enum and the human-readable tool\n  // description. Count both escaped occurrences, plus the enum's JSON string delimiters.\n  const encodedNameBytes = jsonStringContentUtf8ByteUpperBound(tool.name);\n  addUtf8Bytes(encodedNameBytes * 2 + 2, `${toolPath}.name`, state);\n\n  if (tool.description !== undefined) {\n    addUtf8Bytes(\n      jsonStringContentUtf8ByteUpperBound(tool.description),\n      `${toolPath}.description`,\n      state,\n    );\n  }\n\n  // Per-tool framing also grows with the number of tools even when all caller strings are empty.\n  // Include both the toolDescriptions join separator and the enum comma after the first entry.\n  const framingBytes =\n    jsonStringContentUtf8ByteUpperBound(TOOL_DESCRIPTION_ENTRY_PREFIX) +\n    jsonStringContentUtf8ByteUpperBound(TOOL_DESCRIPTION_NAME_SEPARATOR) +\n    jsonStringContentUtf8ByteUpperBound(TOOL_DESCRIPTION_INPUT_SCHEMA_PREFIX) +\n    (index === 0 ? 0 : jsonStringContentUtf8ByteUpperBound(TOOL_DESCRIPTION_ENTRY_SEPARATOR) + 1);\n  addUtf8Bytes(framingBytes, toolPath, state);\n}\n\n/**\n * Returns a conservative UTF-8 byte count for a string when it becomes JSON string content,\n * without allocating the escaped representation. JSON.stringify uses short two-byte escapes for\n * five control characters; counting every control character as a six-byte `\\u00XX` escape keeps\n * this an upper bound while avoiding a second large temporary string.\n */\nfunction jsonStringContentUtf8ByteUpperBound(value: string): number {\n  let bytes = 0;\n\n  for (let index = 0; index < value.length; index += 1) {\n    const codeUnit = value.charCodeAt(index);\n\n    if (codeUnit === 0x22 || codeUnit === 0x5c) {\n      bytes += 2;\n      continue;\n    }\n    if (codeUnit <= 0x1f) {\n      bytes += 6;\n      continue;\n    }\n    if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {\n      const nextCodeUnit = value.charCodeAt(index + 1);\n      if (nextCodeUnit >= 0xdc00 && nextCodeUnit <= 0xdfff) {\n        bytes += 4;\n        index += 1;\n      } else {\n        // Well-formed JSON.stringify escapes lone surrogates as `\\uXXXX`.\n        bytes += 6;\n      }\n      continue;\n    }\n    if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) {\n      bytes += 6;\n      continue;\n    }\n\n    bytes += codeUnit <= 0x7f ? 1 : codeUnit <= 0x7ff ? 2 : 3;\n  }\n\n  return bytes;\n}\n\nfunction addComplexity(\n  root: unknown,\n  path: string,\n  state: ComplexityState,\n  precheckUtf8Bytes = false,\n): void {\n  const rawUtf8Bytes = { value: 0 };\n  if (precheckUtf8Bytes && typeof root === \"string\") {\n    addRawUtf8LowerBound(root, path, state, rawUtf8Bytes);\n  }\n  addNode(path, state);\n  if (root === null || typeof root !== \"object\") return;\n\n  const stack: Array<{ value: Record<string, unknown> | unknown[]; depth: number }> = [\n    { value: root as Record<string, unknown> | unknown[], depth: 0 },\n  ];\n\n  while (stack.length > 0) {\n    const current = stack.pop()!;\n    if (Array.isArray(current.value)) {\n      for (let index = 0; index < current.value.length; index += 1) {\n        const depth = current.depth + 1;\n        assertDepthWithinLimit(depth, path);\n        addNode(path, state);\n\n        const child = current.value[index];\n        if (precheckUtf8Bytes && typeof child === \"string\") {\n          addRawUtf8LowerBound(child, path, state, rawUtf8Bytes);\n        }\n        if (child !== null && typeof child === \"object\") {\n          stack.push({ value: child as Record<string, unknown> | unknown[], depth });\n        }\n      }\n      continue;\n    }\n\n    for (const key in current.value) {\n      if (!Object.hasOwn(current.value, key)) continue;\n      if (precheckUtf8Bytes) {\n        addRawUtf8LowerBound(key, path, state, rawUtf8Bytes);\n      }\n      const depth = current.depth + 1;\n      assertDepthWithinLimit(depth, path);\n      addNode(path, state);\n\n      const child = current.value[key];\n      if (precheckUtf8Bytes && typeof child === \"string\") {\n        addRawUtf8LowerBound(child, path, state, rawUtf8Bytes);\n      }\n      if (child !== null && typeof child === \"object\") {\n        stack.push({ value: child as Record<string, unknown> | unknown[], depth });\n      }\n    }\n  }\n}\n\nfunction addRawUtf8LowerBound(\n  value: string,\n  path: string,\n  state: ComplexityState,\n  rawUtf8Bytes: { value: number },\n): void {\n  rawUtf8Bytes.value += Buffer.byteLength(value, \"utf8\");\n  if (state.utf8Bytes + rawUtf8Bytes.value > CALLER_SCHEMA_LIMITS.maxUtf8Bytes) {\n    throwLimitError(path, \"UTF-8 byte\", CALLER_SCHEMA_LIMITS.maxUtf8Bytes, state);\n  }\n}\n\nfunction assertDepthWithinLimit(depth: number, path: string): void {\n  if (depth > CALLER_SCHEMA_LIMITS.maxDepth) {\n    throw new CallerSchemaValidationError(\n      `${path} exceeds depth limit of ${CALLER_SCHEMA_LIMITS.maxDepth}`,\n    );\n  }\n}\n\nfunction addNode(path: string, state: ComplexityState): void {\n  state.nodes += 1;\n  if (state.nodes > CALLER_SCHEMA_LIMITS.maxNodes) {\n    throwLimitError(path, \"node\", CALLER_SCHEMA_LIMITS.maxNodes, state);\n  }\n}\n\nfunction throwLimitError(\n  path: string,\n  kind: \"UTF-8 byte\" | \"node\",\n  limit: number,\n  state: ComplexityState,\n): never {\n  throw new CallerSchemaValidationError(\n    state.schemas === 0\n      ? `${path} exceeds ${kind} limit of ${limit}`\n      : `caller schemas exceed aggregate ${kind} limit of ${limit}`,\n  );\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\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":"schema-validation.js","names":[],"sources":["../../../../src/utils/providers/common/schema-validation.ts"],"sourcesContent":["import { Buffer } from \"node:buffer\";\n\nimport { type JsonValue } from \"./provider-types\";\n\n/**\n * Caller-provided schemas are serialized, copied, and recursively normalized before dispatch.\n * Keep these limits comfortably above normal generated schemas while bounding that preprocessing\n * well below the API's 10 MiB request-body ceiling.\n */\nexport const CALLER_SCHEMA_LIMITS = {\n  maxUtf8Bytes: 512 * 1024,\n  maxNodes: 20_000,\n  maxDepth: 128,\n} as const;\n\n// Linux permits at most 128 KiB (MAX_ARG_STRLEN) for one argv value. qgrid uses a 50% safety\n// margin for every argv-delivered payload — Claude Code --json-schema here and the system-prompt\n// transport (claude-session) both derive from this single constant.\nexport const ARGV_SAFE_MAX_UTF8_BYTES = 64 * 1024;\nexport const ANTHROPIC_SCHEMA_ARGV_MAX_UTF8_BYTES = ARGV_SAFE_MAX_UTF8_BYTES;\n\nexport class CallerSchemaValidationError extends Error {\n  constructor(message: string) {\n    super(`qgrid: ${message}`);\n    this.name = \"CallerSchemaValidationError\";\n  }\n}\n\nexport interface CallerSchemasInput {\n  jsonSchema?: string;\n  tools?: Array<{ name: string; description?: string; inputSchema: unknown }>;\n}\n\ninterface ComplexityState {\n  utf8Bytes: number;\n  nodes: number;\n  schemas: number;\n}\n\nexport function parseAndValidateCallerSchemas(input: CallerSchemasInput): JsonValue | undefined {\n  const state: ComplexityState = {\n    utf8Bytes: 0,\n    nodes: 0,\n    schemas: 0,\n  };\n  let outputSchema: JsonValue | undefined;\n\n  if (input.jsonSchema !== undefined) {\n    addUtf8Bytes(Buffer.byteLength(input.jsonSchema, \"utf8\"), \"jsonSchema\", state);\n\n    let parsed: unknown;\n    try {\n      parsed = JSON.parse(input.jsonSchema);\n    } catch {\n      throw new CallerSchemaValidationError(\"jsonSchema must contain valid JSON\");\n    }\n\n    if (!isRecord(parsed) || parsed.type !== \"object\") {\n      throw new CallerSchemaValidationError('jsonSchema top-level type must be \"object\"');\n    }\n\n    addComplexity(parsed, \"jsonSchema\", state);\n    state.schemas += 1;\n    outputSchema = parsed as JsonValue;\n  }\n\n  for (const [index, tool] of (input.tools ?? []).entries()) {\n    addToolMetadataUtf8Bytes(tool, index, state);\n\n    const path = `tools[${index}].inputSchema`;\n    addComplexity(tool.inputSchema, path, state, true);\n\n    const serialized = stringifyJsonOrThrow(tool.inputSchema, path);\n\n    // buildToolCallSchema embeds this serialization inside another JSON string. Charge the\n    // escaped outer-string representation before that composed description is materialized.\n    addUtf8Bytes(jsonStringContentUtf8ByteUpperBound(serialized), path, state);\n    state.schemas += 1;\n  }\n\n  return outputSchema;\n}\n\nexport function serializeAndValidateDispatchSchema(\n  schema: unknown,\n  provider?: string,\n): string | undefined {\n  if (schema === undefined) return undefined;\n\n  const serialized = stringifyJsonOrThrow(schema, \"dispatch schema\");\n\n  const byteLength = Buffer.byteLength(serialized, \"utf8\");\n  if (byteLength > CALLER_SCHEMA_LIMITS.maxUtf8Bytes) {\n    throw new CallerSchemaValidationError(\n      `dispatch schema exceeds UTF-8 byte limit of ${CALLER_SCHEMA_LIMITS.maxUtf8Bytes}`,\n    );\n  }\n  if (provider === \"anthropic\") {\n    assertAnthropicSchemaArgvSize(serialized);\n  }\n\n  return serialized;\n}\n\nexport function assertAnthropicSchemaArgvSize(jsonSchema: string): void {\n  if (Buffer.byteLength(jsonSchema, \"utf8\") > ANTHROPIC_SCHEMA_ARGV_MAX_UTF8_BYTES) {\n    throw new CallerSchemaValidationError(\n      `Anthropic dispatch schema exceeds argv UTF-8 byte limit of ${ANTHROPIC_SCHEMA_ARGV_MAX_UTF8_BYTES}`,\n    );\n  }\n}\n\nfunction stringifyJsonOrThrow(value: unknown, subject: string): string {\n  let serialized: string | undefined;\n  try {\n    serialized = JSON.stringify(value);\n  } catch {\n    throw new CallerSchemaValidationError(`${subject} must be JSON-serializable`);\n  }\n  if (serialized === undefined) {\n    throw new CallerSchemaValidationError(`${subject} must be JSON-serializable`);\n  }\n  return serialized;\n}\n\nfunction addUtf8Bytes(byteLength: number, path: string, state: ComplexityState): void {\n  state.utf8Bytes += byteLength;\n  if (state.utf8Bytes > CALLER_SCHEMA_LIMITS.maxUtf8Bytes) {\n    throwLimitError(path, \"UTF-8 byte\", CALLER_SCHEMA_LIMITS.maxUtf8Bytes, state);\n  }\n}\n\nconst TOOL_DESCRIPTION_ENTRY_PREFIX = \"- \";\nconst TOOL_DESCRIPTION_NAME_SEPARATOR = \": \";\nconst TOOL_DESCRIPTION_INPUT_SCHEMA_PREFIX = \"\\n  inputSchema: \";\nconst TOOL_DESCRIPTION_ENTRY_SEPARATOR = \"\\n\";\n\nfunction addToolMetadataUtf8Bytes(\n  tool: NonNullable<CallerSchemasInput[\"tools\"]>[number],\n  index: number,\n  state: ComplexityState,\n): void {\n  const toolPath = `tools[${index}]`;\n\n  // buildToolCallSchema places every tool name in both the enum and the human-readable tool\n  // description. Count both escaped occurrences, plus the enum's JSON string delimiters.\n  const encodedNameBytes = jsonStringContentUtf8ByteUpperBound(tool.name);\n  addUtf8Bytes(encodedNameBytes * 2 + 2, `${toolPath}.name`, state);\n\n  if (tool.description !== undefined) {\n    addUtf8Bytes(\n      jsonStringContentUtf8ByteUpperBound(tool.description),\n      `${toolPath}.description`,\n      state,\n    );\n  }\n\n  // Per-tool framing also grows with the number of tools even when all caller strings are empty.\n  // Include both the toolDescriptions join separator and the enum comma after the first entry.\n  const framingBytes =\n    jsonStringContentUtf8ByteUpperBound(TOOL_DESCRIPTION_ENTRY_PREFIX) +\n    jsonStringContentUtf8ByteUpperBound(TOOL_DESCRIPTION_NAME_SEPARATOR) +\n    jsonStringContentUtf8ByteUpperBound(TOOL_DESCRIPTION_INPUT_SCHEMA_PREFIX) +\n    (index === 0 ? 0 : jsonStringContentUtf8ByteUpperBound(TOOL_DESCRIPTION_ENTRY_SEPARATOR) + 1);\n  addUtf8Bytes(framingBytes, toolPath, state);\n}\n\n/**\n * Returns a conservative UTF-8 byte count for a string when it becomes JSON string content,\n * without allocating the escaped representation. JSON.stringify uses short two-byte escapes for\n * five control characters; counting every control character as a six-byte `\\u00XX` escape keeps\n * this an upper bound while avoiding a second large temporary string.\n */\nfunction jsonStringContentUtf8ByteUpperBound(value: string): number {\n  let bytes = 0;\n\n  for (let index = 0; index < value.length; index += 1) {\n    const codeUnit = value.charCodeAt(index);\n\n    if (codeUnit === 0x22 || codeUnit === 0x5c) {\n      bytes += 2;\n      continue;\n    }\n    if (codeUnit <= 0x1f) {\n      bytes += 6;\n      continue;\n    }\n    if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {\n      const nextCodeUnit = value.charCodeAt(index + 1);\n      if (nextCodeUnit >= 0xdc00 && nextCodeUnit <= 0xdfff) {\n        bytes += 4;\n        index += 1;\n      } else {\n        // Well-formed JSON.stringify escapes lone surrogates as `\\uXXXX`.\n        bytes += 6;\n      }\n      continue;\n    }\n    if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) {\n      bytes += 6;\n      continue;\n    }\n\n    bytes += codeUnit <= 0x7f ? 1 : codeUnit <= 0x7ff ? 2 : 3;\n  }\n\n  return bytes;\n}\n\nfunction addComplexity(\n  root: unknown,\n  path: string,\n  state: ComplexityState,\n  precheckUtf8Bytes = false,\n): void {\n  const rawUtf8Bytes = { value: 0 };\n  if (precheckUtf8Bytes && typeof root === \"string\") {\n    addRawUtf8LowerBound(root, path, state, rawUtf8Bytes);\n  }\n  addNode(path, state);\n  if (root === null || typeof root !== \"object\") return;\n\n  const stack: Array<{ value: Record<string, unknown> | unknown[]; depth: number }> = [\n    { value: root as Record<string, unknown> | unknown[], depth: 0 },\n  ];\n\n  while (stack.length > 0) {\n    const current = stack.pop()!;\n    if (Array.isArray(current.value)) {\n      for (let index = 0; index < current.value.length; index += 1) {\n        const depth = current.depth + 1;\n        assertDepthWithinLimit(depth, path);\n        addNode(path, state);\n\n        const child = current.value[index];\n        if (precheckUtf8Bytes && typeof child === \"string\") {\n          addRawUtf8LowerBound(child, path, state, rawUtf8Bytes);\n        }\n        if (child !== null && typeof child === \"object\") {\n          stack.push({ value: child as Record<string, unknown> | unknown[], depth });\n        }\n      }\n      continue;\n    }\n\n    for (const key in current.value) {\n      if (!Object.hasOwn(current.value, key)) continue;\n      if (precheckUtf8Bytes) {\n        addRawUtf8LowerBound(key, path, state, rawUtf8Bytes);\n      }\n      const depth = current.depth + 1;\n      assertDepthWithinLimit(depth, path);\n      addNode(path, state);\n\n      const child = current.value[key];\n      if (precheckUtf8Bytes && typeof child === \"string\") {\n        addRawUtf8LowerBound(child, path, state, rawUtf8Bytes);\n      }\n      if (child !== null && typeof child === \"object\") {\n        stack.push({ value: child as Record<string, unknown> | unknown[], depth });\n      }\n    }\n  }\n}\n\nfunction addRawUtf8LowerBound(\n  value: string,\n  path: string,\n  state: ComplexityState,\n  rawUtf8Bytes: { value: number },\n): void {\n  rawUtf8Bytes.value += Buffer.byteLength(value, \"utf8\");\n  if (state.utf8Bytes + rawUtf8Bytes.value > CALLER_SCHEMA_LIMITS.maxUtf8Bytes) {\n    throwLimitError(path, \"UTF-8 byte\", CALLER_SCHEMA_LIMITS.maxUtf8Bytes, state);\n  }\n}\n\nfunction assertDepthWithinLimit(depth: number, path: string): void {\n  if (depth > CALLER_SCHEMA_LIMITS.maxDepth) {\n    throw new CallerSchemaValidationError(\n      `${path} exceeds depth limit of ${CALLER_SCHEMA_LIMITS.maxDepth}`,\n    );\n  }\n}\n\nfunction addNode(path: string, state: ComplexityState): void {\n  state.nodes += 1;\n  if (state.nodes > CALLER_SCHEMA_LIMITS.maxNodes) {\n    throwLimitError(path, \"node\", CALLER_SCHEMA_LIMITS.maxNodes, state);\n  }\n}\n\nfunction throwLimitError(\n  path: string,\n  kind: \"UTF-8 byte\" | \"node\",\n  limit: number,\n  state: ComplexityState,\n): never {\n  throw new CallerSchemaValidationError(\n    state.schemas === 0\n      ? `${path} exceeds ${kind} limit of ${limit}`\n      : `caller schemas exceed aggregate ${kind} limit of ${limit}`,\n  );\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return value !== null && typeof value === \"object\" && !Array.isArray(value);\n}\n"],"mappings":";;;;;;;AASA,MAAa,uBAAuB;CAClC,cAAc,MAAM;CACpB,UAAU;CACV,UAAU;AACZ;AAKA,MAAa,2BAA2B,KAAK;AAC7C,MAAa,uCAAuC;AAEpD,IAAa,8BAAb,cAAiD,MAAM;CACrD,YAAY,SAAiB;EAC3B,MAAM,UAAU,SAAS;EACzB,KAAK,OAAO;CACd;AACF;AAaA,SAAgB,8BAA8B,OAAkD;CAC9F,MAAM,QAAyB;EAC7B,WAAW;EACX,OAAO;EACP,SAAS;CACX;CACA,IAAI;CAEJ,IAAI,MAAM,eAAe,QAAW;EAClC,aAAa,OAAO,WAAW,MAAM,YAAY,MAAM,GAAG,cAAc,KAAK;EAE7E,IAAI;EACJ,IAAI;GACF,SAAS,KAAK,MAAM,MAAM,UAAU;EACtC,QAAQ;GACN,MAAM,IAAI,4BAA4B,oCAAoC;EAC5E;EAEA,IAAI,CAAC,SAAS,MAAM,KAAK,OAAO,SAAS,UACvC,MAAM,IAAI,4BAA4B,8CAA4C;EAGpF,cAAc,QAAQ,cAAc,KAAK;EACzC,MAAM,WAAW;EACjB,eAAe;CACjB;CAEA,KAAK,MAAM,CAAC,OAAO,UAAU,MAAM,SAAS,CAAC,EAAA,CAAG,QAAQ,GAAG;EACzD,yBAAyB,MAAM,OAAO,KAAK;EAE3C,MAAM,OAAO,SAAS,MAAM;EAC5B,cAAc,KAAK,aAAa,MAAM,OAAO,IAAI;EAMjD,aAAa,oCAJM,qBAAqB,KAAK,aAAa,IAIT,CAAU,GAAG,MAAM,KAAK;EACzE,MAAM,WAAW;CACnB;CAEA,OAAO;AACT;AAEA,SAAgB,mCACd,QACA,UACoB;CACpB,IAAI,WAAW,QAAW,OAAO;CAEjC,MAAM,aAAa,qBAAqB,QAAQ,iBAAiB;CAGjE,IADmB,OAAO,WAAW,YAAY,MAC7C,IAAa,qBAAqB,cACpC,MAAM,IAAI,4BACR,+CAA+C,qBAAqB,cACtE;CAEF,IAAI,aAAa,aACf,8BAA8B,UAAU;CAG1C,OAAO;AACT;AAEA,SAAgB,8BAA8B,YAA0B;CACtE,IAAI,OAAO,WAAW,YAAY,MAAM,IAAA,OACtC,MAAM,IAAI,4BACR,8DAA8D,sCAChE;AAEJ;AAEA,SAAS,qBAAqB,OAAgB,SAAyB;CACrE,IAAI;CACJ,IAAI;EACF,aAAa,KAAK,UAAU,KAAK;CACnC,QAAQ;EACN,MAAM,IAAI,4BAA4B,GAAG,QAAQ,2BAA2B;CAC9E;CACA,IAAI,eAAe,QACjB,MAAM,IAAI,4BAA4B,GAAG,QAAQ,2BAA2B;CAE9E,OAAO;AACT;AAEA,SAAS,aAAa,YAAoB,MAAc,OAA8B;CACpF,MAAM,aAAa;CACnB,IAAI,MAAM,YAAY,qBAAqB,cACzC,gBAAgB,MAAM,cAAc,qBAAqB,cAAc,KAAK;AAEhF;AAEA,MAAM,gCAAgC;AACtC,MAAM,kCAAkC;AACxC,MAAM,uCAAuC;AAC7C,MAAM,mCAAmC;AAEzC,SAAS,yBACP,MACA,OACA,OACM;CACN,MAAM,WAAW,SAAS,MAAM;CAKhC,aADyB,oCAAoC,KAAK,IACrD,IAAmB,IAAI,GAAG,GAAG,SAAS,QAAQ,KAAK;CAEhE,IAAI,KAAK,gBAAgB,QACvB,aACE,oCAAoC,KAAK,WAAW,GACpD,GAAG,SAAS,eACZ,KACF;CAUF,aAJE,oCAAoC,6BAA6B,IACjE,oCAAoC,+BAA+B,IACnE,oCAAoC,oCAAoC,KACvE,UAAU,IAAI,IAAI,oCAAoC,gCAAgC,IAAI,IAClE,UAAU,KAAK;AAC5C;;;;;;;AAQA,SAAS,oCAAoC,OAAuB;CAClE,IAAI,QAAQ;CAEZ,KAAK,IAAI,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAAS,GAAG;EACpD,MAAM,WAAW,MAAM,WAAW,KAAK;EAEvC,IAAI,aAAa,MAAQ,aAAa,IAAM;GAC1C,SAAS;GACT;EACF;EACA,IAAI,YAAY,IAAM;GACpB,SAAS;GACT;EACF;EACA,IAAI,YAAY,SAAU,YAAY,OAAQ;GAC5C,MAAM,eAAe,MAAM,WAAW,QAAQ,CAAC;GAC/C,IAAI,gBAAgB,SAAU,gBAAgB,OAAQ;IACpD,SAAS;IACT,SAAS;GACX,OAEE,SAAS;GAEX;EACF;EACA,IAAI,YAAY,SAAU,YAAY,OAAQ;GAC5C,SAAS;GACT;EACF;EAEA,SAAS,YAAY,MAAO,IAAI,YAAY,OAAQ,IAAI;CAC1D;CAEA,OAAO;AACT;AAEA,SAAS,cACP,MACA,MACA,OACA,oBAAoB,OACd;CACN,MAAM,eAAe,EAAE,OAAO,EAAE;CAChC,IAAI,qBAAqB,OAAO,SAAS,UACvC,qBAAqB,MAAM,MAAM,OAAO,YAAY;CAEtD,QAAQ,MAAM,KAAK;CACnB,IAAI,SAAS,QAAQ,OAAO,SAAS,UAAU;CAE/C,MAAM,QAA8E,CAClF;EAAE,OAAO;EAA6C,OAAO;CAAE,CACjE;CAEA,OAAO,MAAM,SAAS,GAAG;EACvB,MAAM,UAAU,MAAM,IAAI;EAC1B,IAAI,MAAM,QAAQ,QAAQ,KAAK,GAAG;GAChC,KAAK,IAAI,QAAQ,GAAG,QAAQ,QAAQ,MAAM,QAAQ,SAAS,GAAG;IAC5D,MAAM,QAAQ,QAAQ,QAAQ;IAC9B,uBAAuB,OAAO,IAAI;IAClC,QAAQ,MAAM,KAAK;IAEnB,MAAM,QAAQ,QAAQ,MAAM;IAC5B,IAAI,qBAAqB,OAAO,UAAU,UACxC,qBAAqB,OAAO,MAAM,OAAO,YAAY;IAEvD,IAAI,UAAU,QAAQ,OAAO,UAAU,UACrC,MAAM,KAAK;KAAE,OAAO;KAA8C;IAAM,CAAC;GAE7E;GACA;EACF;EAEA,KAAK,MAAM,OAAO,QAAQ,OAAO;GAC/B,IAAI,CAAC,OAAO,OAAO,QAAQ,OAAO,GAAG,GAAG;GACxC,IAAI,mBACF,qBAAqB,KAAK,MAAM,OAAO,YAAY;GAErD,MAAM,QAAQ,QAAQ,QAAQ;GAC9B,uBAAuB,OAAO,IAAI;GAClC,QAAQ,MAAM,KAAK;GAEnB,MAAM,QAAQ,QAAQ,MAAM;GAC5B,IAAI,qBAAqB,OAAO,UAAU,UACxC,qBAAqB,OAAO,MAAM,OAAO,YAAY;GAEvD,IAAI,UAAU,QAAQ,OAAO,UAAU,UACrC,MAAM,KAAK;IAAE,OAAO;IAA8C;GAAM,CAAC;EAE7E;CACF;AACF;AAEA,SAAS,qBACP,OACA,MACA,OACA,cACM;CACN,aAAa,SAAS,OAAO,WAAW,OAAO,MAAM;CACrD,IAAI,MAAM,YAAY,aAAa,QAAQ,qBAAqB,cAC9D,gBAAgB,MAAM,cAAc,qBAAqB,cAAc,KAAK;AAEhF;AAEA,SAAS,uBAAuB,OAAe,MAAoB;CACjE,IAAI,QAAQ,qBAAqB,UAC/B,MAAM,IAAI,4BACR,GAAG,KAAK,0BAA0B,qBAAqB,UACzD;AAEJ;AAEA,SAAS,QAAQ,MAAc,OAA8B;CAC3D,MAAM,SAAS;CACf,IAAI,MAAM,QAAQ,qBAAqB,UACrC,gBAAgB,MAAM,QAAQ,qBAAqB,UAAU,KAAK;AAEtE;AAEA,SAAS,gBACP,MACA,MACA,OACA,OACO;CACP,MAAM,IAAI,4BACR,MAAM,YAAY,IACd,GAAG,KAAK,WAAW,KAAK,YAAY,UACpC,mCAAmC,KAAK,YAAY,OAC1D;AACF;AAEA,SAAS,SAAS,OAAkD;CAClE,OAAO,UAAU,QAAQ,OAAO,UAAU,YAAY,CAAC,MAAM,QAAQ,KAAK;AAC5E"}