@cartanova/qgrid-cli 2.2.1 → 2.3.2

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

@@ -0,0 +1,177 @@
+import "../../../_virtual/_rolldown/runtime.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");
+}
+function textBlock(text) {
+	return [{
+		type: "text",
+		text
+	}];
+}
+function asObject(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v) ? v : null;
+}
+function responseItemText(item) {
+	const content = item.content;
+	if (!Array.isArray(content)) return "";
+	return content.map((c) => {
+		const obj = asObject(c);
+		return obj && typeof obj.text === "string" ? obj.text : "";
+	}).filter(Boolean).join("\n");
+}
+/**
+* cold history(codex ResponseItem[])를 **단일 평탄 텍스트**로 변환한다.
+* user/assistant/tool 모두 라벨 붙은 한 덩어리로 — 실행되지 않는 assistant context 로 들어간다.
+* (cold 의 user/tool-output 을 type:"user" 로 내보내면 새 prompt 로 재실행되므로 금지.)
+*/
+function flattenColdHistory(coldHistory) {
+	const parts = [];
+	for (const raw of coldHistory) {
+		const item = asObject(raw);
+		if (!item) continue;
+		if (item.type === "message" && item.role === "assistant") parts.push(`Assistant: ${responseItemText(item)}`);
+		else if (item.type === "message" && item.role === "user") parts.push(`User: ${responseItemText(item)}`);
+		else if (item.type === "function_call") {
+			const name = typeof item.name === "string" ? item.name : "";
+			const args = typeof item.arguments === "string" ? item.arguments : JSON.stringify(item.arguments ?? {});
+			parts.push(`Tool call: ${name}(${args})`);
+		} else if (item.type === "function_call_output") {
+			const output = typeof item.output === "string" ? item.output : JSON.stringify(item.output ?? "");
+			parts.push(`Tool result: ${output}`);
+		}
+	}
+	return parts.join("\n");
+}
+/**
+* 서버 GenerateRequest payload 를 Claude stream-json JSONL 라인 배열로 변환한다.
+*
+* @param opts.coldHistory  cold 경로의 codex ResponseItem 배열(JsonValue[]). resume 경로면 미사용.
+* @param opts.input        실행할 input — cold 면 coldInput, resume 면 reuseInput.
+* @param opts.isResume     resume 경로 여부. true 면 history 재주입 없이 input(delta)만.
+*
+* 출력 규칙:
+*  - 실행 가능한 `type:"user"` 줄은 **항상 정확히 1개** — 마지막 input.
+*  - resume: user(delta) 1줄만. thread 가 이전 turn 을 누적하므로 history 미포함.
+*  - cold: coldHistory 전체를 **단일 assistant context 텍스트**로 평탄화(실행 안 됨) + user(input) 1줄.
+*          user/assistant/tool 모두 평탄화되므로 과거 user/tool-output 이 재실행되지 않는다.
+*          full-fidelity role replay 가 필요하면 session resume 또는 JSONL backstop(범위 밖).
+*  - tool(function_call/output): native 블록 없이 평탄 텍스트로.
+*/
+function buildStreamJsonInput(opts) {
+	const lines = [];
+	if (!opts.isResume && opts.coldHistory && opts.coldHistory.length > 0) {
+		const flattened = flattenColdHistory(opts.coldHistory);
+		if (flattened) lines.push({
+			type: "assistant",
+			message: {
+				role: "assistant",
+				content: textBlock(`Prior conversation context:\n${flattened}`)
+			}
+		});
+	}
+	lines.push({
+		type: "user",
+		message: {
+			role: "user",
+			content: textBlock(userInputToText(opts.input))
+		}
+	});
+	return lines;
+}
+function serializeStreamJsonInput(lines) {
+	return lines.map((l) => JSON.stringify(l)).join("\n") + "\n";
+}
+function toUsageBreakdown(u) {
+	const input = u.input_tokens ?? 0;
+	const cacheCreate = u.cache_creation_input_tokens ?? 0;
+	const cacheRead = u.cache_read_input_tokens ?? 0;
+	const output = u.output_tokens ?? 0;
+	const totalInput = input + cacheCreate + cacheRead;
+	return {
+		totalTokens: totalInput + output,
+		inputTokens: totalInput,
+		cachedInputTokens: cacheRead,
+		cacheCreationInputTokens: cacheCreate,
+		outputTokens: output,
+		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;
+	for (const raw of content) {
+		const block = asObject(raw);
+		if (!block) continue;
+		if (block.type === "tool_use" && block.name === "StructuredOutput" && block.input !== void 0) return JSON.stringify(block.input);
+	}
+}
+/**
+* stream-json 출력 라인 하나를 처리한다. 순수 함수 — side effect 는 onDelta 콜백뿐.
+*
+* @param opts.structuredOutput  structured output(jsonSchema) 모드 여부.
+*   structured 모드에서 Claude 는 자연어 text_delta 와 input_json_delta.partial_json 을
+*   **함께** 흘릴 수 있다(PoC 확인). 이때 text_delta 를 그대로 onDelta 로 보내면 client 의
+*   streamObject 파서가 prose 를 JSON 앞에서 만나 깨진다. 그래서:
+*     - structured 모드: text_delta 무시, partial_json 만 onDelta.
+*     - text 모드: text_delta 만 onDelta (partial_json 은 안 옴).
+*
+* @returns result 이벤트면 ClaudeStreamResult, 그 외(delta/system 등)면 null.
+*          호출부는 라인 스트림을 돌며 이 함수를 호출하고, non-null 이 나오면 종료.
+*/
+function handleStreamJsonLine(line, onDelta, opts) {
+	const structuredOutput = opts?.structuredOutput ?? false;
+	const state = opts?.state;
+	const trimmed = line.trim();
+	if (!trimmed) return null;
+	let j;
+	try {
+		j = JSON.parse(trimmed);
+	} catch {
+		return null;
+	}
+	if (j.type === "stream_event") {
+		const event = asObject(j.event);
+		if (event && event.type === "content_block_delta") {
+			const delta = asObject(event.delta);
+			if (delta) {
+				if (structuredOutput) {
+					if (delta.type === "input_json_delta" && typeof delta.partial_json === "string") onDelta(delta.partial_json);
+				} else if (delta.type === "text_delta" && typeof delta.text === "string") onDelta(delta.text);
+			}
+		}
+		return null;
+	}
+	if (j.type === "assistant" && structuredOutput && state && state.structuredOutputText === void 0) {
+		const text = structuredOutputToolUseText(j);
+		if (text !== void 0) state.structuredOutputText = text;
+		return null;
+	}
+	if (j.type === "result") {
+		let text;
+		const preservedStructuredOutput = structuredOutput ? state?.structuredOutputText : void 0;
+		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 : "");
+		const usage = toUsageBreakdown(asObject(j.usage) ?? {});
+		const quotaExhausted = text.startsWith("You've hit");
+		const subtype = typeof j.subtype === "string" ? j.subtype : void 0;
+		const isError = !(preservedStructuredOutput !== void 0 && (subtype === "error_max_turns" || j.terminal_reason === "max_turns")) && (j.is_error === true || j.terminal_reason === "model_error" || subtype !== void 0 && subtype !== "success");
+		return {
+			text,
+			usage,
+			durationMs: typeof j.duration_ms === "number" ? j.duration_ms : 0,
+			costUsd: typeof j.total_cost_usd === "number" ? j.total_cost_usd : 0,
+			quotaExhausted,
+			isError
+		};
+	}
+	return null;
+}
+//#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 * stream-json 어댑터 — Anthropic(Claude) provider 의 입력/출력 변환.\n *\n * 이 모듈은 부활의 유일한 본질적 신규 코드다. 두 방향을 분리된 순수 함수로 둔다:\n *  - 입력: 서버 GenerateRequest payload(coldInput/coldHistory/reuseInput)\n *          → `claude -p --input-format stream-json` 의 JSONL 라인.\n *  - 출력: `claude -p --output-format stream-json --verbose` 의 JSONL 라인\n *          → qgrid 서버 delta(onDelta) + 최종 result. (U3, 같은 파일 하단)\n *\n * 중요한 계약:\n *  - 입력은 AI SDK LanguageModelV3Message[] 가 아니라 **서버측 GenerateRequest** 다.\n *    ai-sdk 가 이미 QueryInput.history(JsonValue[]) 로 변환했고, decideConvRouting 이\n *    coldInput/coldHistory/reuseInput 으로 만든 뒤 dispatcher 에 도달한다.\n *  - content 는 user/assistant 모두 block 배열 `[{type:\"text\",text}]` 로 정규화한다.\n *    문자열 content 는 일부 user 단발만 통과하고 history replay 에서 깨진다\n *    (`W is not an Object (evaluating '\"tool_use_id\" in W')`).\n *  - stream-json 의 user/assistant 는 비대칭이다: assistant 는 history context 로 push 되고\n *    **user 는 새 prompt 로 enqueue(=실행)된다.** 따라서 cold 경로에서 과거 대화(user/assistant/\n *    tool)를 그대로 줄로 늘어놓으면 과거 user/tool-output 이 실행 prompt 로 재실행된다. 이를 피하려\n *    cold history 는 **단일 assistant context 텍스트로 평탄화**하고, 실행 가능한 `type:\"user\"` 줄은\n *    **마지막 input 하나뿐**이 되도록 한다. full-fidelity role replay 가 필요하면 session resume\n *    (reuseInput) 또는 JSONL backstop 으로 간다.\n *  - tool 결과는 native Anthropic tool_result 블록을 새로 만들지 않고, 기존 OpenAI 와\n *    동일하게 평탄화된 text 로 처리한다(emulation 공통 계약).\n */\n\nimport { type JsonValue } from \"../../../codex-protocol/serde_json/JsonValue\";\nimport { type UserInput } from \"../../../codex-protocol/v2/UserInput\";\nimport { type ProviderTokenUsageBreakdown } from \"../common/provider-dispatcher\";\n\n// ── 입력 어댑터 ────────────────────────────────────────────────────\n\n// Claude stream-json 입력 한 줄(JSONL). content 는 항상 block 배열.\n//\n// SDK envelope 필드(uuid / session_id / parent_tool_use_id)는 **여기서 만들지 않는다**.\n// 그 값들은 세션을 발급/소유하는 claude-session 의 책임이다. 이 모듈은 role/content 변환만 하는\n// 순수 함수로 두고, claude-session 이 직렬화 직전에 envelope 를 decorate 한다. 책임 분리.\nexport interface ClaudeStreamJsonLine {\n  type: \"user\" | \"assistant\";\n  message: {\n    role: \"user\" | \"assistant\";\n    content: Array<{ type: \"text\"; text: string }>;\n  };\n}\n\n// UserInput[] 에서 text 만 뽑아 하나의 문자열로. (image/skill/mention 등은 현재 범위 밖 — text 위주)\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\n// content 를 항상 block 배열로 정규화(문자열 content 는 history replay 에서 깨짐).\nfunction textBlock(text: string): Array<{ type: \"text\"; text: string }> {\n  return [{ type: \"text\", text }];\n}\n\n// codex ResponseItem(coldHistory 의 한 항목) 형태 판별용 최소 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\n// codex message content([{type:input_text|output_text, text}]) 에서 text 추출.\n// 여러 content 블록은 줄바꿈으로 구분(token-adjacent 붙음 방지).\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\n/**\n * cold history(codex ResponseItem[])를 **단일 평탄 텍스트**로 변환한다.\n * user/assistant/tool 모두 라벨 붙은 한 덩어리로 — 실행되지 않는 assistant context 로 들어간다.\n * (cold 의 user/tool-output 을 type:\"user\" 로 내보내면 새 prompt 로 재실행되므로 금지.)\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\n/**\n * 서버 GenerateRequest payload 를 Claude stream-json JSONL 라인 배열로 변환한다.\n *\n * @param opts.coldHistory  cold 경로의 codex ResponseItem 배열(JsonValue[]). resume 경로면 미사용.\n * @param opts.input        실행할 input — cold 면 coldInput, resume 면 reuseInput.\n * @param opts.isResume     resume 경로 여부. true 면 history 재주입 없이 input(delta)만.\n *\n * 출력 규칙:\n *  - 실행 가능한 `type:\"user\"` 줄은 **항상 정확히 1개** — 마지막 input.\n *  - resume: user(delta) 1줄만. thread 가 이전 turn 을 누적하므로 history 미포함.\n *  - cold: coldHistory 전체를 **단일 assistant context 텍스트**로 평탄화(실행 안 됨) + user(input) 1줄.\n *          user/assistant/tool 모두 평탄화되므로 과거 user/tool-output 이 재실행되지 않는다.\n *          full-fidelity role replay 가 필요하면 session resume 또는 JSONL backstop(범위 밖).\n *  - tool(function_call/output): native 블록 없이 평탄 텍스트로.\n */\nexport function buildStreamJsonInput(opts: {\n  coldHistory?: Array<JsonValue>;\n  input: Array<UserInput>;\n  isResume: boolean;\n}): Array<ClaudeStreamJsonLine> {\n  const lines: Array<ClaudeStreamJsonLine> = [];\n\n  // cold 경로: history 를 단일 assistant context 로 평탄화(실행 안 됨).\n  if (!opts.isResume && 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  // 실행할 input — resume/cold 공통, 항상 마지막의 단일 user 줄.\n  lines.push({\n    type: \"user\",\n    message: { role: \"user\", content: textBlock(userInputToText(opts.input)) },\n  });\n\n  return lines;\n}\n\n// JSONL 문자열(claude stdin 으로 흘릴 형태)로 직렬화.\nexport function serializeStreamJsonInput(lines: Array<ClaudeStreamJsonLine>): string {\n  return lines.map((l) => JSON.stringify(l)).join(\"\\n\") + \"\\n\";\n}\n\n// ── 출력 어댑터 ────────────────────────────────────────────────────\n//\n// claude -p --output-format stream-json --verbose 의 stdout(JSONL)을\n// qgrid 서버 delta(onDelta) + 최종 result 로 변환한다.\n//\n// 계약:\n//  - 이 어댑터는 qgrid **서버** 계층이다. AI SDK stream part(text-delta 등)는\n//    packages/ai-sdk(client provider)가 만든다 — 여기서 만들지 않는다.\n//  - text_delta → onDelta(text). structured output 일 때 input_json_delta.partial_json\n//    조각도 onDelta(text) 로 흘린다(client provider 가 partialObjectStream 으로 누적).\n//  - 최종 result → structured_output(우선) 또는 result(폴백, 자연어 가능) + usage + 종료.\n//  - usage 는 input/cache_creation/cache_read/output 4 카테고리를 받아 TokenUsageBreakdown 으로.\n//    payload 크기 비교는 3 카테고리 합으로(과거 학습 — input 단독 비교 무의미).\n\n// claude stream-json 출력에서 우리가 보는 usage shape(부분). Anthropic 네이티브 필드.\ninterface ClaudeUsage {\n  input_tokens?: number;\n  output_tokens?: number;\n  cache_creation_input_tokens?: number;\n  cache_read_input_tokens?: number;\n}\n\n// 최종 result 파싱 산출물. dispatcher(U1)가 GenerateResult 조립에 쓴다.\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}\n\nexport interface ClaudeStreamJsonState {\n  structuredOutputText?: string;\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  return {\n    totalTokens: totalInput + output,\n    inputTokens: totalInput,\n    cachedInputTokens: cacheRead,\n    cacheCreationInputTokens: cacheCreate,\n    outputTokens: output,\n    reasoningOutputTokens: 0,\n  };\n}\n\n// result.result 의 코드펜스(```json ... ```) 제거. structured_output 이 없을 때만 쓴다.\n// 앞뒤 공백/개행을 먼저 trim 해 `\\n```json\\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 (block.type === \"tool_use\" && block.name === \"StructuredOutput\" && block.input !== undefined) {\n      return JSON.stringify(block.input);\n    }\n  }\n  return undefined;\n}\n\n/**\n * stream-json 출력 라인 하나를 처리한다. 순수 함수 — side effect 는 onDelta 콜백뿐.\n *\n * @param opts.structuredOutput  structured output(jsonSchema) 모드 여부.\n *   structured 모드에서 Claude 는 자연어 text_delta 와 input_json_delta.partial_json 을\n *   **함께** 흘릴 수 있다(PoC 확인). 이때 text_delta 를 그대로 onDelta 로 보내면 client 의\n *   streamObject 파서가 prose 를 JSON 앞에서 만나 깨진다. 그래서:\n *     - structured 모드: text_delta 무시, partial_json 만 onDelta.\n *     - text 모드: text_delta 만 onDelta (partial_json 은 안 옴).\n *\n * @returns result 이벤트면 ClaudeStreamResult, 그 외(delta/system 등)면 null.\n *          호출부는 라인 스트림을 돌며 이 함수를 호출하고, non-null 이 나오면 종료.\n */\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    // 깨진 JSON 라인은 graceful skip.\n    return null;\n  }\n\n  // 점진 delta: stream_event > content_block_delta > {text_delta | input_json_delta}.\n  if (j.type === \"stream_event\") {\n    const event = asObject(j.event);\n    if (event && event.type === \"content_block_delta\") {\n      const delta = asObject(event.delta);\n      if (delta) {\n        if (structuredOutput) {\n          // structured: JSON 조각만. 자연어 text_delta 는 버린다(streamObject 파서 보호).\n          if (delta.type === \"input_json_delta\" && typeof delta.partial_json === \"string\") {\n            onDelta(delta.partial_json);\n          }\n        } else {\n          // text: 자연어 delta 만.\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 === \"assistant\" && structuredOutput && state && state.structuredOutputText === undefined) {\n    const text = structuredOutputToolUseText(j);\n    if (text !== undefined) state.structuredOutputText = text;\n    return null;\n  }\n\n  // 최종 result.\n  if (j.type === \"result\") {\n    let text: string;\n    const preservedStructuredOutput = structuredOutput ? state?.structuredOutputText : undefined;\n    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 usage = toUsageBreakdown((asObject(j.usage) ?? {}) as ClaudeUsage);\n    const quotaExhausted = text.startsWith(\"You've hit\");\n    // 에러 판정: is_error true, terminal model_error,\n    // 또는 subtype 이 있고 \"success\" 가 아니면(error_during_execution / error_max_turns /\n    // error_max_budget_usd / error_max_structured_output_retries 등) 에러로 본다.\n    const subtype = typeof j.subtype === \"string\" ? j.subtype : undefined;\n    const structuredMaxTurnsCompleted =\n      preservedStructuredOutput !== undefined &&\n      (subtype === \"error_max_turns\" || j.terminal_reason === \"max_turns\");\n    const isError =\n      !structuredMaxTurnsCompleted &&\n      (j.is_error === true ||\n        j.terminal_reason === \"model_error\" ||\n        (subtype !== undefined && subtype !== \"success\"));\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    };\n  }\n\n  return null;\n}\n"],"mappings":"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"}

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

@@ -39,77 +39,92 @@ const ANTHROPIC_COSTS = {
 	sonnet: {
 		inputTokens: 3,
 		outputTokens: 15,
-		cachedInputTokens: .3
+		cachedInputTokens: .3,
+		cacheCreationInputTokens: 3.75
 	},
 	"claude-3-5-haiku": {
 		inputTokens: .8,
 		outputTokens: 4,
-		cachedInputTokens: .08
+		cachedInputTokens: .08,
+		cacheCreationInputTokens: 1
 	},
 	"claude-haiku-4-5": {
 		inputTokens: 1,
 		outputTokens: 5,
-		cachedInputTokens: .1
+		cachedInputTokens: .1,
+		cacheCreationInputTokens: 1.25
 	},
 	"claude-3-5-sonnet": {
 		inputTokens: 3,
 		outputTokens: 15,
-		cachedInputTokens: .3
+		cachedInputTokens: .3,
+		cacheCreationInputTokens: 3.75
 	},
 	"claude-3-7-sonnet": {
 		inputTokens: 3,
 		outputTokens: 15,
-		cachedInputTokens: .3
+		cachedInputTokens: .3,
+		cacheCreationInputTokens: 3.75
 	},
 	"claude-sonnet-4": {
 		inputTokens: 3,
 		outputTokens: 15,
-		cachedInputTokens: .3
+		cachedInputTokens: .3,
+		cacheCreationInputTokens: 3.75
 	},
 	"claude-sonnet-4-5": {
 		inputTokens: 3,
 		outputTokens: 15,
-		cachedInputTokens: .3
+		cachedInputTokens: .3,
+		cacheCreationInputTokens: 3.75
 	},
 	"claude-sonnet-4-6": {
 		inputTokens: 3,
 		outputTokens: 15,
-		cachedInputTokens: .3
+		cachedInputTokens: .3,
+		cacheCreationInputTokens: 3.75
 	},
 	"claude-sonnet-4-7": {
 		inputTokens: 3,
 		outputTokens: 15,
-		cachedInputTokens: .3
+		cachedInputTokens: .3,
+		cacheCreationInputTokens: 3.75
 	},
 	"claude-opus-4": {
 		inputTokens: 15,
 		outputTokens: 75,
-		cachedInputTokens: 1.5
+		cachedInputTokens: 1.5,
+		cacheCreationInputTokens: 18.75
 	},
 	"claude-opus-4-1": {
 		inputTokens: 15,
 		outputTokens: 75,
-		cachedInputTokens: 1.5
+		cachedInputTokens: 1.5,
+		cacheCreationInputTokens: 18.75
 	},
 	"claude-opus-4-5": {
 		inputTokens: 5,
 		outputTokens: 25,
-		cachedInputTokens: .5
+		cachedInputTokens: .5,
+		cacheCreationInputTokens: 6.25
 	},
 	"claude-opus-4-6": {
 		inputTokens: 5,
 		outputTokens: 25,
-		cachedInputTokens: .5
+		cachedInputTokens: .5,
+		cacheCreationInputTokens: 6.25
 	},
 	"claude-opus-4-7": {
 		inputTokens: 5,
 		outputTokens: 25,
-		cachedInputTokens: .5
+		cachedInputTokens: .5,
+		cacheCreationInputTokens: 6.25
 	},
 	"claude-opus-4-8": {
 		inputTokens: 5,
 		outputTokens: 25,
-		cachedInputTokens: .5
+		cachedInputTokens: .5,
+		cacheCreationInputTokens: 6.25
 	}
 };
 const DEFAULT_COSTS = {
@@ -123,15 +138,17 @@ function getModelCosts(model) {
 function calculateCostUsd(model, usage) {
 	const costs = getModelCosts(model);
 	const cachedInput = usage.cachedInputTokens ?? 0;
-	const nonCachedInput = usage.inputTokens - cachedInput;
+	const cacheCreationInput = usage.cacheCreationInputTokens ?? 0;
+	const nonCachedInput = Math.max(usage.inputTokens - cachedInput - cacheCreationInput, 0);
 	const lc = costs.longContext;
 	const isLongContext = lc !== void 0 && usage.inputTokens > lc.threshold;
 	const inputRate = costs.inputTokens * (isLongContext ? lc.inputMultiplier : 1);
 	const cachedRate = costs.cachedInputTokens * (isLongContext ? lc.cachedInputMultiplier : 1);
+	const cacheCreationRate = (costs.cacheCreationInputTokens ?? costs.inputTokens) * (isLongContext ? lc.inputMultiplier : 1);
 	const outputRate = costs.outputTokens * (isLongContext ? lc.outputMultiplier : 1);
-	return nonCachedInput / 1e6 * inputRate + usage.outputTokens / 1e6 * outputRate + cachedInput / 1e6 * cachedRate;
+	return nonCachedInput / 1e6 * inputRate + usage.outputTokens / 1e6 * outputRate + cachedInput / 1e6 * cachedRate + cacheCreationInput / 1e6 * cacheCreationRate;
 }
 //#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  /**\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://openai.com/api/pricing (2026-06-11 확인)\n// 신모델 출시마다 단가가 바뀌므로(5.2→5.4→5.5) 모델 추가 시 반드시 공식 페이지 재확인해야함\n\n// GPT-5.4에서 처음 도입된 long-context 할증 (5.2/5.3-codex는 해당 없음, 5.4-mini는 미확인)\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  // 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\nconst ANTHROPIC_COSTS: Record<string, ModelCosts> = {\n  sonnet: { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 },\n  \"claude-3-5-haiku\": { inputTokens: 0.8, outputTokens: 4, cachedInputTokens: 0.08 },\n  \"claude-haiku-4-5\": { inputTokens: 1, outputTokens: 5, cachedInputTokens: 0.1 },\n  \"claude-3-5-sonnet\": { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 },\n  \"claude-3-7-sonnet\": { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 },\n  \"claude-sonnet-4\": { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 },\n  \"claude-sonnet-4-5\": { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 },\n  \"claude-sonnet-4-6\": { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 },\n  \"claude-sonnet-4-7\": { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 },\n  \"claude-opus-4\": { inputTokens: 15, outputTokens: 75, cachedInputTokens: 1.5 },\n  \"claude-opus-4-1\": { inputTokens: 15, outputTokens: 75, cachedInputTokens: 1.5 },\n  \"claude-opus-4-5\": { inputTokens: 5, outputTokens: 25, cachedInputTokens: 0.5 },\n  \"claude-opus-4-6\": { inputTokens: 5, outputTokens: 25, cachedInputTokens: 0.5 },\n  \"claude-opus-4-7\": { inputTokens: 5, outputTokens: 25, cachedInputTokens: 0.5 },\n  \"claude-opus-4-8\": { inputTokens: 5, outputTokens: 25, cachedInputTokens: 0.5 },\n};\n\nconst DEFAULT_COSTS: ModelCosts = { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 };\n\nexport function getModelCosts(model: string): ModelCosts {\n  return OPENAI_COSTS[model] ?? ANTHROPIC_COSTS[model] ?? DEFAULT_COSTS;\n}\n\nexport function calculateCostUsd(\n  model: string,\n  usage: { inputTokens: number; outputTokens: number; cachedInputTokens?: number },\n): number {\n  const costs = getModelCosts(model);\n  const cachedInput = usage.cachedInputTokens ?? 0;\n  const nonCachedInput = usage.inputTokens - cachedInput;\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 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  );\n}\n"],"mappings":";;AAoCA,MAAM,oBAA4D;CAChE,WAAW;CACX,iBAAiB;CACjB,uBAAuB;CACvB,kBAAkB;CACnB;AAED,MAAM,eAA2C;CAE/C,WAAW;EACT,aAAa;EACb,cAAc;EACd,mBAAmB;EACnB,aAAa;EACd;CAED,WAAW;EACT,aAAa;EACb,cAAc;EACd,mBAAmB;EACnB,aAAa;EACd;CACD,gBAAgB;EAAE,aAAa;EAAM,cAAc;EAAK,mBAAmB;EAAO;CAElF,iBAAiB;EAAE,aAAa;EAAM,cAAc;EAAI,mBAAmB;EAAO;CAElF,WAAW;EAAE,aAAa;EAAM,cAAc;EAAI,mBAAmB;EAAO;CAC7E;AAID,MAAM,kBAA8C;CAClD,QAAQ;EAAE,aAAa;EAAG,cAAc;EAAI,mBAAmB;EAAK;CACpE,oBAAoB;EAAE,aAAa;EAAK,cAAc;EAAG,mBAAmB;EAAM;CAClF,oBAAoB;EAAE,aAAa;EAAG,cAAc;EAAG,mBAAmB;EAAK;CAC/E,qBAAqB;EAAE,aAAa;EAAG,cAAc;EAAI,mBAAmB;EAAK;CACjF,qBAAqB;EAAE,aAAa;EAAG,cAAc;EAAI,mBAAmB;EAAK;CACjF,mBAAmB;EAAE,aAAa;EAAG,cAAc;EAAI,mBAAmB;EAAK;CAC/E,qBAAqB;EAAE,aAAa;EAAG,cAAc;EAAI,mBAAmB;EAAK;CACjF,qBAAqB;EAAE,aAAa;EAAG,cAAc;EAAI,mBAAmB;EAAK;CACjF,qBAAqB;EAAE,aAAa;EAAG,cAAc;EAAI,mBAAmB;EAAK;CACjF,iBAAiB;EAAE,aAAa;EAAI,cAAc;EAAI,mBAAmB;EAAK;CAC9E,mBAAmB;EAAE,aAAa;EAAI,cAAc;EAAI,mBAAmB;EAAK;CAChF,mBAAmB;EAAE,aAAa;EAAG,cAAc;EAAI,mBAAmB;EAAK;CAC/E,mBAAmB;EAAE,aAAa;EAAG,cAAc;EAAI,mBAAmB;EAAK;CAC/E,mBAAmB;EAAE,aAAa;EAAG,cAAc;EAAI,mBAAmB;EAAK;CAC/E,mBAAmB;EAAE,aAAa;EAAG,cAAc;EAAI,mBAAmB;EAAK;CAChF;AAED,MAAM,gBAA4B;CAAE,aAAa;CAAG,cAAc;CAAI,mBAAmB;CAAK;AAE9F,SAAgB,cAAc,OAA2B;AACvD,QAAO,aAAa,UAAU,gBAAgB,UAAU;;AAG1D,SAAgB,iBACd,OACA,OACQ;CACR,MAAM,QAAQ,cAAc,MAAM;CAClC,MAAM,cAAc,MAAM,qBAAqB;CAC/C,MAAM,iBAAiB,MAAM,cAAc;CAG3C,MAAM,KAAK,MAAM;CACjB,MAAM,gBAAgB,OAAO,UAAa,MAAM,cAAc,GAAG;CACjE,MAAM,YAAY,MAAM,eAAe,gBAAgB,GAAG,kBAAkB;CAC5E,MAAM,aAAa,MAAM,qBAAqB,gBAAgB,GAAG,wBAAwB;CACzF,MAAM,aAAa,MAAM,gBAAgB,gBAAgB,GAAG,mBAAmB;AAE/E,QACG,iBAAiB,MAAa,YAC9B,MAAM,eAAe,MAAa,aAClC,cAAc,MAAa"}
+//# 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  cacheCreationInputTokens?: 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://openai.com/api/pricing (2026-06-11 확인)\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  // 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\nconst ANTHROPIC_COSTS: Record<string, ModelCosts> = {\n  // Claude Code 는 별도 ttl:\"1h\" 옵션 없이 실행되므로 fallback 가격표는 5분 cache write(1.25x)를 기준으로 둔다.\n  // 1시간 cache write 는 input 2x 이지만 현재 qgrid 실행 경로의 기본값이 아니다.\n  sonnet: {\n    inputTokens: 3,\n    outputTokens: 15,\n    cachedInputTokens: 0.3,\n    cacheCreationInputTokens: 3.75,\n  },\n  \"claude-3-5-haiku\": {\n    inputTokens: 0.8,\n    outputTokens: 4,\n    cachedInputTokens: 0.08,\n    cacheCreationInputTokens: 1,\n  },\n  \"claude-haiku-4-5\": {\n    inputTokens: 1,\n    outputTokens: 5,\n    cachedInputTokens: 0.1,\n    cacheCreationInputTokens: 1.25,\n  },\n  \"claude-3-5-sonnet\": {\n    inputTokens: 3,\n    outputTokens: 15,\n    cachedInputTokens: 0.3,\n    cacheCreationInputTokens: 3.75,\n  },\n  \"claude-3-7-sonnet\": {\n    inputTokens: 3,\n    outputTokens: 15,\n    cachedInputTokens: 0.3,\n    cacheCreationInputTokens: 3.75,\n  },\n  \"claude-sonnet-4\": {\n    inputTokens: 3,\n    outputTokens: 15,\n    cachedInputTokens: 0.3,\n    cacheCreationInputTokens: 3.75,\n  },\n  \"claude-sonnet-4-5\": {\n    inputTokens: 3,\n    outputTokens: 15,\n    cachedInputTokens: 0.3,\n    cacheCreationInputTokens: 3.75,\n  },\n  \"claude-sonnet-4-6\": {\n    inputTokens: 3,\n    outputTokens: 15,\n    cachedInputTokens: 0.3,\n    cacheCreationInputTokens: 3.75,\n  },\n  \"claude-sonnet-4-7\": {\n    inputTokens: 3,\n    outputTokens: 15,\n    cachedInputTokens: 0.3,\n    cacheCreationInputTokens: 3.75,\n  },\n  \"claude-opus-4\": {\n    inputTokens: 15,\n    outputTokens: 75,\n    cachedInputTokens: 1.5,\n    cacheCreationInputTokens: 18.75,\n  },\n  \"claude-opus-4-1\": {\n    inputTokens: 15,\n    outputTokens: 75,\n    cachedInputTokens: 1.5,\n    cacheCreationInputTokens: 18.75,\n  },\n  \"claude-opus-4-5\": {\n    inputTokens: 5,\n    outputTokens: 25,\n    cachedInputTokens: 0.5,\n    cacheCreationInputTokens: 6.25,\n  },\n  \"claude-opus-4-6\": {\n    inputTokens: 5,\n    outputTokens: 25,\n    cachedInputTokens: 0.5,\n    cacheCreationInputTokens: 6.25,\n  },\n  \"claude-opus-4-7\": {\n    inputTokens: 5,\n    outputTokens: 25,\n    cachedInputTokens: 0.5,\n    cacheCreationInputTokens: 6.25,\n  },\n  \"claude-opus-4-8\": {\n    inputTokens: 5,\n    outputTokens: 25,\n    cachedInputTokens: 0.5,\n    cacheCreationInputTokens: 6.25,\n  },\n};\n\nconst DEFAULT_COSTS: ModelCosts = { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 };\n\nexport function getModelCosts(model: string): ModelCosts {\n  return OPENAI_COSTS[model] ?? ANTHROPIC_COSTS[model] ?? 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  },\n): number {\n  const costs = getModelCosts(model);\n  const cachedInput = usage.cachedInputTokens ?? 0;\n  const cacheCreationInput = usage.cacheCreationInputTokens ?? 0;\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 cacheCreationRate =\n    (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    (cacheCreationInput / 1_000_000) * cacheCreationRate\n  );\n}\n"],"mappings":";;AAqCA,MAAM,oBAA4D;CAChE,WAAW;CACX,iBAAiB;CACjB,uBAAuB;CACvB,kBAAkB;CACnB;AAED,MAAM,eAA2C;CAE/C,WAAW;EACT,aAAa;EACb,cAAc;EACd,mBAAmB;EACnB,aAAa;EACd;CAED,WAAW;EACT,aAAa;EACb,cAAc;EACd,mBAAmB;EACnB,aAAa;EACd;CACD,gBAAgB;EAAE,aAAa;EAAM,cAAc;EAAK,mBAAmB;EAAO;CAElF,iBAAiB;EAAE,aAAa;EAAM,cAAc;EAAI,mBAAmB;EAAO;CAElF,WAAW;EAAE,aAAa;EAAM,cAAc;EAAI,mBAAmB;EAAO;CAC7E;AAID,MAAM,kBAA8C;CAGlD,QAAQ;EACN,aAAa;EACb,cAAc;EACd,mBAAmB;EACnB,0BAA0B;EAC3B;CACD,oBAAoB;EAClB,aAAa;EACb,cAAc;EACd,mBAAmB;EACnB,0BAA0B;EAC3B;CACD,oBAAoB;EAClB,aAAa;EACb,cAAc;EACd,mBAAmB;EACnB,0BAA0B;EAC3B;CACD,qBAAqB;EACnB,aAAa;EACb,cAAc;EACd,mBAAmB;EACnB,0BAA0B;EAC3B;CACD,qBAAqB;EACnB,aAAa;EACb,cAAc;EACd,mBAAmB;EACnB,0BAA0B;EAC3B;CACD,mBAAmB;EACjB,aAAa;EACb,cAAc;EACd,mBAAmB;EACnB,0BAA0B;EAC3B;CACD,qBAAqB;EACnB,aAAa;EACb,cAAc;EACd,mBAAmB;EACnB,0BAA0B;EAC3B;CACD,qBAAqB;EACnB,aAAa;EACb,cAAc;EACd,mBAAmB;EACnB,0BAA0B;EAC3B;CACD,qBAAqB;EACnB,aAAa;EACb,cAAc;EACd,mBAAmB;EACnB,0BAA0B;EAC3B;CACD,iBAAiB;EACf,aAAa;EACb,cAAc;EACd,mBAAmB;EACnB,0BAA0B;EAC3B;CACD,mBAAmB;EACjB,aAAa;EACb,cAAc;EACd,mBAAmB;EACnB,0BAA0B;EAC3B;CACD,mBAAmB;EACjB,aAAa;EACb,cAAc;EACd,mBAAmB;EACnB,0BAA0B;EAC3B;CACD,mBAAmB;EACjB,aAAa;EACb,cAAc;EACd,mBAAmB;EACnB,0BAA0B;EAC3B;CACD,mBAAmB;EACjB,aAAa;EACb,cAAc;EACd,mBAAmB;EACnB,0BAA0B;EAC3B;CACD,mBAAmB;EACjB,aAAa;EACb,cAAc;EACd,mBAAmB;EACnB,0BAA0B;EAC3B;CACF;AAED,MAAM,gBAA4B;CAAE,aAAa;CAAG,cAAc;CAAI,mBAAmB;CAAK;AAE9F,SAAgB,cAAc,OAA2B;AACvD,QAAO,aAAa,UAAU,gBAAgB,UAAU;;AAG1D,SAAgB,iBACd,OACA,OAMQ;CACR,MAAM,QAAQ,cAAc,MAAM;CAClC,MAAM,cAAc,MAAM,qBAAqB;CAC/C,MAAM,qBAAqB,MAAM,4BAA4B;CAC7D,MAAM,iBAAiB,KAAK,IAAI,MAAM,cAAc,cAAc,oBAAoB,EAAE;CAGxF,MAAM,KAAK,MAAM;CACjB,MAAM,gBAAgB,OAAO,UAAa,MAAM,cAAc,GAAG;CACjE,MAAM,YAAY,MAAM,eAAe,gBAAgB,GAAG,kBAAkB;CAC5E,MAAM,aAAa,MAAM,qBAAqB,gBAAgB,GAAG,wBAAwB;CACzF,MAAM,qBACH,MAAM,4BAA4B,MAAM,gBACxC,gBAAgB,GAAG,kBAAkB;CACxC,MAAM,aAAa,MAAM,gBAAgB,gBAAgB,GAAG,mBAAmB;AAE/E,QACG,iBAAiB,MAAa,YAC9B,MAAM,eAAe,MAAa,aAClC,cAAc,MAAa,aAC3B,qBAAqB,MAAa"}

package/bundle/dist/utils/providers/openai/openai-refresh.js

@@ -16,6 +16,7 @@ const inflightRefresh = /* @__PURE__ */ new Map();
 const lastRefreshTime = /* @__PURE__ */ new Map();
 const REFRESH_MIN_INTERVAL_MS = 5e3;
 async function handleChatgptAuthTokensRefresh(tokenId) {
+	logger.info(`refresh requested for token ${tokenId} (pid=${process.pid})`);
 	const existing = inflightRefresh.get(tokenId);
 	if (existing) {
 		logger.info(`refresh dedup for token ${tokenId}`);
@@ -62,11 +63,17 @@ async function doRefresh(tokenId) {
 	});
 	if (!resp.ok) {
 		const body = await resp.text().catch(() => "");
+		let errorCode;
+		try {
+			errorCode = JSON.parse(body).error;
+		} catch {}
+		logger.error(`OpenAI refresh FAILED token=${token.name}(id=${tokenId}) status=${resp.status} code=${errorCode ?? "?"} body=${body}`);
 		throw new Error(`OpenAI refresh failed: ${resp.status} ${body}`);
 	}
 	const data = await resp.json();
 	const newRefreshToken = data.refresh_token ?? creds.refreshToken;
-	if (data.refresh_token !== null && data.refresh_token !== void 0 && data.refresh_token !== creds.refreshToken) logger.info(`refresh_token rotated for token ${token.name}`);
+	const rotated = data.refresh_token !== null && data.refresh_token !== void 0 && data.refresh_token !== creds.refreshToken;
+	if (rotated) logger.info(`refresh_token rotated for token ${token.name}`);
 	const updatedCreds = {
 		...creds,
 		accessToken: data.access_token,
@@ -74,13 +81,18 @@ async function doRefresh(tokenId) {
 		accessTokenExpiresAt: data.expires_in ? Date.now() + data.expires_in * 1e3 : creds.accessTokenExpiresAt,
 		...data.id_token ? { idToken: data.id_token } : {}
 	};
-	await TokenModel.save([{
-		id: tokenId,
-		provider: "openai",
-		credentials: updatedCreds,
-		name: token.name
-	}]);
-	logger.info(`token ${token.name} refreshed successfully`);
+	try {
+		await TokenModel.save([{
+			id: tokenId,
+			provider: "openai",
+			credentials: updatedCreds,
+			name: token.name
+		}]);
+	} catch (e) {
+		logger.error(`OpenAI refresh: DB save FAILED after rotation(rotated=${rotated}) token=${token.name}(id=${tokenId}) — 옛 refresh_token 폐기됨, DB 미반영 → 토큰 사망 위험. err=${String(e)}`);
+		throw e;
+	}
+	logger.info(`token ${token.name} refreshed successfully (rotated=${rotated})`);
 	return {
 		accessToken: data.access_token,
 		chatgptAccountId: creds.accountId,
@@ -90,4 +102,4 @@ async function doRefresh(tokenId) {
 //#endregion
 export { handleChatgptAuthTokensRefresh };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"openai-refresh.js","names":[],"sources":["../../../../src/utils/providers/openai/openai-refresh.ts"],"sourcesContent":["/**\n * OpenAI chatgptAuthTokens refresh handler.\n *\n * - codex app-server 가 401 받으면 `account/chatgptAuthTokens/refresh` server-request 를 보냄\n * - qgrid 가 DB 의 refresh_token 으로 새 access_token 을 발급받아 응답\n * - per-token inflight promise 로 concurrent refresh dedup\n * - rotation 감지: 새 refresh_token 있으면 DB 즉시 업데이트\n */\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { TokenModel } from \"../../../application/token/token.model\";\nimport { type OpenAICredentials } from \"../../../application/token/token.types\";\n\nconst logger = getLogger([\"qgrid\", \"openai-refresh\"]);\n\nimport { OPENAI_CLIENT_ID, OPENAI_TOKEN_URL } from \"./openai-constants\";\n\n// per-token inflight promise dedup + minimum interval\nconst inflightRefresh = new Map<number, Promise<RefreshResult>>();\nconst lastRefreshTime = new Map<number, number>();\nconst REFRESH_MIN_INTERVAL_MS = 5_000;\n\ninterface RefreshResult {\n  accessToken: string;\n  chatgptAccountId: string;\n  chatgptPlanType?: string;\n}\n\nexport async function handleChatgptAuthTokensRefresh(tokenId: number): Promise<RefreshResult> {\n  const existing = inflightRefresh.get(tokenId);\n  if (existing) {\n    logger.info(`refresh dedup for token ${tokenId}`);\n    return existing;\n  }\n\n  const lastAt = lastRefreshTime.get(tokenId) ?? 0;\n  if (Date.now() - lastAt < REFRESH_MIN_INTERVAL_MS) {\n    logger.info(`refresh too soon for token ${tokenId}, reading current creds from DB`);\n    return readCurrentCreds(tokenId);\n  }\n\n  lastRefreshTime.set(tokenId, Date.now());\n  const promise = doRefresh(tokenId);\n  inflightRefresh.set(tokenId, promise);\n\n  try {\n    return await promise;\n  } finally {\n    inflightRefresh.delete(tokenId);\n  }\n}\n\nasync function readCurrentCreds(tokenId: number): Promise<RefreshResult> {\n  const token = await TokenModel.findOne(\"A\", { id: tokenId });\n  if (!token || token.provider !== \"openai\") throw new Error(`token ${tokenId} not found`);\n  const creds = token.credentials as OpenAICredentials;\n  return {\n    accessToken: creds.accessToken,\n    chatgptAccountId: creds.accountId,\n    chatgptPlanType: creds.planType,\n  };\n}\n\nasync function doRefresh(tokenId: number): Promise<RefreshResult> {\n  const token = await TokenModel.findOne(\"A\", { id: tokenId });\n  if (!token || token.provider !== \"openai\") {\n    throw new Error(`token ${tokenId} not found or not openai`);\n  }\n\n  const creds = token.credentials as OpenAICredentials;\n  if (!creds.refreshToken) {\n    throw new Error(`token ${tokenId} has no refreshToken`);\n  }\n\n  logger.info(`refreshing token ${token.name} (id=${tokenId})`);\n\n  const resp = await fetch(OPENAI_TOKEN_URL, {\n    method: \"POST\",\n    headers: { \"Content-Type\": \"application/x-www-form-urlencoded\" },\n    body: new URLSearchParams({\n      grant_type: \"refresh_token\",\n      client_id: OPENAI_CLIENT_ID,\n      refresh_token: creds.refreshToken,\n    }),\n  });\n\n  if (!resp.ok) {\n    const body = await resp.text().catch(() => \"\");\n    throw new Error(`OpenAI refresh failed: ${resp.status} ${body}`);\n  }\n\n  const data = (await resp.json()) as {\n    access_token: string;\n    refresh_token?: string;\n    expires_in?: number;\n    id_token?: string;\n  };\n\n  const newRefreshToken = data.refresh_token ?? creds.refreshToken;\n  const rotated =\n    data.refresh_token !== null &&\n    data.refresh_token !== undefined &&\n    data.refresh_token !== creds.refreshToken;\n  if (rotated) {\n    logger.info(`refresh_token rotated for token ${token.name}`);\n  }\n\n  const updatedCreds: OpenAICredentials = {\n    ...creds,\n    accessToken: data.access_token,\n    refreshToken: newRefreshToken,\n    accessTokenExpiresAt: data.expires_in\n      ? Date.now() + data.expires_in * 1000\n      : creds.accessTokenExpiresAt,\n    ...(data.id_token ? { idToken: data.id_token } : {}),\n  };\n\n  await TokenModel.save([\n    {\n      id: tokenId,\n      provider: \"openai\",\n      credentials: updatedCreds,\n      name: token.name,\n    },\n  ]);\n\n  logger.info(`token ${token.name} refreshed successfully`);\n\n  return {\n    accessToken: data.access_token,\n    chatgptAccountId: creds.accountId,\n    chatgptPlanType: creds.planType,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;AAaA,MAAM,SAAS,UAAU,CAAC,SAAS,iBAAiB,CAAC;AAKrD,MAAM,kCAAkB,IAAI,KAAqC;AACjE,MAAM,kCAAkB,IAAI,KAAqB;AACjD,MAAM,0BAA0B;AAQhC,eAAsB,+BAA+B,SAAyC;CAC5F,MAAM,WAAW,gBAAgB,IAAI,QAAQ;AAC7C,KAAI,UAAU;AACZ,SAAO,KAAK,2BAA2B,UAAU;AACjD,SAAO;;CAGT,MAAM,SAAS,gBAAgB,IAAI,QAAQ,IAAI;AAC/C,KAAI,KAAK,KAAK,GAAG,SAAS,yBAAyB;AACjD,SAAO,KAAK,8BAA8B,QAAQ,iCAAiC;AACnF,SAAO,iBAAiB,QAAQ;;AAGlC,iBAAgB,IAAI,SAAS,KAAK,KAAK,CAAC;CACxC,MAAM,UAAU,UAAU,QAAQ;AAClC,iBAAgB,IAAI,SAAS,QAAQ;AAErC,KAAI;AACF,SAAO,MAAM;WACL;AACR,kBAAgB,OAAO,QAAQ;;;AAInC,eAAe,iBAAiB,SAAyC;CACvE,MAAM,QAAQ,MAAM,WAAW,QAAQ,KAAK,EAAE,IAAI,SAAS,CAAC;AAC5D,KAAI,CAAC,SAAS,MAAM,aAAa,SAAU,OAAM,IAAI,MAAM,SAAS,QAAQ,YAAY;CACxF,MAAM,QAAQ,MAAM;AACpB,QAAO;EACL,aAAa,MAAM;EACnB,kBAAkB,MAAM;EACxB,iBAAiB,MAAM;EACxB;;AAGH,eAAe,UAAU,SAAyC;CAChE,MAAM,QAAQ,MAAM,WAAW,QAAQ,KAAK,EAAE,IAAI,SAAS,CAAC;AAC5D,KAAI,CAAC,SAAS,MAAM,aAAa,SAC/B,OAAM,IAAI,MAAM,SAAS,QAAQ,0BAA0B;CAG7D,MAAM,QAAQ,MAAM;AACpB,KAAI,CAAC,MAAM,aACT,OAAM,IAAI,MAAM,SAAS,QAAQ,sBAAsB;AAGzD,QAAO,KAAK,oBAAoB,MAAM,KAAK,OAAO,QAAQ,GAAG;CAE7D,MAAM,OAAO,MAAM,MAAM,kBAAkB;EACzC,QAAQ;EACR,SAAS,EAAE,gBAAgB,qCAAqC;EAChE,MAAM,IAAI,gBAAgB;GACxB,YAAY;GACZ,WAAW;GACX,eAAe,MAAM;GACtB,CAAC;EACH,CAAC;AAEF,KAAI,CAAC,KAAK,IAAI;EACZ,MAAM,OAAO,MAAM,KAAK,MAAM,CAAC,YAAY,GAAG;AAC9C,QAAM,IAAI,MAAM,0BAA0B,KAAK,OAAO,GAAG,OAAO;;CAGlE,MAAM,OAAQ,MAAM,KAAK,MAAM;CAO/B,MAAM,kBAAkB,KAAK,iBAAiB,MAAM;AAKpD,KAHE,KAAK,kBAAkB,QACvB,KAAK,kBAAkB,UACvB,KAAK,kBAAkB,MAAM,aAE7B,QAAO,KAAK,mCAAmC,MAAM,OAAO;CAG9D,MAAM,eAAkC;EACtC,GAAG;EACH,aAAa,KAAK;EAClB,cAAc;EACd,sBAAsB,KAAK,aACvB,KAAK,KAAK,GAAG,KAAK,aAAa,MAC/B,MAAM;EACV,GAAI,KAAK,WAAW,EAAE,SAAS,KAAK,UAAU,GAAG,EAAE;EACpD;AAED,OAAM,WAAW,KAAK,CACpB;EACE,IAAI;EACJ,UAAU;EACV,aAAa;EACb,MAAM,MAAM;EACb,CACF,CAAC;AAEF,QAAO,KAAK,SAAS,MAAM,KAAK,yBAAyB;AAEzD,QAAO;EACL,aAAa,KAAK;EAClB,kBAAkB,MAAM;EACxB,iBAAiB,MAAM;EACxB"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"openai-refresh.js","names":[],"sources":["../../../../src/utils/providers/openai/openai-refresh.ts"],"sourcesContent":["/**\n * OpenAI chatgptAuthTokens refresh handler.\n *\n * - codex app-server 가 401 받으면 `account/chatgptAuthTokens/refresh` server-request 를 보냄\n * - qgrid 가 DB 의 refresh_token 으로 새 access_token 을 발급받아 응답\n * - per-token inflight promise 로 concurrent refresh dedup\n * - rotation 감지: 새 refresh_token 있으면 DB 즉시 업데이트\n */\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { TokenModel } from \"../../../application/token/token.model\";\nimport { type OpenAICredentials } from \"../../../application/token/token.types\";\n\nconst logger = getLogger([\"qgrid\", \"openai-refresh\"]);\n\nimport { OPENAI_CLIENT_ID, OPENAI_TOKEN_URL } from \"./openai-constants\";\n\n// per-token inflight promise dedup + minimum interval\nconst inflightRefresh = new Map<number, Promise<RefreshResult>>();\nconst lastRefreshTime = new Map<number, number>();\nconst REFRESH_MIN_INTERVAL_MS = 5_000;\n\ninterface RefreshResult {\n  accessToken: string;\n  chatgptAccountId: string;\n  chatgptPlanType?: string;\n}\n\nexport async function handleChatgptAuthTokensRefresh(tokenId: number): Promise<RefreshResult> {\n  logger.info(`refresh requested for token ${tokenId} (pid=${process.pid})`);\n  const existing = inflightRefresh.get(tokenId);\n  if (existing) {\n    logger.info(`refresh dedup for token ${tokenId}`);\n    return existing;\n  }\n\n  const lastAt = lastRefreshTime.get(tokenId) ?? 0;\n  if (Date.now() - lastAt < REFRESH_MIN_INTERVAL_MS) {\n    logger.info(`refresh too soon for token ${tokenId}, reading current creds from DB`);\n    return readCurrentCreds(tokenId);\n  }\n\n  lastRefreshTime.set(tokenId, Date.now());\n  const promise = doRefresh(tokenId);\n  inflightRefresh.set(tokenId, promise);\n\n  try {\n    return await promise;\n  } finally {\n    inflightRefresh.delete(tokenId);\n  }\n}\n\nasync function readCurrentCreds(tokenId: number): Promise<RefreshResult> {\n  const token = await TokenModel.findOne(\"A\", { id: tokenId });\n  if (!token || token.provider !== \"openai\") throw new Error(`token ${tokenId} not found`);\n  const creds = token.credentials as OpenAICredentials;\n  return {\n    accessToken: creds.accessToken,\n    chatgptAccountId: creds.accountId,\n    chatgptPlanType: creds.planType,\n  };\n}\n\nasync function doRefresh(tokenId: number): Promise<RefreshResult> {\n  const token = await TokenModel.findOne(\"A\", { id: tokenId });\n  if (!token || token.provider !== \"openai\") {\n    throw new Error(`token ${tokenId} not found or not openai`);\n  }\n\n  const creds = token.credentials as OpenAICredentials;\n  if (!creds.refreshToken) {\n    throw new Error(`token ${tokenId} has no refreshToken`);\n  }\n\n  logger.info(`refreshing token ${token.name} (id=${tokenId})`);\n\n  const resp = await fetch(OPENAI_TOKEN_URL, {\n    method: \"POST\",\n    headers: { \"Content-Type\": \"application/x-www-form-urlencoded\" },\n    body: new URLSearchParams({\n      grant_type: \"refresh_token\",\n      client_id: OPENAI_CLIENT_ID,\n      refresh_token: creds.refreshToken,\n    }),\n  });\n\n  if (!resp.ok) {\n    const body = await resp.text().catch(() => \"\");\n    // 401 본문의 error 코드가 토큰 사망의 결정적 사인이다.\n    //   refresh_token_expired     → refresh_token 자체 만료\n    //   refresh_token_reused      → 이미 사용된(회전 폐기된) refresh_token 재사용 → 패밀리 무효화\n    //   refresh_token_invalidated → 서버측 revoke\n    // 위 3개는 모두 영구 실패. 재등록 외 복구 불가.\n    let errorCode: string | undefined;\n    try {\n      errorCode = (JSON.parse(body) as { error?: string }).error;\n    } catch {}\n    logger.error(\n      `OpenAI refresh FAILED token=${token.name}(id=${tokenId}) status=${resp.status} ` +\n        `code=${errorCode ?? \"?\"} body=${body}`,\n    );\n    throw new Error(`OpenAI refresh failed: ${resp.status} ${body}`);\n  }\n\n  const data = (await resp.json()) as {\n    access_token: string;\n    refresh_token?: string;\n    expires_in?: number;\n    id_token?: string;\n  };\n\n  const newRefreshToken = data.refresh_token ?? creds.refreshToken;\n  const rotated =\n    data.refresh_token !== null &&\n    data.refresh_token !== undefined &&\n    data.refresh_token !== creds.refreshToken;\n  if (rotated) {\n    logger.info(`refresh_token rotated for token ${token.name}`);\n  }\n\n  const updatedCreds: OpenAICredentials = {\n    ...creds,\n    accessToken: data.access_token,\n    refreshToken: newRefreshToken,\n    accessTokenExpiresAt: data.expires_in\n      ? Date.now() + data.expires_in * 1000\n      : creds.accessTokenExpiresAt,\n    ...(data.id_token ? { idToken: data.id_token } : {}),\n  };\n\n  // 회전(rotated)이 일어났는데 이 save 가 실패하면, OpenAI 쪽 옛 refresh_token 은 이미\n  // 폐기된 상태에서 DB 에는 옛 토큰이 남는다 → 다음 refresh 가 refresh_token_reused 로\n  // 영구 사망. 이 구간 실패는 토큰 사망의 직접 원인이므로 반드시 크게 남긴다.\n  try {\n    await TokenModel.save([\n      {\n        id: tokenId,\n        provider: \"openai\",\n        credentials: updatedCreds,\n        name: token.name,\n      },\n    ]);\n  } catch (e) {\n    logger.error(\n      `OpenAI refresh: DB save FAILED after rotation(rotated=${rotated}) ` +\n        `token=${token.name}(id=${tokenId}) — 옛 refresh_token 폐기됨, DB 미반영 → 토큰 사망 위험. err=${String(e)}`,\n    );\n    throw e;\n  }\n\n  logger.info(`token ${token.name} refreshed successfully (rotated=${rotated})`);\n\n  return {\n    accessToken: data.access_token,\n    chatgptAccountId: creds.accountId,\n    chatgptPlanType: creds.planType,\n  };\n}\n"],"mappings":"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"}

package/bundle/src/application/qgrid/conv-routing.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, it } from "vitest";
+
+import { decideConvRouting, systemHash } from "./conv-routing";
+import { type QueryInput } from "./qgrid.types";
+
+function input(overrides: Partial<QueryInput> = {}): QueryInput {
+  return {
+    prompt: "hello",
+    ...overrides,
+  };
+}
+
+describe("decideConvRouting", () => {
+  it("일반 cold 첫 turn 은 기존 prompt 를 실행 input 으로 유지한다", () => {
+    const decision = decideConvRouting(input({ prompt: "first turn" }));
+
+    expect(decision.reuse).toBeUndefined();
+    expect(decision.reuseInput).toBeUndefined();
+    expect(decision.coldInput).toEqual([{ type: "text", text: "first turn", text_elements: [] }]);
+  });
+
+  it("tool result follow-up cold fallback 도 continuation 을 실행 input 으로 담는다", () => {
+    const decision = decideConvRouting(
+      input({
+        prompt: "",
+        history: JSON.stringify([
+          {
+            type: "function_call",
+            name: "getWeather",
+            arguments: '{"city":"Seoul"}',
+            call_id: "call_1",
+          },
+          {
+            type: "function_call_output",
+            call_id: "call_1",
+            output: "22C and clear",
+          },
+        ]),
+        toolResults: [
+          {
+            toolCallId: "call_1",
+            toolName: "getWeather",
+            output: "22C and clear",
+          },
+        ],
+      }),
+    );
+
+    expect(decision.reuse).toBeUndefined();
+    expect(decision.coldHistory).toHaveLength(2);
+    expect(decision.coldInput).toEqual([
+      {
+        type: "text",
+        text: "Tool result for call call_1 (getWeather): 22C and clear\n\nNow continue answering the user's request using these results.",
+        text_elements: [],
+      },
+    ]);
+  });
+
+  it("reuse 가능한 tool result follow-up 은 reuseInput 과 coldInput 이 같은 continuation 을 쓴다", () => {
+    const decision = decideConvRouting(
+      input({
+        prompt: "",
+        system: "same",
+        runContext: {
+          threadCoord: {
+            workerId: 1,
+            threadId: "S1",
+            epoch: 0,
+            systemHash: systemHash("same"),
+          },
+        },
+        toolResults: [{ toolCallId: "call_1", output: "ok" }],
+      }),
+    );
+
+    expect(decision.reuse).toEqual({ workerId: 1, threadId: "S1", epoch: 0 });
+    expect(decision.reuseInput).toEqual(decision.coldInput);
+    expect(decision.coldInput[0]).toMatchObject({
+      type: "text",
+      text: expect.stringContaining("Tool result for call call_1"),
+    });
+    expect(decision.coldInput[0]).not.toMatchObject({ type: "text", text: "" });
+  });
+});

package/bundle/src/application/qgrid/conv-routing.ts

@@ -68,8 +68,9 @@ export function decideConvRouting(input: QueryInput): ConvDecision {
         : undefined,
     // 재사용 turn 은 delta(마지막 user/tool 결과)만 — thread 가 이미 이전 turn 들을 누적.
     reuseInput: eligible ? buildDeltaInput(input) : undefined,
-    // 첫 turn / 폴백: 전체 prompt + history inject.
-    coldInput: [{ type: "text", text: input.prompt, text_elements: [] }],
+    // 첫 turn / 폴백: 전체 prompt + history inject. tool 결과 follow-up 이 cold 로 떨어져도
+    // 실행 user 줄에는 "이 결과로 계속 답하라"는 continuation 이 들어가야 한다.
+    coldInput: buildDeltaInput(input),
     coldHistory: history,
     systemHash: sysHash,
   };