@cartanova/qgrid-cli 2.3.2 → 2.3.4

package/bundle/dist/utils/providers/anthropic/claude-session.js

@@ -1,35 +1,25 @@
 import "../../../_virtual/_rolldown/runtime.js";
-import { ANTHROPIC_CLAUDE_CWD, ANTHROPIC_DISALLOWED_TOOLS, anthropicConfigDir, canonicalAnthropicModel } from "./anthropic-constants.js";
+import { ANTHROPIC_CLAUDE_CWD, ANTHROPIC_DISALLOWED_TOOLS, anthropicConfigDir, assertSupportedOneMillionSuffix, canonicalAnthropicModel, needsCli1mSuffix, supports1MContext } from "./anthropic-constants.js";
 import { buildStreamJsonInput, handleStreamJsonLine } from "./stream-json-adapter.js";
-import { createHash, randomUUID } from "node:crypto";
+import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 import { mkdirSync, writeFileSync } from "node:fs";
 //#region src/utils/providers/anthropic/claude-session.ts
 /**
 * claude-session — Claude CLI 세션 spawn + QgridThreadCoord 매핑 + per-session 락.
 *
-* 멀티턴: 첫 호출 `--session-id <uuid>`, 후속 `--resume <uuid>`. 입력은 U2 어댑터가 만든
-* JSONL 을 stdin 으로 흘리고(`--input-format stream-json`), 출력은 U3 파서로 처리한다.
+* 멀티턴: 매 호출 fresh `--session-id <uuid>`로 실행한다. 입력은 어댑터가 만든 JSONL 을
+* stdin 으로 흘리고(`--input-format stream-json`), 출력은 파서로 처리한다.
 *
 * 핵심 계약:
 *  - coord 는 임의 저장이 아니라 기존 QgridThreadCoord{workerId,threadId,epoch,systemHash} 에
 *    매핑한다. threadId=세션 uuid, epoch=0 고정(worker restart 개념 없음), workerId=token 기반
 *    안정 합성, systemHash=요청 system 해시. issueConvContext/decideConvRouting 과 round-trip.
-*  - resume eligibility 는 systemHash 만으로 부족 → 확장 호환키(system+model+structured 모드)로
-*    판정. 불일치면 cold fallback.
-*  - 같은 세션의 동시 turn 은 per-session 락(session-id 단위 직렬화)으로 transcript 오염 방지.
+*  - withSessionLock 은 exported primitive 로 유지한다. 기본 경로에서는 매 호출 새 session-id 라
+*    사실상 no-contention 이지만, 직접 호출자/테스트의 직렬화 보장은 보존한다.
 *  - stream-json 직렬화 시 SDK envelope(uuid/session_id/parent_tool_use_id) decorate.
 *  - structured output 일 때 출력 파서에 { structuredOutput: true } 전달(없으면 streamObject 깨짐).
-*
-* ⚠️ 첫 호출 동시성: resume 가 아닌 "첫 호출"은 여기서 새 랜덤 session-id 를 발급하므로, 같은
-*    qgrid sessionKey 에 대한 두 동시 첫 호출은 서로 다른 id 로 둘 다 실행된다. 현재 IF/owner scope 는
-*    LLM 호출을 순차 실행하고 sessionKey 를 서버로 보내지 않으므로, dispatcher 는 cold 락을 두지 않는다.
-*    병렬 첫 호출을 서버가 지원하게 되면 sessionKey 전달/락 설계부터 다시 잡아야 한다.
 */
-function compatibilityKey(opts) {
-	const schemaPart = opts.outputSchema && opts.outputSchema.length > 0 ? opts.outputSchema : "text";
-	return createHash("sha256").update(`${opts.system ?? ""}\0${opts.model}\0${schemaPart}`).digest("hex").slice(0, 16);
-}
 const sessionChains = /* @__PURE__ */ new Map();
 async function withSessionLock(sessionId, fn) {
 	const next = (sessionChains.get(sessionId) ?? Promise.resolve()).then(fn, fn);
@@ -66,6 +56,19 @@ function ensureCwd() {
 	writeFileSync(`${ANTHROPIC_CLAUDE_CWD}/.claude/settings.json`, "{}");
 	cwdEnsured = true;
 }
+function applyOneMillionSuffix(model, needsSuffix) {
+	const base = canonicalAnthropicModel(model);
+	return needsSuffix ? `${base}[1m]` : base;
+}
+function oneMillionEnv(supported) {
+	return supported ? {} : { CLAUDE_CODE_DISABLE_1M_CONTEXT: "1" };
+}
+function structuredOutputRetriesEnv(raw = process.env.MAX_STRUCTURED_OUTPUT_RETRIES) {
+	if (!raw) return { MAX_STRUCTURED_OUTPUT_RETRIES: "1" };
+	const parsed = Number.parseInt(raw, 10);
+	if (!Number.isFinite(parsed)) return { MAX_STRUCTURED_OUTPUT_RETRIES: "1" };
+	return { MAX_STRUCTURED_OUTPUT_RETRIES: String(Math.max(parsed, 1)) };
+}
 function buildClaudeArgs(opts) {
 	const useStructured = Boolean(opts.jsonSchema && opts.jsonSchema.length > 0);
 	const args = [
@@ -83,22 +86,22 @@ function buildClaudeArgs(opts) {
 		"--output-format",
 		"stream-json",
 		"--verbose",
-		"--max-turns",
-		useStructured ? "2" : "1",
+		...opts.includePartialMessages ? ["--include-partial-messages"] : [],
 		"--permission-mode",
 		"bypassPermissions",
 		"--setting-sources",
 		"project",
 		"--model",
-		opts.model,
+		applyOneMillionSuffix(opts.model, opts.needsOneMillionSuffix ?? false),
 		"--system-prompt",
 		opts.system ?? "",
 		"--thinking",
 		"disabled",
 		"--effort",
-		opts.effort ?? "high",
+		opts.effort ?? "low",
 		"--disable-slash-commands",
-		...opts.isResume ? ["--resume", opts.sessionId] : ["--session-id", opts.sessionId]
+		"--session-id",
+		opts.sessionId
 	];
 	if (useStructured) args.push("--json-schema", opts.jsonSchema);
 	return args;
@@ -108,9 +111,11 @@ function buildClaudeArgs(opts) {
 * @param onDelta 점진 텍스트 delta(streamText) 또는 structured 부분 JSON(streamObject).
 */
 function runClaudeSession(req, onDelta) {
+	assertSupportedOneMillionSuffix(req.model);
 	const model = canonicalAnthropicModel(req.model);
-	const isResume = Boolean(req.resumeSessionId);
-	const sessionId = req.resumeSessionId ?? randomUUID();
+	const supportsOneMillion = supports1MContext(model);
+	const needsOneMillionSuffix = needsCli1mSuffix(model);
+	const sessionId = randomUUID();
 	const useStructured = Boolean(req.jsonSchema && req.jsonSchema.length > 0);
 	const workerId = makeAnthropicWorkerId(req.tokenId);
 	return withSessionLock(sessionId, () => {
@@ -122,14 +127,18 @@ function runClaudeSession(req, onDelta) {
 			effort: req.effort,
 			jsonSchema: req.jsonSchema,
 			sessionId,
-			isResume
+			needsOneMillionSuffix,
+			includePartialMessages: req.includePartialMessages
 		});
 		const stdinPayload = decorateAndSerialize(buildStreamJsonInput({
 			coldHistory: req.coldHistory,
-			input: req.input,
-			isResume
+			input: req.input
 		}), sessionId);
 		return new Promise((resolve, reject) => {
+			if (req.abortSignal?.aborted) {
+				reject(/* @__PURE__ */ new Error("aborted"));
+				return;
+			}
 			const child = spawn("claude", args, {
 				stdio: [
 					"pipe",
@@ -144,9 +153,14 @@ function runClaudeSession(req, onDelta) {
 					CLAUDE_CONFIG_DIR: configDir,
 					CLAUDE_CODE_DISABLE_AUTO_MEMORY: "1",
 					CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING: "1",
-					CLAUDE_CODE_DISABLE_1M_CONTEXT: "1",
+					...oneMillionEnv(supportsOneMillion),
 					CLAUDE_CODE_DISABLE_CLAUDE_MDS: "1",
-					CLAUDE_CODE_ATTRIBUTION_HEADER: "0"
+					CLAUDE_CODE_DISABLE_TERMINAL_TITLE: "1",
+					CLAUDE_CODE_DISABLE_BUNDLED_SKILLS: "1",
+					CLAUDE_CODE_DISABLE_WORKFLOWS: "1",
+					CLAUDE_CODE_ATTRIBUTION_HEADER: "0",
+					MAX_THINKING_TOKENS: "0",
+					...useStructured ? structuredOutputRetriesEnv() : {}
 				}
 			});
 			let settled = false;
@@ -158,9 +172,11 @@ function runClaudeSession(req, onDelta) {
 				stderrBuf = (stderrBuf + d.toString()).slice(-STDERR_CAP);
 			});
 			const stderrSuffix = () => stderrBuf.trim() ? ` — stderr: ${stderrBuf.trim()}` : "";
+			let cleanupAbort;
 			const timer = setTimeout(() => {
 				if (settled) return;
 				settled = true;
+				cleanupAbort?.();
 				child.kill();
 				reject(/* @__PURE__ */ new Error(`Claude session timeout after ${req.timeoutMs / 1e3}s`));
 			}, req.timeoutMs);
@@ -168,19 +184,23 @@ function runClaudeSession(req, onDelta) {
 				if (settled) return;
 				settled = true;
 				clearTimeout(timer);
+				cleanupAbort?.();
 				resolve({
 					...result,
 					sessionId,
 					workerId
 				});
 			};
-			req.abortSignal?.addEventListener("abort", () => {
+			const onAbort = () => {
 				if (settled) return;
 				settled = true;
 				clearTimeout(timer);
+				cleanupAbort?.();
 				child.kill();
 				reject(/* @__PURE__ */ new Error("aborted"));
-			});
+			};
+			cleanupAbort = () => req.abortSignal?.removeEventListener("abort", onAbort);
+			req.abortSignal?.addEventListener("abort", onAbort, { once: true });
 			child.stdout?.on("data", (d) => {
 				if (settled) return;
 				buffer += d.toString();
@@ -201,12 +221,14 @@ function runClaudeSession(req, onDelta) {
 				if (settled) return;
 				settled = true;
 				clearTimeout(timer);
+				cleanupAbort?.();
 				reject(/* @__PURE__ */ new Error(`Claude session closed without result${stderrSuffix()}`));
 			});
 			child.on("error", (err) => {
 				if (settled) return;
 				settled = true;
 				clearTimeout(timer);
+				cleanupAbort?.();
 				reject(/* @__PURE__ */ new Error(`Claude session spawn error: ${err.message}`));
 			});
 			child.stdin?.write(stdinPayload);
@@ -215,6 +237,6 @@ function runClaudeSession(req, onDelta) {
 	});
 }
 //#endregion
-export { buildClaudeArgs, compatibilityKey, decorateAndSerialize, ensureConfigDir, makeAnthropicWorkerId, runClaudeSession, withSessionLock };
+export { applyOneMillionSuffix, buildClaudeArgs, decorateAndSerialize, ensureConfigDir, makeAnthropicWorkerId, oneMillionEnv, runClaudeSession, structuredOutputRetriesEnv, withSessionLock };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"claude-session.js","names":[],"sources":["../../../../src/utils/providers/anthropic/claude-session.ts"],"sourcesContent":["/**\n * claude-session — Claude CLI 세션 spawn + QgridThreadCoord 매핑 + per-session 락.\n *\n * 멀티턴: 첫 호출 `--session-id <uuid>`, 후속 `--resume <uuid>`. 입력은 U2 어댑터가 만든\n * JSONL 을 stdin 으로 흘리고(`--input-format stream-json`), 출력은 U3 파서로 처리한다.\n *\n * 핵심 계약:\n *  - coord 는 임의 저장이 아니라 기존 QgridThreadCoord{workerId,threadId,epoch,systemHash} 에\n *    매핑한다. threadId=세션 uuid, epoch=0 고정(worker restart 개념 없음), workerId=token 기반\n *    안정 합성, systemHash=요청 system 해시. issueConvContext/decideConvRouting 과 round-trip.\n *  - resume eligibility 는 systemHash 만으로 부족 → 확장 호환키(system+model+structured 모드)로\n *    판정. 불일치면 cold fallback.\n *  - 같은 세션의 동시 turn 은 per-session 락(session-id 단위 직렬화)으로 transcript 오염 방지.\n *  - stream-json 직렬화 시 SDK envelope(uuid/session_id/parent_tool_use_id) decorate.\n *  - structured output 일 때 출력 파서에 { structuredOutput: true } 전달(없으면 streamObject 깨짐).\n *\n * ⚠️ 첫 호출 동시성: resume 가 아닌 \"첫 호출\"은 여기서 새 랜덤 session-id 를 발급하므로, 같은\n *    qgrid sessionKey 에 대한 두 동시 첫 호출은 서로 다른 id 로 둘 다 실행된다. 현재 IF/owner scope 는\n *    LLM 호출을 순차 실행하고 sessionKey 를 서버로 보내지 않으므로, dispatcher 는 cold 락을 두지 않는다.\n *    병렬 첫 호출을 서버가 지원하게 되면 sessionKey 전달/락 설계부터 다시 잡아야 한다.\n */\n\nimport { spawn } from \"node:child_process\";\nimport { createHash, randomUUID } from \"node:crypto\";\nimport { mkdirSync, writeFileSync } from \"node:fs\";\n\nimport { type JsonValue } from \"../../../codex-protocol/serde_json/JsonValue\";\nimport { type TokenUsageBreakdown } from \"../../../codex-protocol/v2/TokenUsageBreakdown\";\nimport { type UserInput } from \"../../../codex-protocol/v2/UserInput\";\nimport {\n  ANTHROPIC_CLAUDE_CWD,\n  anthropicConfigDir,\n  ANTHROPIC_DEFAULT_EFFORT,\n  ANTHROPIC_DISALLOWED_TOOLS,\n  canonicalAnthropicModel,\n} from \"./anthropic-constants\";\nimport {\n  buildStreamJsonInput,\n  type ClaudeStreamJsonState,\n  type ClaudeStreamJsonLine,\n  type ClaudeStreamResult,\n  handleStreamJsonLine,\n} from \"./stream-json-adapter\";\n\n// ── 호환키 ──────────────────────────────────────────────────────────\n\n// resume 가능 여부를 가르는 키. systemHash 만으로는 같은 sessionKey 를 다른 model/schema 로\n// 재사용할 때 context 오염 → system + model + structured 모드까지 묶는다.\nexport function compatibilityKey(opts: {\n  system?: string;\n  model: string;\n  // structured output schema 문자열. 없으면 text 모드. 내용이 다르면 다른 키.\n  outputSchema?: string;\n}): string {\n  const schemaPart = opts.outputSchema && opts.outputSchema.length > 0 ? opts.outputSchema : \"text\";\n  return createHash(\"sha256\")\n    .update(`${opts.system ?? \"\"}\\0${opts.model}\\0${schemaPart}`)\n    .digest(\"hex\")\n    .slice(0, 16);\n}\n\n// ── per-session 락 ─────────────────────────────────────────────────\n\n// session-id 단위 직렬화. 같은 세션의 동시 turn 이 같은 transcript 에 동시 resume·append 하는 것 방지.\nconst sessionChains = new Map<string, Promise<unknown>>();\n\nexport async function withSessionLock<T>(sessionId: string, fn: () => Promise<T>): Promise<T> {\n  const prev = sessionChains.get(sessionId) ?? Promise.resolve();\n  // 이전 turn 의 성패와 무관하게 직렬 체인을 잇는다.\n  const next = prev.then(fn, fn);\n  // tail: 성패 무관 settle 되는 핸들. 이걸 맵에 두고, finally 에서 \"여전히 내가 끝\"일 때만 삭제.\n  // (set 직후 undefined 검사로 하면 절대 삭제 안 돼 세션 id 가 누수됨 — tail 일치 검사로 회피.)\n  const tail = next.then(\n    () => {},\n    () => {},\n  );\n  sessionChains.set(sessionId, tail);\n  try {\n    return await next;\n  } finally {\n    // 그 사이 다른 turn 이 체인을 이어받았으면 tail 이 교체돼 있다 — 그때는 삭제하지 않는다.\n    if (sessionChains.get(sessionId) === tail) sessionChains.delete(sessionId);\n  }\n}\n\n// ── coord 매핑 ──────────────────────────────────────────────────────\n\n// token 기반 안정 workerId 합성. Anthropic 은 worker pool 이 없으므로 tokenId 를 그대로 쓴다.\nexport function makeAnthropicWorkerId(tokenId: number): number {\n  return tokenId;\n}\n\n// ── envelope decorate ──────────────────────────────────────────────\n\n// stream-json 입력 라인에 SDK envelope 부착 후 직렬화. session 소유자인 여기서 한다.\nexport function decorateAndSerialize(lines: Array<ClaudeStreamJsonLine>, sessionId: string): string {\n  return (\n    lines\n      .map((line) =>\n        JSON.stringify({\n          ...line,\n          session_id: sessionId,\n          uuid: randomUUID(),\n          parent_tool_use_id: null,\n        }),\n      )\n      .join(\"\\n\") + \"\\n\"\n  );\n}\n\n// ── spawn + consume ────────────────────────────────────────────────\n\nexport interface ClaudeSessionRequest {\n  tokenId: number;\n  token: string; // OAuth access token\n  model: string;\n  system?: string;\n  jsonSchema?: string; // 있으면 structured output\n  effort?: string;\n  timeoutMs: number;\n  // 입력: cold(coldHistory+coldInput) 또는 resume(reuseInput).\n  coldHistory?: Array<JsonValue>;\n  input: Array<UserInput>;\n  // resume 경로면 기존 session-id, cold 면 undefined(새로 발급).\n  resumeSessionId?: string;\n  abortSignal?: AbortSignal;\n}\n\nexport interface ClaudeSessionResult extends ClaudeStreamResult {\n  sessionId: string;\n  workerId: number;\n}\n\n// per-token CLAUDE_CONFIG_DIR 보장(격리). 경로 규칙은 anthropicConfigDir(순수 함수)이 소유 —\n// 여기선 그 경로에 빈 settings 를 깔아 claude-mem hook 등을 차단한다. (R10 격리)\n// 이 seed 파일은 claude-mem hook / 사용자 설정 오염 차단을 위한 격리 경계다. 매 호출마다 다시 써서\n// 외부 변조·삭제 후에도 다음 실행에서 self-healing 되도록 기존 semantics 를 유지한다.\nexport function ensureConfigDir(tokenId: number): string {\n  const dir = anthropicConfigDir(tokenId);\n  mkdirSync(dir, { recursive: true });\n  writeFileSync(`${dir}/.claude.json`, \"{}\");\n  writeFileSync(`${dir}/settings.json`, \"{}\");\n  return dir;\n}\n\nlet cwdEnsured = false;\nfunction ensureCwd(): void {\n  if (cwdEnsured) return;\n  mkdirSync(`${ANTHROPIC_CLAUDE_CWD}/.claude`, { recursive: true });\n  writeFileSync(`${ANTHROPIC_CLAUDE_CWD}/.claude/settings.json`, \"{}\");\n  cwdEnsured = true;\n}\n\n// spawn args 구성. 멀티턴/격리/structured 모드 반영.\nexport function buildClaudeArgs(opts: {\n  model: string;\n  system?: string;\n  effort?: string;\n  jsonSchema?: string;\n  sessionId: string;\n  isResume: boolean;\n}): Array<string> {\n  const useStructured = Boolean(opts.jsonSchema && opts.jsonSchema.length > 0);\n  // --tools \"\" 로 전체 차단, structured(jsonSchema 있음) 면 StructuredOutput 만 허용.\n  const toolArgs = useStructured\n    ? [\"--tools\", \"\", \"--allowed-tools\", \"StructuredOutput\"]\n    : [\"--tools\", \"\"];\n\n  const args: Array<string> = [\n    \"-p\",\n    ...toolArgs,\n    \"--disallowedTools\",\n    ...ANTHROPIC_DISALLOWED_TOOLS,\n    \"--input-format\",\n    \"stream-json\",\n    \"--output-format\",\n    \"stream-json\",\n    \"--verbose\",\n    \"--max-turns\",\n    useStructured ? \"2\" : \"1\",\n    \"--permission-mode\",\n    \"bypassPermissions\",\n    \"--setting-sources\",\n    \"project\",\n    \"--model\",\n    opts.model,\n    // inline [System] 금지 — 정식 채널만(R7). 생략 시 CC default(23k) 주입되므로 반드시 명시.\n    \"--system-prompt\",\n    opts.system ?? \"\",\n    \"--thinking\",\n    \"disabled\",\n    \"--effort\",\n    opts.effort ?? ANTHROPIC_DEFAULT_EFFORT,\n    \"--disable-slash-commands\",\n    // 멀티턴: 첫 호출은 session-id 발급, 후속은 resume. --no-session-persistence 는 쓰지 않는다.\n    ...(opts.isResume ? [\"--resume\", opts.sessionId] : [\"--session-id\", opts.sessionId]),\n  ];\n  if (useStructured) args.push(\"--json-schema\", opts.jsonSchema!);\n  return args;\n}\n\n/**\n * Claude 세션을 spawn 해 한 turn 을 실행한다. per-session 락으로 직렬화된다.\n * @param onDelta 점진 텍스트 delta(streamText) 또는 structured 부분 JSON(streamObject).\n */\nexport function runClaudeSession(\n  req: ClaudeSessionRequest,\n  onDelta: (text: string) => void,\n): Promise<ClaudeSessionResult> {\n  // 정규화 규칙은 canonicalAnthropicModel 이 단독 소유 — dispatcher 가 이미 canonical 을 넘기지만,\n  // 직접 호출(테스트/미래 caller) 대비 방어적으로 한 번 더 통과시킨다(이미 canonical 이면 no-op).\n  const model = canonicalAnthropicModel(req.model);\n  const isResume = Boolean(req.resumeSessionId);\n  const sessionId = req.resumeSessionId ?? randomUUID();\n  const useStructured = Boolean(req.jsonSchema && req.jsonSchema.length > 0);\n  const workerId = makeAnthropicWorkerId(req.tokenId);\n\n  return withSessionLock(sessionId, () => {\n    ensureCwd();\n    const configDir = ensureConfigDir(req.tokenId);\n\n    const args = buildClaudeArgs({\n      model,\n      system: req.system,\n      effort: req.effort,\n      jsonSchema: req.jsonSchema,\n      sessionId,\n      isResume,\n    });\n\n    const inputLines = buildStreamJsonInput({\n      coldHistory: req.coldHistory,\n      input: req.input,\n      isResume,\n    });\n    const stdinPayload = decorateAndSerialize(inputLines, sessionId);\n\n    return new Promise<ClaudeSessionResult>((resolve, reject) => {\n      const child = spawn(\"claude\", args, {\n        // stderr 도 캡처: invalid OAuth / 잘못된 플래그 / CLI 검증 실패가\n        // \"closed without result\" 로 뭉개지지 않게 close/error 에 stderr 를 실어 보낸다.\n        stdio: [\"pipe\", \"pipe\", \"pipe\"],\n        cwd: ANTHROPIC_CLAUDE_CWD,\n        env: {\n          PATH: process.env.PATH,\n          TMPDIR: process.env.TMPDIR,\n          CLAUDE_CODE_OAUTH_TOKEN: req.token,\n          CLAUDE_CONFIG_DIR: configDir,\n          CLAUDE_CODE_DISABLE_AUTO_MEMORY: \"1\",\n          CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING: \"1\",\n          CLAUDE_CODE_DISABLE_1M_CONTEXT: \"1\",\n          CLAUDE_CODE_DISABLE_CLAUDE_MDS: \"1\",\n          CLAUDE_CODE_ATTRIBUTION_HEADER: \"0\",\n        },\n      });\n\n      let settled = false;\n      let buffer = \"\";\n      const streamState: ClaudeStreamJsonState = {};\n      // bounded stderr 버퍼(최근 ~4KB만 유지 — 무한 누적 방지).\n      let stderrBuf = \"\";\n      const STDERR_CAP = 4096;\n      child.stderr?.on(\"data\", (d: Buffer) => {\n        stderrBuf = (stderrBuf + d.toString()).slice(-STDERR_CAP);\n      });\n      const stderrSuffix = () => (stderrBuf.trim() ? ` — stderr: ${stderrBuf.trim()}` : \"\");\n      const timer = setTimeout(() => {\n        if (settled) return;\n        settled = true;\n        child.kill();\n        reject(new Error(`Claude session timeout after ${req.timeoutMs / 1000}s`));\n      }, req.timeoutMs);\n\n      const finish = (result: ClaudeStreamResult) => {\n        if (settled) return;\n        settled = true;\n        clearTimeout(timer);\n        resolve({ ...result, sessionId, workerId });\n      };\n\n      req.abortSignal?.addEventListener(\"abort\", () => {\n        if (settled) return;\n        settled = true;\n        clearTimeout(timer);\n        child.kill();\n        reject(new Error(\"aborted\"));\n      });\n\n      child.stdout?.on(\"data\", (d: Buffer) => {\n        if (settled) return;\n        buffer += d.toString();\n        const lines = buffer.split(\"\\n\");\n        buffer = lines.pop() ?? \"\";\n        for (const line of lines) {\n          const result = handleStreamJsonLine(line, onDelta, {\n            structuredOutput: useStructured,\n            state: streamState,\n          });\n          if (result) {\n            finish(result);\n            return;\n          }\n        }\n      });\n\n      child.on(\"close\", () => {\n        if (settled) return;\n        settled = true;\n        clearTimeout(timer);\n        reject(new Error(`Claude session closed without result${stderrSuffix()}`));\n      });\n      child.on(\"error\", (err) => {\n        if (settled) return;\n        settled = true;\n        clearTimeout(timer);\n        reject(new Error(`Claude session spawn error: ${err.message}`));\n      });\n\n      // stdin 으로 입력 JSONL 흘리고 닫는다.\n      child.stdin?.write(stdinPayload);\n      child.stdin?.end();\n    });\n  });\n}\n\n// usage 재노출(테스트 편의).\nexport type { TokenUsageBreakdown };\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"claude-session.js","names":[],"sources":["../../../../src/utils/providers/anthropic/claude-session.ts"],"sourcesContent":["/**\n * claude-session — Claude CLI 세션 spawn + QgridThreadCoord 매핑 + per-session 락.\n *\n * 멀티턴: 매 호출 fresh `--session-id <uuid>`로 실행한다. 입력은 어댑터가 만든 JSONL 을\n * stdin 으로 흘리고(`--input-format stream-json`), 출력은 파서로 처리한다.\n *\n * 핵심 계약:\n *  - coord 는 임의 저장이 아니라 기존 QgridThreadCoord{workerId,threadId,epoch,systemHash} 에\n *    매핑한다. threadId=세션 uuid, epoch=0 고정(worker restart 개념 없음), workerId=token 기반\n *    안정 합성, systemHash=요청 system 해시. issueConvContext/decideConvRouting 과 round-trip.\n *  - withSessionLock 은 exported primitive 로 유지한다. 기본 경로에서는 매 호출 새 session-id 라\n *    사실상 no-contention 이지만, 직접 호출자/테스트의 직렬화 보장은 보존한다.\n *  - stream-json 직렬화 시 SDK envelope(uuid/session_id/parent_tool_use_id) decorate.\n *  - structured output 일 때 출력 파서에 { structuredOutput: true } 전달(없으면 streamObject 깨짐).\n */\n\nimport { spawn } from \"node:child_process\";\nimport { randomUUID } from \"node:crypto\";\nimport { mkdirSync, writeFileSync } from \"node:fs\";\n\nimport { type JsonValue } from \"../../../codex-protocol/serde_json/JsonValue\";\nimport { type TokenUsageBreakdown } from \"../../../codex-protocol/v2/TokenUsageBreakdown\";\nimport { type UserInput } from \"../../../codex-protocol/v2/UserInput\";\nimport {\n  ANTHROPIC_CLAUDE_CWD,\n  anthropicConfigDir,\n  ANTHROPIC_DEFAULT_EFFORT,\n  ANTHROPIC_DISALLOWED_TOOLS,\n  assertSupportedOneMillionSuffix,\n  canonicalAnthropicModel,\n  needsCli1mSuffix,\n  supports1MContext,\n} from \"./anthropic-constants\";\nimport {\n  buildStreamJsonInput,\n  type ClaudeStreamJsonState,\n  type ClaudeStreamJsonLine,\n  type ClaudeStreamResult,\n  handleStreamJsonLine,\n} from \"./stream-json-adapter\";\n\n// ── per-session 락 ─────────────────────────────────────────────────\n\n// session-id 단위 직렬화 primitive. 기본 경로에서는 매 호출 새 uuid 라 사실상 no-op 이지만,\n// 같은 session-id 를 직접 쓰는 호출자는 여전히 직렬화 보장을 받는다.\nconst sessionChains = new Map<string, Promise<unknown>>();\n\nexport async function withSessionLock<T>(sessionId: string, fn: () => Promise<T>): Promise<T> {\n  const prev = sessionChains.get(sessionId) ?? Promise.resolve();\n  // 이전 turn 의 성패와 무관하게 직렬 체인을 잇는다.\n  const next = prev.then(fn, fn);\n  // tail: 성패 무관 settle 되는 핸들. 이걸 맵에 두고, finally 에서 \"여전히 내가 끝\"일 때만 삭제.\n  // (set 직후 undefined 검사로 하면 절대 삭제 안 돼 세션 id 가 누수됨 — tail 일치 검사로 회피.)\n  const tail = next.then(\n    () => {},\n    () => {},\n  );\n  sessionChains.set(sessionId, tail);\n  try {\n    return await next;\n  } finally {\n    // 그 사이 다른 turn 이 체인을 이어받았으면 tail 이 교체돼 있다 — 그때는 삭제하지 않는다.\n    if (sessionChains.get(sessionId) === tail) sessionChains.delete(sessionId);\n  }\n}\n\n// ── coord 매핑 ──────────────────────────────────────────────────────\n\n// token 기반 안정 workerId 합성. Anthropic 은 worker pool 이 없으므로 tokenId 를 그대로 쓴다.\nexport function makeAnthropicWorkerId(tokenId: number): number {\n  return tokenId;\n}\n\n// ── envelope decorate ──────────────────────────────────────────────\n\n// stream-json 입력 라인에 SDK envelope 부착 후 직렬화. session 소유자인 여기서 한다.\nexport function decorateAndSerialize(\n  lines: Array<ClaudeStreamJsonLine>,\n  sessionId: string,\n): string {\n  return (\n    lines\n      .map((line) =>\n        JSON.stringify({\n          ...line,\n          session_id: sessionId,\n          uuid: randomUUID(),\n          parent_tool_use_id: null,\n        }),\n      )\n      .join(\"\\n\") + \"\\n\"\n  );\n}\n\n// ── spawn + consume ────────────────────────────────────────────────\n\nexport interface ClaudeSessionRequest {\n  tokenId: number;\n  token: string; // OAuth access token\n  model: string;\n  system?: string;\n  jsonSchema?: string; // 있으면 structured output\n  effort?: string;\n  timeoutMs: number;\n  coldHistory?: Array<JsonValue>;\n  input: Array<UserInput>;\n  abortSignal?: AbortSignal;\n  includePartialMessages?: boolean;\n}\n\nexport interface ClaudeSessionResult extends ClaudeStreamResult {\n  sessionId: string;\n  workerId: number;\n}\n\n// per-token CLAUDE_CONFIG_DIR 보장(격리). 경로 규칙은 anthropicConfigDir(순수 함수)이 소유 —\n// 여기선 그 경로에 빈 settings 를 깔아 claude-mem hook 등을 차단한다. (R10 격리)\n// 이 seed 파일은 claude-mem hook / 사용자 설정 오염 차단을 위한 격리 경계다. 매 호출마다 다시 써서\n// 외부 변조·삭제 후에도 다음 실행에서 self-healing 되도록 기존 semantics 를 유지한다.\nexport function ensureConfigDir(tokenId: number): string {\n  const dir = anthropicConfigDir(tokenId);\n  mkdirSync(dir, { recursive: true });\n  writeFileSync(`${dir}/.claude.json`, \"{}\");\n  writeFileSync(`${dir}/settings.json`, \"{}\");\n  return dir;\n}\n\nlet cwdEnsured = false;\nfunction ensureCwd(): void {\n  if (cwdEnsured) return;\n  mkdirSync(`${ANTHROPIC_CLAUDE_CWD}/.claude`, { recursive: true });\n  writeFileSync(`${ANTHROPIC_CLAUDE_CWD}/.claude/settings.json`, \"{}\");\n  cwdEnsured = true;\n}\n\n// spawn args 구성. 멀티턴/격리/structured 모드 반영.\nexport function applyOneMillionSuffix(model: string, needsSuffix: boolean): string {\n  const base = canonicalAnthropicModel(model);\n  return needsSuffix ? `${base}[1m]` : base;\n}\n\nexport function oneMillionEnv(supported: boolean): { CLAUDE_CODE_DISABLE_1M_CONTEXT?: \"1\" } {\n  return supported ? {} : { CLAUDE_CODE_DISABLE_1M_CONTEXT: \"1\" };\n}\n\n// SON-495: structured output retry 를 1 로 고정한다. CC 가 attempt 를 reject 하고 retry 하면\n// `{rejected}{accepted}` 누적이 AI-SDK 의 JSON.parse 를 깨뜨리므로, retry 자체를 막아 그 경로를\n// 원천 차단한다. `0` 은 CC query loop(`callsThisQuery >= maxRetries`)가 첫 attempt emit 전에\n// 실패시키므로(`error_max_structured_output_retries`) 외부 값이 1 미만이어도 1 로 클램프한다.\nexport function structuredOutputRetriesEnv(raw = process.env.MAX_STRUCTURED_OUTPUT_RETRIES): {\n  MAX_STRUCTURED_OUTPUT_RETRIES: string;\n} {\n  if (!raw) return { MAX_STRUCTURED_OUTPUT_RETRIES: \"1\" };\n  const parsed = Number.parseInt(raw, 10);\n  if (!Number.isFinite(parsed)) return { MAX_STRUCTURED_OUTPUT_RETRIES: \"1\" };\n  return { MAX_STRUCTURED_OUTPUT_RETRIES: String(Math.max(parsed, 1)) };\n}\n\nexport function buildClaudeArgs(opts: {\n  model: string;\n  system?: string;\n  effort?: string;\n  jsonSchema?: string;\n  sessionId: string;\n  needsOneMillionSuffix?: boolean;\n  includePartialMessages?: boolean;\n}): Array<string> {\n  const useStructured = Boolean(opts.jsonSchema && opts.jsonSchema.length > 0);\n  // --tools \"\" 로 전체 차단, structured(jsonSchema 있음) 면 StructuredOutput 만 허용.\n  const toolArgs = useStructured\n    ? [\"--tools\", \"\", \"--allowed-tools\", \"StructuredOutput\"]\n    : [\"--tools\", \"\"];\n\n  const args: Array<string> = [\n    \"-p\",\n    ...toolArgs,\n    \"--disallowedTools\",\n    ...ANTHROPIC_DISALLOWED_TOOLS,\n    \"--input-format\",\n    \"stream-json\",\n    \"--output-format\",\n    \"stream-json\",\n    \"--verbose\",\n    ...(opts.includePartialMessages ? [\"--include-partial-messages\"] : []),\n    \"--permission-mode\",\n    \"bypassPermissions\",\n    \"--setting-sources\",\n    \"project\",\n    \"--model\",\n    applyOneMillionSuffix(opts.model, opts.needsOneMillionSuffix ?? false),\n    // inline [System] 금지 — 정식 채널만(R7). 생략 시 CC default(23k) 주입되므로 반드시 명시.\n    \"--system-prompt\",\n    opts.system ?? \"\",\n    \"--thinking\",\n    \"disabled\",\n    \"--effort\",\n    opts.effort ?? ANTHROPIC_DEFAULT_EFFORT,\n    \"--disable-slash-commands\",\n    \"--session-id\",\n    opts.sessionId,\n  ];\n  if (useStructured) args.push(\"--json-schema\", opts.jsonSchema!);\n  return args;\n}\n\n/**\n * Claude 세션을 spawn 해 한 turn 을 실행한다. per-session 락으로 직렬화된다.\n * @param onDelta 점진 텍스트 delta(streamText) 또는 structured 부분 JSON(streamObject).\n */\nexport function runClaudeSession(\n  req: ClaudeSessionRequest,\n  onDelta: (text: string) => void,\n): Promise<ClaudeSessionResult> {\n  // 정규화 규칙은 canonicalAnthropicModel 이 단독 소유 — dispatcher 가 이미 canonical 을 넘기지만,\n  // 직접 호출(테스트/미래 caller) 대비 방어적으로 한 번 더 통과시킨다(이미 canonical 이면 no-op).\n  assertSupportedOneMillionSuffix(req.model);\n  const model = canonicalAnthropicModel(req.model);\n  const supportsOneMillion = supports1MContext(model);\n  const needsOneMillionSuffix = needsCli1mSuffix(model);\n  const sessionId = randomUUID();\n  const useStructured = Boolean(req.jsonSchema && req.jsonSchema.length > 0);\n  const workerId = makeAnthropicWorkerId(req.tokenId);\n\n  return withSessionLock(sessionId, () => {\n    ensureCwd();\n    const configDir = ensureConfigDir(req.tokenId);\n\n    const args = buildClaudeArgs({\n      model,\n      system: req.system,\n      effort: req.effort,\n      jsonSchema: req.jsonSchema,\n      sessionId,\n      needsOneMillionSuffix,\n      includePartialMessages: req.includePartialMessages,\n    });\n\n    const inputLines = buildStreamJsonInput({\n      coldHistory: req.coldHistory,\n      input: req.input,\n    });\n    const stdinPayload = decorateAndSerialize(inputLines, sessionId);\n\n    return new Promise<ClaudeSessionResult>((resolve, reject) => {\n      if (req.abortSignal?.aborted) {\n        reject(new Error(\"aborted\"));\n        return;\n      }\n\n      const child = spawn(\"claude\", args, {\n        // stderr 도 캡처: invalid OAuth / 잘못된 플래그 / CLI 검증 실패가\n        // \"closed without result\" 로 뭉개지지 않게 close/error 에 stderr 를 실어 보낸다.\n        stdio: [\"pipe\", \"pipe\", \"pipe\"],\n        cwd: ANTHROPIC_CLAUDE_CWD,\n        env: {\n          PATH: process.env.PATH,\n          TMPDIR: process.env.TMPDIR,\n          CLAUDE_CODE_OAUTH_TOKEN: req.token,\n          CLAUDE_CONFIG_DIR: configDir,\n          CLAUDE_CODE_DISABLE_AUTO_MEMORY: \"1\",\n          CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING: \"1\",\n          ...oneMillionEnv(supportsOneMillion),\n          CLAUDE_CODE_DISABLE_CLAUDE_MDS: \"1\",\n          CLAUDE_CODE_DISABLE_TERMINAL_TITLE: \"1\",\n          CLAUDE_CODE_DISABLE_BUNDLED_SKILLS: \"1\",\n          CLAUDE_CODE_DISABLE_WORKFLOWS: \"1\",\n          CLAUDE_CODE_ATTRIBUTION_HEADER: \"0\",\n          MAX_THINKING_TOKENS: \"0\",\n          // structured output 일 때만 retry 를 고정한다(SON-495). text 모드는 영향 없음.\n          ...(useStructured ? structuredOutputRetriesEnv() : {}),\n        },\n      });\n\n      let settled = false;\n      let buffer = \"\";\n      const streamState: ClaudeStreamJsonState = {};\n      // bounded stderr 버퍼(최근 ~4KB만 유지 — 무한 누적 방지).\n      let stderrBuf = \"\";\n      const STDERR_CAP = 4096;\n      child.stderr?.on(\"data\", (d: Buffer) => {\n        stderrBuf = (stderrBuf + d.toString()).slice(-STDERR_CAP);\n      });\n      const stderrSuffix = () => (stderrBuf.trim() ? ` — stderr: ${stderrBuf.trim()}` : \"\");\n      let cleanupAbort: (() => void) | undefined;\n      const timer = setTimeout(() => {\n        if (settled) return;\n        settled = true;\n        cleanupAbort?.();\n        child.kill();\n        reject(new Error(`Claude session timeout after ${req.timeoutMs / 1000}s`));\n      }, req.timeoutMs);\n\n      const finish = (result: ClaudeStreamResult) => {\n        if (settled) return;\n        settled = true;\n        clearTimeout(timer);\n        cleanupAbort?.();\n        resolve({ ...result, sessionId, workerId });\n      };\n\n      const onAbort = () => {\n        if (settled) return;\n        settled = true;\n        clearTimeout(timer);\n        cleanupAbort?.();\n        child.kill();\n        reject(new Error(\"aborted\"));\n      };\n      cleanupAbort = () => req.abortSignal?.removeEventListener(\"abort\", onAbort);\n      req.abortSignal?.addEventListener(\"abort\", onAbort, { once: true });\n\n      child.stdout?.on(\"data\", (d: Buffer) => {\n        if (settled) return;\n        buffer += d.toString();\n        const lines = buffer.split(\"\\n\");\n        buffer = lines.pop() ?? \"\";\n        for (const line of lines) {\n          const result = handleStreamJsonLine(line, onDelta, {\n            structuredOutput: useStructured,\n            state: streamState,\n          });\n          if (result) {\n            finish(result);\n            return;\n          }\n        }\n      });\n\n      child.on(\"close\", () => {\n        if (settled) return;\n        settled = true;\n        clearTimeout(timer);\n        cleanupAbort?.();\n        reject(new Error(`Claude session closed without result${stderrSuffix()}`));\n      });\n      child.on(\"error\", (err) => {\n        if (settled) return;\n        settled = true;\n        clearTimeout(timer);\n        cleanupAbort?.();\n        reject(new Error(`Claude session spawn error: ${err.message}`));\n      });\n\n      // stdin 으로 입력 JSONL 흘리고 닫는다.\n      child.stdin?.write(stdinPayload);\n      child.stdin?.end();\n    });\n  });\n}\n\n// usage 재노출(테스트 편의).\nexport type { TokenUsageBreakdown };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA6CA,MAAM,gCAAgB,IAAI,KAA+B;AAEzD,eAAsB,gBAAmB,WAAmB,IAAkC;CAG5F,MAAM,QAFO,cAAc,IAAI,UAAU,IAAI,QAAQ,SAAS,EAE5C,KAAK,IAAI,GAAG;CAG9B,MAAM,OAAO,KAAK,WACV,UACA,GACP;AACD,eAAc,IAAI,WAAW,KAAK;AAClC,KAAI;AACF,SAAO,MAAM;WACL;AAER,MAAI,cAAc,IAAI,UAAU,KAAK,KAAM,eAAc,OAAO,UAAU;;;AAO9E,SAAgB,sBAAsB,SAAyB;AAC7D,QAAO;;AAMT,SAAgB,qBACd,OACA,WACQ;AACR,QACE,MACG,KAAK,SACJ,KAAK,UAAU;EACb,GAAG;EACH,YAAY;EACZ,MAAM,YAAY;EAClB,oBAAoB;EACrB,CAAC,CACH,CACA,KAAK,KAAK,GAAG;;AA6BpB,SAAgB,gBAAgB,SAAyB;CACvD,MAAM,MAAM,mBAAmB,QAAQ;AACvC,WAAU,KAAK,EAAE,WAAW,MAAM,CAAC;AACnC,eAAc,GAAG,IAAI,gBAAgB,KAAK;AAC1C,eAAc,GAAG,IAAI,iBAAiB,KAAK;AAC3C,QAAO;;AAGT,IAAI,aAAa;AACjB,SAAS,YAAkB;AACzB,KAAI,WAAY;AAChB,WAAU,GAAG,qBAAqB,WAAW,EAAE,WAAW,MAAM,CAAC;AACjE,eAAc,GAAG,qBAAqB,yBAAyB,KAAK;AACpE,cAAa;;AAIf,SAAgB,sBAAsB,OAAe,aAA8B;CACjF,MAAM,OAAO,wBAAwB,MAAM;AAC3C,QAAO,cAAc,GAAG,KAAK,QAAQ;;AAGvC,SAAgB,cAAc,WAA8D;AAC1F,QAAO,YAAY,EAAE,GAAG,EAAE,gCAAgC,KAAK;;AAOjE,SAAgB,2BAA2B,MAAM,QAAQ,IAAI,+BAE3D;AACA,KAAI,CAAC,IAAK,QAAO,EAAE,+BAA+B,KAAK;CACvD,MAAM,SAAS,OAAO,SAAS,KAAK,GAAG;AACvC,KAAI,CAAC,OAAO,SAAS,OAAO,CAAE,QAAO,EAAE,+BAA+B,KAAK;AAC3E,QAAO,EAAE,+BAA+B,OAAO,KAAK,IAAI,QAAQ,EAAE,CAAC,EAAE;;AAGvE,SAAgB,gBAAgB,MAQd;CAChB,MAAM,gBAAgB,QAAQ,KAAK,cAAc,KAAK,WAAW,SAAS,EAAE;CAM5E,MAAM,OAAsB;EAC1B;EACA,GANe,gBACb;GAAC;GAAW;GAAI;GAAmB;GAAmB,GACtD,CAAC,WAAW,GAAG;EAKjB;EACA,GAAG;EACH;EACA;EACA;EACA;EACA;EACA,GAAI,KAAK,yBAAyB,CAAC,6BAA6B,GAAG,EAAE;EACrE;EACA;EACA;EACA;EACA;EACA,sBAAsB,KAAK,OAAO,KAAK,yBAAyB,MAAM;EAEtE;EACA,KAAK,UAAU;EACf;EACA;EACA;EACA,KAAK,UAAA;EACL;EACA;EACA,KAAK;EACN;AACD,KAAI,cAAe,MAAK,KAAK,iBAAiB,KAAK,WAAY;AAC/D,QAAO;;;;;;AAOT,SAAgB,iBACd,KACA,SAC8B;AAG9B,iCAAgC,IAAI,MAAM;CAC1C,MAAM,QAAQ,wBAAwB,IAAI,MAAM;CAChD,MAAM,qBAAqB,kBAAkB,MAAM;CACnD,MAAM,wBAAwB,iBAAiB,MAAM;CACrD,MAAM,YAAY,YAAY;CAC9B,MAAM,gBAAgB,QAAQ,IAAI,cAAc,IAAI,WAAW,SAAS,EAAE;CAC1E,MAAM,WAAW,sBAAsB,IAAI,QAAQ;AAEnD,QAAO,gBAAgB,iBAAiB;AACtC,aAAW;EACX,MAAM,YAAY,gBAAgB,IAAI,QAAQ;EAE9C,MAAM,OAAO,gBAAgB;GAC3B;GACA,QAAQ,IAAI;GACZ,QAAQ,IAAI;GACZ,YAAY,IAAI;GAChB;GACA;GACA,wBAAwB,IAAI;GAC7B,CAAC;EAMF,MAAM,eAAe,qBAJF,qBAAqB;GACtC,aAAa,IAAI;GACjB,OAAO,IAAI;GACZ,CAAC,EACoD,UAAU;AAEhE,SAAO,IAAI,SAA8B,SAAS,WAAW;AAC3D,OAAI,IAAI,aAAa,SAAS;AAC5B,2BAAO,IAAI,MAAM,UAAU,CAAC;AAC5B;;GAGF,MAAM,QAAQ,MAAM,UAAU,MAAM;IAGlC,OAAO;KAAC;KAAQ;KAAQ;KAAO;IAC/B,KAAK;IACL,KAAK;KACH,MAAM,QAAQ,IAAI;KAClB,QAAQ,QAAQ,IAAI;KACpB,yBAAyB,IAAI;KAC7B,mBAAmB;KACnB,iCAAiC;KACjC,uCAAuC;KACvC,GAAG,cAAc,mBAAmB;KACpC,gCAAgC;KAChC,oCAAoC;KACpC,oCAAoC;KACpC,+BAA+B;KAC/B,gCAAgC;KAChC,qBAAqB;KAErB,GAAI,gBAAgB,4BAA4B,GAAG,EAAE;KACtD;IACF,CAAC;GAEF,IAAI,UAAU;GACd,IAAI,SAAS;GACb,MAAM,cAAqC,EAAE;GAE7C,IAAI,YAAY;GAChB,MAAM,aAAa;AACnB,SAAM,QAAQ,GAAG,SAAS,MAAc;AACtC,iBAAa,YAAY,EAAE,UAAU,EAAE,MAAM,CAAC,WAAW;KACzD;GACF,MAAM,qBAAsB,UAAU,MAAM,GAAG,cAAc,UAAU,MAAM,KAAK;GAClF,IAAI;GACJ,MAAM,QAAQ,iBAAiB;AAC7B,QAAI,QAAS;AACb,cAAU;AACV,oBAAgB;AAChB,UAAM,MAAM;AACZ,2BAAO,IAAI,MAAM,gCAAgC,IAAI,YAAY,IAAK,GAAG,CAAC;MACzE,IAAI,UAAU;GAEjB,MAAM,UAAU,WAA+B;AAC7C,QAAI,QAAS;AACb,cAAU;AACV,iBAAa,MAAM;AACnB,oBAAgB;AAChB,YAAQ;KAAE,GAAG;KAAQ;KAAW;KAAU,CAAC;;GAG7C,MAAM,gBAAgB;AACpB,QAAI,QAAS;AACb,cAAU;AACV,iBAAa,MAAM;AACnB,oBAAgB;AAChB,UAAM,MAAM;AACZ,2BAAO,IAAI,MAAM,UAAU,CAAC;;AAE9B,wBAAqB,IAAI,aAAa,oBAAoB,SAAS,QAAQ;AAC3E,OAAI,aAAa,iBAAiB,SAAS,SAAS,EAAE,MAAM,MAAM,CAAC;AAEnE,SAAM,QAAQ,GAAG,SAAS,MAAc;AACtC,QAAI,QAAS;AACb,cAAU,EAAE,UAAU;IACtB,MAAM,QAAQ,OAAO,MAAM,KAAK;AAChC,aAAS,MAAM,KAAK,IAAI;AACxB,SAAK,MAAM,QAAQ,OAAO;KACxB,MAAM,SAAS,qBAAqB,MAAM,SAAS;MACjD,kBAAkB;MAClB,OAAO;MACR,CAAC;AACF,SAAI,QAAQ;AACV,aAAO,OAAO;AACd;;;KAGJ;AAEF,SAAM,GAAG,eAAe;AACtB,QAAI,QAAS;AACb,cAAU;AACV,iBAAa,MAAM;AACnB,oBAAgB;AAChB,2BAAO,IAAI,MAAM,uCAAuC,cAAc,GAAG,CAAC;KAC1E;AACF,SAAM,GAAG,UAAU,QAAQ;AACzB,QAAI,QAAS;AACb,cAAU;AACV,iBAAa,MAAM;AACnB,oBAAgB;AAChB,2BAAO,IAAI,MAAM,+BAA+B,IAAI,UAAU,CAAC;KAC/D;AAGF,SAAM,OAAO,MAAM,aAAa;AAChC,SAAM,OAAO,KAAK;IAClB;GACF"}

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

@@ -20,11 +20,6 @@ function responseItemText(item) {
 		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) {
@@ -43,24 +38,9 @@ function flattenColdHistory(coldHistory) {
 	}
 	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) {
+	if (opts.coldHistory && opts.coldHistory.length > 0) {
 		const flattened = flattenColdHistory(opts.coldHistory);
 		if (flattened) lines.push({
 			type: "assistant",
@@ -109,19 +89,6 @@ function structuredOutputToolUseText(j) {
 		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;
@@ -159,14 +126,17 @@ function handleStreamJsonLine(line, onDelta, opts) {
 		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");
+		const terminalReason = typeof j.terminal_reason === "string" ? j.terminal_reason : void 0;
+		const isError = 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
+			isError,
+			subtype,
+			terminalReason
 		};
 	}
 	return null;
@@ -174,4 +144,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 * 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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"}
+//# 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 { type ProviderTokenUsageBreakdown } 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}\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}\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\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\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 && 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 (\n    j.type === \"assistant\" &&\n    structuredOutput &&\n    state &&\n    state.structuredOutputText === undefined\n  ) {\n    const text = structuredOutputToolUseText(j);\n    if (text !== undefined) state.structuredOutputText = text;\n    return null;\n  }\n\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    const subtype = typeof j.subtype === \"string\" ? j.subtype : undefined;\n    const terminalReason = typeof j.terminal_reason === \"string\" ? j.terminal_reason : undefined;\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\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    };\n  }\n\n  return null;\n}\n"],"mappings":"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"}

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

@@ -133,7 +133,8 @@ const DEFAULT_COSTS = {
 	cachedInputTokens: .3
 };
 function getModelCosts(model) {
-	return OPENAI_COSTS[model] ?? ANTHROPIC_COSTS[model] ?? DEFAULT_COSTS;
+	const normalizedModel = model.replace(/\[1m\]$/i, "");
+	return OPENAI_COSTS[normalizedModel] ?? ANTHROPIC_COSTS[normalizedModel] ?? DEFAULT_COSTS;
 }
 function calculateCostUsd(model, usage) {
 	const costs = getModelCosts(model);
@@ -151,4 +152,4 @@ function calculateCostUsd(model, usage) {
 //#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  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"}
+//# 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  const normalizedModel = model.replace(/\\[1m\\]$/i, \"\");\n  return OPENAI_COSTS[normalizedModel] ?? ANTHROPIC_COSTS[normalizedModel] ?? DEFAULT_COSTS;\n}\n\nexport function calculateCostUsd(\n  model: string,\n  usage: {\n    inputTokens: number;\n    outputTokens: number;\n    cachedInputTokens?: number;\n    cacheCreationInputTokens?: number;\n  },\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;CACvD,MAAM,kBAAkB,MAAM,QAAQ,YAAY,GAAG;AACrD,QAAO,aAAa,oBAAoB,gBAAgB,oBAAoB;;AAG9E,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"}