@cartanova/qgrid-cli 2.7.0 → 2.7.1

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 { 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\";\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// 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 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/src/application/qgrid/qgrid.dispatcher.test.ts

@@ -6,6 +6,7 @@ import {
   type GenerateStreamCallbacks,
 } from "../../utils/providers/common/provider-dispatcher";
 import { buildStrictOutputSchema, QgridDispatcherClass } from "./qgrid.dispatcher";
+import { type QueryOutput } from "./qgrid.types";
 
 function providerResult(overrides: Partial<GenerateResult> = {}): GenerateResult {
   return {
@@ -397,9 +398,12 @@ describe("QgridDispatcherClass", () => {
     },
   );
 
-  // SON-495: anthropic route 도 strict(required 유지)를 쓴다 — required 를 살려야 모델이 필드를
-  // 빠짐없이 채운다(실측 확정). optionalize 는 제거됨.
-  it("Anthropic route 에 strict(required 유지) outputSchema 를 전달한다", async () => {
+  // SON-532: anthropic route 는 --json-schema 를 쓰지 않는다 — CC 의 강제 없는 사후 채점이
+  // 소비자 의도와 충돌해 내부 재시도 루프를 발화시켰다. 스키마는 프롬프트로 안내되고
+  // 판정은 소비자(zod)가 맡으므로 provider 로는 outputSchema 를 보내지 않는다.
+  // (SON-495 의 "required 유지" 교훈은 채점 전제의 규칙이었다 — 안내문에는 소비자가
+  // 선언한 required 가 원형 그대로 남는다.)
+  it("Anthropic route 는 outputSchema 를 provider 로 전달하지 않는다", async () => {
     const dispatcher = new QgridDispatcherClass();
     const generate = vi.fn(
       async (_req: GenerateRequest): Promise<GenerateResult> => ({
@@ -429,13 +433,219 @@ describe("QgridDispatcherClass", () => {
       }),
     });
 
-    const outputSchema = generate.mock.calls[0]![0].outputSchema as {
-      required?: string[];
-      additionalProperties?: boolean;
-    };
-    // anthropic 도 OpenAI 와 동일하게 strictify — required 살아있음
-    expect(outputSchema.required).toEqual(["contents"]);
-    expect(outputSchema.additionalProperties).toBe(false);
+    expect(generate.mock.calls[0]![0].outputSchema).toBeUndefined();
+  });
+
+  it("Anthropic route 도 원형 스키마의 구문·복잡도는 계속 검증한다", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    dispatcher.anthropicDispatcher = { generate: vi.fn() } as never;
+
+    // 구문 오류는 provider 실행 전에 caller-fault 로 거절된다.
+    await expect(
+      dispatcher.query({
+        prompt: "hi",
+        model: "anthropic/claude-sonnet-4-6",
+        jsonSchema: "{not json",
+      }),
+    ).rejects.toThrow("jsonSchema must contain valid JSON");
+
+    // 복잡도 한도(depth)도 그대로 산다.
+    await expect(
+      dispatcher.query({
+        prompt: "hi",
+        model: "anthropic/claude-sonnet-4-6",
+        jsonSchema: deeplyNestedOutputSchema(5_000),
+      }),
+    ).rejects.toThrow("exceeds depth limit");
+  });
+
+  // SON-532: 계약은 --json-schema 대신 system 말미에 텍스트로 주입된다.
+  it.each(["query", "queryStream"] as const)(
+    "Anthropic %s 는 스키마 계약을 system prompt 말미에 합성해 전달한다",
+    async (method) => {
+      const dispatcher = new QgridDispatcherClass();
+      let request: GenerateRequest | undefined;
+
+      if (method === "query") {
+        const generate = vi.fn(async (req: GenerateRequest) => {
+          request = req;
+          return providerResult();
+        });
+        dispatcher.anthropicDispatcher = { generate } as never;
+        await dispatcher.query({
+          prompt: "hi",
+          system: "You are helpful.",
+          model: "anthropic/claude-sonnet-4-6",
+          jsonSchema: JSON.stringify({ type: "object", properties: { a: { type: "string" } } }),
+        });
+      } else {
+        const generateStream = vi.fn(async (req: GenerateRequest, cb: GenerateStreamCallbacks) => {
+          request = req;
+          cb.onComplete(providerResult());
+        });
+        dispatcher.anthropicDispatcher = { generateStream } as never;
+        await dispatcher.queryStream(
+          {
+            prompt: "hi",
+            system: "You are helpful.",
+            model: "anthropic/claude-sonnet-4-6",
+            jsonSchema: JSON.stringify({ type: "object", properties: { a: { type: "string" } } }),
+          },
+          { onDelta: vi.fn(), onComplete: vi.fn(), onError: vi.fn() },
+        );
+      }
+
+      // 원래 system 이 앞, 계약이 말미 — 스키마 원문이 그대로 들어간다.
+      expect(request?.systemPrompt).toMatch(/^You are helpful\.\n\n## Output Format/);
+      expect(request?.systemPrompt).toContain('"a":{"type":"string"}');
+    },
+  );
+
+  it("Anthropic tools 요청은 envelope 계약을 system 에 합성한다", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    const generate = vi.fn(async (req: GenerateRequest) => {
+      void req;
+      return providerResult({
+        text: '{"result":{"action":"answer","answer":{"payload":"ok"},"toolCalls":null}}',
+      });
+    });
+    dispatcher.anthropicDispatcher = { generate } as never;
+
+    await dispatcher.query({ prompt: "hi", model: "anthropic/claude-sonnet-4-6", ...toolsAndSchema });
+
+    const request = generate.mock.calls[0]![0];
+    expect(request.systemPrompt).toContain("## Client Tool Protocol");
+    expect(request.systemPrompt).toContain('{"result": ...}');
+    expect(request.systemPrompt).toContain("- lookup");
+  });
+
+  it("스키마 없는 Anthropic 요청은 system 을 그대로 둔다", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    const generate = vi.fn(async (_req: GenerateRequest) => providerResult());
+    dispatcher.anthropicDispatcher = { generate } as never;
+
+    await dispatcher.query({ prompt: "hi", system: "plain", model: "anthropic/claude-sonnet-4-6" });
+    expect(generate.mock.calls[0]![0]!.systemPrompt).toBe("plain");
+
+    await dispatcher.query({ prompt: "hi", model: "anthropic/claude-sonnet-4-6" });
+    expect(generate.mock.calls[1]![0]!.systemPrompt).toBeUndefined();
+  });
+
+  it("OpenAI 요청의 system 에는 계약을 합성하지 않는다", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    const generate = vi.fn(async (_req: GenerateRequest) =>
+      providerResult({ text: '{"a":"ok"}' }),
+    );
+    dispatcher.openaiDispatcher = { generate } as never;
+
+    await dispatcher.query({
+      prompt: "hi",
+      system: "plain",
+      model: "openai/gpt-5.5",
+      jsonSchema: JSON.stringify({ type: "object", properties: { a: { type: "string" } } }),
+    });
+
+    expect(generate.mock.calls[0]![0]!.systemPrompt).toBe("plain");
+  });
+
+  // SON-532: 계약 주입 스트림의 델타에서 펜스를 벗긴다. 클라이언트(EnvelopeStreamParser,
+  // partialOutputStream)는 펜스를 처리하지 못하므로 서버 책임이다.
+  it("Anthropic 스트림은 계약 주입 시 델타의 코드펜스를 벗겨 방출한다", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    const generateStream = vi.fn(async (_req: GenerateRequest, cb: GenerateStreamCallbacks) => {
+      cb.onDelta("```json\n");
+      cb.onDelta('{"a"');
+      cb.onDelta(":1}");
+      cb.onDelta("\n```");
+      cb.onComplete(providerResult({ text: '{"a":1}' }));
+    });
+    dispatcher.anthropicDispatcher = { generateStream } as never;
+
+    const deltas: string[] = [];
+    let completed: QueryOutput | undefined;
+    await dispatcher.queryStream(
+      {
+        prompt: "hi",
+        model: "anthropic/claude-sonnet-4-6",
+        jsonSchema: JSON.stringify({ type: "object", properties: { a: { type: "number" } } }),
+      },
+      {
+        onDelta: (t) => deltas.push(t),
+        onComplete: (output) => {
+          completed = output;
+        },
+        onError: vi.fn(),
+      },
+    );
+
+    // 델타 연결 == 펜스 벗긴 전체 텍스트 == done.text (adapter 의 stripFences 와 동일 시맨틱)
+    expect(deltas.join("")).toBe('{"a":1}');
+    expect(completed?.text).toBe('{"a":1}');
+  });
+
+  it("Anthropic 스트림의 홀드백 잔여는 done 전에 방출된다 (내용 무손실)", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    const events: string[] = [];
+    const generateStream = vi.fn(async (_req: GenerateRequest, cb: GenerateStreamCallbacks) => {
+      cb.onDelta('{"a":1}\n``'); // 미완성 펜스로 종료 — 닫는 펜스가 아니다
+      cb.onComplete(providerResult({ text: '{"a":1}\n``' }));
+    });
+    dispatcher.anthropicDispatcher = { generateStream } as never;
+
+    await dispatcher.queryStream(
+      {
+        prompt: "hi",
+        model: "anthropic/claude-sonnet-4-6",
+        jsonSchema: JSON.stringify({ type: "object" }),
+      },
+      {
+        onDelta: (t) => events.push(`delta:${t}`),
+        onComplete: () => events.push("complete"),
+        onError: vi.fn(),
+      },
+    );
+
+    expect(events.join("|")).toBe('delta:{"a":1}|delta:\n``|complete');
+  });
+
+  it("계약 없는 Anthropic 스트림 델타는 무변경 통과한다", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    const generateStream = vi.fn(async (_req: GenerateRequest, cb: GenerateStreamCallbacks) => {
+      cb.onDelta("```python\ncode\n```");
+      cb.onComplete(providerResult({ text: "```python\ncode\n```" }));
+    });
+    dispatcher.anthropicDispatcher = { generateStream } as never;
+
+    const deltas: string[] = [];
+    await dispatcher.queryStream(
+      { prompt: "hi", model: "anthropic/claude-sonnet-4-6" },
+      { onDelta: (t) => deltas.push(t), onComplete: vi.fn(), onError: vi.fn() },
+    );
+
+    expect(deltas.join("")).toBe("```python\ncode\n```");
+  });
+
+  it("Anthropic route 는 strict 전용 argv 64KiB 제한을 적용하지 않는다", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    const generate = vi.fn(async (): Promise<GenerateResult> => providerResult());
+    dispatcher.anthropicDispatcher = { generate } as never;
+
+    // 64KiB(ANTHROPIC_SCHEMA_ARGV_MAX_UTF8_BYTES) 초과, 전역 512KiB 미만 스키마.
+    // structured 시절에는 argv 제한으로 거절됐지만 프롬프트 전달은 system 크기 분기가 흡수한다.
+    const bigSchema = JSON.stringify({
+      type: "object",
+      description: "x".repeat(80 * 1024),
+      properties: { value: { type: "string" } },
+    });
+
+    await expect(
+      dispatcher.query({
+        prompt: "hi",
+        model: "anthropic/claude-sonnet-4-6",
+        jsonSchema: bigSchema,
+      }),
+    ).resolves.toBeDefined();
+    expect(generate).toHaveBeenCalledOnce();
   });
 
   it("OpenAI route 도 strictify(required 유지)한다", async () => {
@@ -660,7 +870,9 @@ describe("QgridDispatcherClass", () => {
     ["anthropic", "query"],
     ["anthropic", "queryStream"],
   ] as const)(
-    "%s %s 모두 tools + jsonSchema composed outputSchema를 provider에 전달한다",
+    // openai 는 composed strict envelope 를 provider 로 보내고, anthropic 은 보내지 않는다
+    // (SON-532 — envelope 계약은 프롬프트로 안내). 응답 해석(emulation)은 양쪽 동일하다.
+    "%s %s tools + jsonSchema 경로: outputSchema 전달 계약과 envelope 해석",
     async (provider, method) => {
       const dispatcher = new QgridDispatcherClass();
       const model =
@@ -709,33 +921,37 @@ describe("QgridDispatcherClass", () => {
         );
       }
 
-      expect(request?.outputSchema).toMatchObject({
-        properties: {
-          result: {
-            anyOf: [
-              {
-                properties: {
-                  action: { enum: ["answer"] },
-                  answer: { $ref: "#/$defs/__qgrid_user_output" },
+      if (provider === "openai") {
+        expect(request?.outputSchema).toMatchObject({
+          properties: {
+            result: {
+              anyOf: [
+                {
+                  properties: {
+                    action: { enum: ["answer"] },
+                    answer: { $ref: "#/$defs/__qgrid_user_output" },
+                  },
                 },
-              },
-              {
-                properties: {
-                  action: { enum: ["tool_call"] },
-                  toolCalls: { minItems: 1 },
+                {
+                  properties: {
+                    action: { enum: ["tool_call"] },
+                    toolCalls: { minItems: 1 },
+                  },
                 },
-              },
-            ],
+              ],
+            },
           },
-        },
-        $defs: {
-          __qgrid_user_output: {
-            type: "object",
-            required: ["result"],
-            additionalProperties: false,
+          $defs: {
+            __qgrid_user_output: {
+              type: "object",
+              required: ["result"],
+              additionalProperties: false,
+            },
           },
-        },
-      });
+        });
+      } else {
+        expect(request?.outputSchema).toBeUndefined();
+      }
       expect(mappedText).toBe('{"payload":"ok"}');
     },
   );