@cartanova/qgrid-cli 2.3.3 → 2.3.5

package/bundle/dist/application/qgrid/qgrid.dispatcher.js

@@ -34,8 +34,8 @@ var QgridDispatcherClass = class {
 	}
 	async query(input, timeoutMs) {
 		if (input.tools?.length && input.jsonSchema) throw new ProcessError("tools and jsonSchema cannot be used together");
-		const outputSchema = buildStrictOutputSchema(input);
 		const route = parseProviderRoute(input.model);
+		const outputSchema = buildStrictOutputSchema(input);
 		if (route.provider === "openai") {
 			if (!this.openaiDispatcher) throw new QuotaError("OpenAI dispatcher not initialized");
 			const decision = decideConvRouting(input);
@@ -69,8 +69,8 @@ var QgridDispatcherClass = class {
 		throw directLlmApiFallbackNotImplemented(input);
 	}
 	async queryStream(input, cb, abortSignal) {
-		const outputSchema = buildStrictOutputSchema(input);
 		const route = parseProviderRoute(input.model);
+		const outputSchema = buildStrictOutputSchema(input);
 		if (route.provider === "openai") {
 			if (!this.openaiDispatcher) throw new QuotaError("OpenAI dispatcher not initialized");
 			const decision = decideConvRouting(input);
@@ -135,9 +135,12 @@ function directLlmApiFallbackNotImplemented(input) {
 	return new ProcessError(`Direct LLM API fallback not implemented for model: ${input.model ?? "<default>"}`);
 }
 function buildStrictOutputSchema(input) {
-	const outputSchema = input.tools?.length ? buildToolCallSchema(input.tools) : input.jsonSchema ? JSON.parse(input.jsonSchema) : void 0;
+	const outputSchema = buildRawOutputSchema(input);
 	return outputSchema ? strictify(outputSchema) : void 0;
 }
+function buildRawOutputSchema(input) {
+	return input.tools?.length ? buildToolCallSchema(input.tools) : input.jsonSchema ? JSON.parse(input.jsonSchema) : void 0;
+}
 function toEmulationResult(result) {
 	return {
 		text: result.text,
@@ -162,4 +165,4 @@ const QgridDispatcher = new QgridDispatcherClass();
 //#endregion
 export { QgridDispatcher, QgridDispatcherClass, buildStrictOutputSchema };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"qgrid.dispatcher.js","names":[],"sources":["../../../src/application/qgrid/qgrid.dispatcher.ts"],"sourcesContent":["/**\n * QgridDispatcher — provider dispatcher 라우팅 + 토큰 캐시/통계 싱글턴.\n *\n * - 메모리 캐시 (Map<id, TokenSubsetA>) 는 TokenSubscriber 가 pg LISTEN/NOTIFY 로 갱신\n * - OpenAI/Anthropic 요청은 각 provider dispatcher 로만 실행\n * - QuotaError 는 그대로 상위 전파\n */\n\nimport { type JsonValue } from \"../../codex-protocol/serde_json/JsonValue\";\nimport { type AnthropicDispatcher } from \"../../utils/providers/anthropic/anthropic-dispatcher\";\nimport { getAccessToken } from \"../../utils/providers/common/credentials\";\nimport { calculateCostUsd } from \"../../utils/providers/common/model-cost\";\nimport {\n  type GenerateResult,\n  type StreamCallbacks,\n} from \"../../utils/providers/common/provider-dispatcher\";\nimport { strictify } from \"../../utils/providers/common/strictifier\";\nimport { type OpenAIDispatcher } from \"../../utils/providers/openai/openai-dispatcher\";\nimport { type TokenSubsetA } from \"../sonamu.generated\";\nimport { decideConvRouting, issueConvContext } from \"./conv-routing\";\nimport { type QueryInput, type QueryOutput, type TokenStats } from \"./qgrid.types\";\nimport { maskToken, ProcessError, QuotaError } from \"./qgrid.types\";\nimport { type TokenSubscriber } from \"./token-subscriber\";\nimport { applyToolCallEmulation, buildToolCallSchema } from \"./tool-emulation\";\n\nexport class QgridDispatcherClass {\n  tokens = new Map<number, TokenSubsetA>();\n\n  // TokenStats shape 보존용. 실제 provider 요청 카운팅은 각 dispatcher 로 이동했다.\n  requestCounts = new Map<string, number>();\n\n  // sonamu.config onStart 에서 처리하는 변수\n  subscriber: TokenSubscriber | null = null;\n  openaiDispatcher: OpenAIDispatcher | null = null;\n  anthropicDispatcher: AnthropicDispatcher | null = null;\n\n  countOf(name: string): number {\n    return this.requestCounts.get(name) ?? 0;\n  }\n\n  // TokenSubscriber 콜백 — 캐시 mutation\n  upsertCache(id: number, row: TokenSubsetA): void {\n    this.tokens.set(id, row);\n  }\n\n  removeCache(id: number): void {\n    this.tokens.delete(id);\n  }\n\n  replaceCache(rows: TokenSubsetA[]): void {\n    this.tokens = new Map(rows.map((r) => [r.id, r]));\n  }\n\n  getStats(): TokenStats[] {\n    return [...this.tokens.values()].map((r) => ({\n      token: maskToken(getAccessToken(r.credentials)),\n      name: r.name,\n      provider: r.provider,\n      requests: this.countOf(r.name),\n    }));\n  }\n\n  async query(input: QueryInput, timeoutMs?: number): Promise<QueryOutput> {\n    void timeoutMs;\n\n    if (input.tools?.length && input.jsonSchema) {\n      throw new ProcessError(\"tools and jsonSchema cannot be used together\");\n    }\n\n    const outputSchema = buildStrictOutputSchema(input);\n    const route = parseProviderRoute(input.model);\n\n    // provider prefix routing: 'openai/gpt-5.4' → OpenAIDispatcher\n    if (route.provider === \"openai\") {\n      if (!this.openaiDispatcher) throw new QuotaError(\"OpenAI dispatcher not initialized\");\n\n      const decision = decideConvRouting(input);\n      const result = await this.openaiDispatcher.generate({\n        model: route.model,\n        systemPrompt: input.system,\n        outputSchema,\n        effort: input.effort,\n        verbosity: input.verbosity,\n        reasoningSummary: input.reasoningSummary,\n        serviceTier: input.serviceTier,\n        coldInput: decision.coldInput,\n        coldHistory: decision.coldHistory,\n        reuse: decision.reuse,\n        reuseInput: decision.reuseInput,\n      });\n\n      return applyToolCallEmulation(\n        toEmulationResult(result),\n        input.tools,\n        issueConvContext(result.threadCoord, decision),\n      );\n    } else if (route.provider === \"anthropic\") {\n      if (!this.anthropicDispatcher) throw new QuotaError(\"Anthropic dispatcher not initialized\");\n\n      const decision = decideConvRouting(input);\n      const result = await this.anthropicDispatcher.generate({\n        // AnthropicDispatcher 내부에서 알아서 provider prefix 를 canonical model 로 정규화함\n        model: input.model,\n        systemPrompt: input.system,\n        outputSchema,\n        effort: input.effort,\n        coldInput: decision.coldInput,\n        coldHistory: decision.coldHistory,\n      });\n\n      return applyToolCallEmulation(\n        toEmulationResult(result),\n        input.tools,\n        issueConvContext(result.threadCoord, decision),\n      );\n    }\n\n    throw directLlmApiFallbackNotImplemented(input);\n  }\n\n  async queryStream(\n    input: QueryInput,\n    cb: StreamCallbacks<QueryOutput>,\n    abortSignal?: AbortSignal,\n  ): Promise<void> {\n    const outputSchema = buildStrictOutputSchema(input);\n    const route = parseProviderRoute(input.model);\n\n    if (route.provider === \"openai\") {\n      if (!this.openaiDispatcher) throw new QuotaError(\"OpenAI dispatcher not initialized\");\n\n      const decision = decideConvRouting(input);\n      await this.openaiDispatcher.generateStream(\n        {\n          model: route.model,\n          systemPrompt: input.system,\n          outputSchema,\n          effort: input.effort,\n          verbosity: input.verbosity,\n          reasoningSummary: input.reasoningSummary,\n          serviceTier: input.serviceTier,\n          coldInput: decision.coldInput,\n          coldHistory: decision.coldHistory,\n          reuse: decision.reuse,\n          reuseInput: decision.reuseInput,\n          abortSignal,\n        },\n        {\n          onDelta: cb.onDelta,\n          onThreadId: cb.onThreadId,\n          onTurnId: cb.onTurnId,\n          onComplete: (turnResult) => {\n            cb.onComplete(\n              applyToolCallEmulation(\n                toEmulationResult(turnResult),\n                input.tools,\n                issueConvContext(turnResult.threadCoord, decision),\n              ),\n            );\n          },\n          onError: cb.onError,\n        },\n      );\n      return;\n    } else if (route.provider === \"anthropic\") {\n      if (!this.anthropicDispatcher) throw new QuotaError(\"Anthropic dispatcher not initialized\");\n\n      const decision = decideConvRouting(input);\n      await this.anthropicDispatcher.generateStream(\n        {\n          model: input.model,\n          systemPrompt: input.system,\n          outputSchema,\n          effort: input.effort,\n          coldInput: decision.coldInput,\n          coldHistory: decision.coldHistory,\n          abortSignal,\n        },\n        {\n          onDelta: cb.onDelta,\n          onThreadId: cb.onThreadId,\n          onComplete: (turnResult) => {\n            const issuedCoord = issueConvContext(turnResult.threadCoord, decision);\n            cb.onComplete(\n              applyToolCallEmulation(toEmulationResult(turnResult), input.tools, issuedCoord),\n            );\n          },\n          onError: cb.onError,\n        },\n      );\n      return;\n    }\n\n    throw directLlmApiFallbackNotImplemented(input);\n  }\n}\n\nfunction parseProviderRoute(model: string | undefined): { provider?: string; model: string } {\n  if (!model?.includes(\"/\")) {\n    return { model: model ?? \"\" };\n  }\n\n  const [provider, routedModel] = model.split(\"/\", 2);\n  if (!provider || !routedModel) throw new ProcessError(\"unknown model\");\n  return { provider, model: routedModel };\n}\n\n// qgrid provider dispatcher 에서 처리하지 않는 모델은 향후 직접 LLM API 호출 지점으로 보낸다.\nfunction directLlmApiFallbackNotImplemented(input: QueryInput): ProcessError {\n  return new ProcessError(\n    `Direct LLM API fallback not implemented for model: ${input.model ?? \"<default>\"}`,\n  );\n}\n\nexport function buildStrictOutputSchema(\n  input: Pick<QueryInput, \"tools\" | \"jsonSchema\">,\n): JsonValue | undefined {\n  const outputSchema = input.tools?.length\n    ? buildToolCallSchema(input.tools)\n    : input.jsonSchema\n      ? (JSON.parse(input.jsonSchema) as JsonValue)\n      : undefined;\n\n  return outputSchema\n    ? (strictify(outputSchema as Parameters<typeof strictify>[0]) as JsonValue)\n    : undefined;\n}\n\n// GenerateResult(provider dispatcher 응답)를 applyToolCallEmulation 입력 shape 로 매핑한다.\n// OpenAI/Anthropic, query/queryStream 4 경로가 동일하게 쓴다.\n// Anthropic adapter 는 cache creation 을 inputTokens 에 포함해 표준화하고, 별도 필드에도 보존한다.\n// per-request cost 는 provider 가 준 값을 우선 사용하고, 없으면 공통 cost 함수를 쓴다.\nfunction toEmulationResult(\n  result: GenerateResult,\n): Omit<QueryOutput, \"content\" | \"finishReason\" | \"runContext\"> {\n  return {\n    text: result.text,\n    tokenName: result.tokenName,\n    model: result.model,\n    usage: {\n      input_tokens: result.usage.inputTokens,\n      output_tokens: result.usage.outputTokens,\n      cache_creation_input_tokens: result.usage.cacheCreationInputTokens ?? 0,\n      cache_read_input_tokens: result.usage.cachedInputTokens,\n    },\n    durationMs: result.durationMs,\n    costUsd:\n      result.costUsd !== undefined && result.costUsd > 0\n        ? result.costUsd\n        : calculateCostUsd(result.model, {\n            inputTokens: result.usage.inputTokens,\n            outputTokens: result.usage.outputTokens,\n            cachedInputTokens: result.usage.cachedInputTokens,\n            cacheCreationInputTokens: result.usage.cacheCreationInputTokens ?? 0,\n          }),\n  };\n}\n\nexport const QgridDispatcher = new QgridDispatcherClass();\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"qgrid.dispatcher.js","names":[],"sources":["../../../src/application/qgrid/qgrid.dispatcher.ts"],"sourcesContent":["/**\n * QgridDispatcher — provider dispatcher 라우팅 + 토큰 캐시/통계 싱글턴.\n *\n * - 메모리 캐시 (Map<id, TokenSubsetA>) 는 TokenSubscriber 가 pg LISTEN/NOTIFY 로 갱신\n * - OpenAI/Anthropic 요청은 각 provider dispatcher 로만 실행\n * - QuotaError 는 그대로 상위 전파\n */\n\nimport { type JsonValue } from \"../../codex-protocol/serde_json/JsonValue\";\nimport { type AnthropicDispatcher } from \"../../utils/providers/anthropic/anthropic-dispatcher\";\nimport { getAccessToken } from \"../../utils/providers/common/credentials\";\nimport { calculateCostUsd } from \"../../utils/providers/common/model-cost\";\nimport {\n  type GenerateResult,\n  type StreamCallbacks,\n} from \"../../utils/providers/common/provider-dispatcher\";\nimport { strictify } from \"../../utils/providers/common/strictifier\";\nimport { type OpenAIDispatcher } from \"../../utils/providers/openai/openai-dispatcher\";\nimport { type TokenSubsetA } from \"../sonamu.generated\";\nimport { decideConvRouting, issueConvContext } from \"./conv-routing\";\nimport { type QueryInput, type QueryOutput, type TokenStats } from \"./qgrid.types\";\nimport { maskToken, ProcessError, QuotaError } from \"./qgrid.types\";\nimport { type TokenSubscriber } from \"./token-subscriber\";\nimport { applyToolCallEmulation, buildToolCallSchema } from \"./tool-emulation\";\n\nexport class QgridDispatcherClass {\n  tokens = new Map<number, TokenSubsetA>();\n\n  // TokenStats shape 보존용. 실제 provider 요청 카운팅은 각 dispatcher 로 이동했다.\n  requestCounts = new Map<string, number>();\n\n  // sonamu.config onStart 에서 처리하는 변수\n  subscriber: TokenSubscriber | null = null;\n  openaiDispatcher: OpenAIDispatcher | null = null;\n  anthropicDispatcher: AnthropicDispatcher | null = null;\n\n  countOf(name: string): number {\n    return this.requestCounts.get(name) ?? 0;\n  }\n\n  // TokenSubscriber 콜백 — 캐시 mutation\n  upsertCache(id: number, row: TokenSubsetA): void {\n    this.tokens.set(id, row);\n  }\n\n  removeCache(id: number): void {\n    this.tokens.delete(id);\n  }\n\n  replaceCache(rows: TokenSubsetA[]): void {\n    this.tokens = new Map(rows.map((r) => [r.id, r]));\n  }\n\n  getStats(): TokenStats[] {\n    return [...this.tokens.values()].map((r) => ({\n      token: maskToken(getAccessToken(r.credentials)),\n      name: r.name,\n      provider: r.provider,\n      requests: this.countOf(r.name),\n    }));\n  }\n\n  async query(input: QueryInput, timeoutMs?: number): Promise<QueryOutput> {\n    void timeoutMs;\n\n    if (input.tools?.length && input.jsonSchema) {\n      throw new ProcessError(\"tools and jsonSchema cannot be used together\");\n    }\n\n    const route = parseProviderRoute(input.model);\n    const outputSchema = buildStrictOutputSchema(input);\n\n    // provider prefix routing: 'openai/gpt-5.4' → OpenAIDispatcher\n    if (route.provider === \"openai\") {\n      if (!this.openaiDispatcher) throw new QuotaError(\"OpenAI dispatcher not initialized\");\n\n      const decision = decideConvRouting(input);\n      const result = await this.openaiDispatcher.generate({\n        model: route.model,\n        systemPrompt: input.system,\n        outputSchema,\n        effort: input.effort,\n        verbosity: input.verbosity,\n        reasoningSummary: input.reasoningSummary,\n        serviceTier: input.serviceTier,\n        coldInput: decision.coldInput,\n        coldHistory: decision.coldHistory,\n        reuse: decision.reuse,\n        reuseInput: decision.reuseInput,\n      });\n\n      return applyToolCallEmulation(\n        toEmulationResult(result),\n        input.tools,\n        issueConvContext(result.threadCoord, decision),\n      );\n    } else if (route.provider === \"anthropic\") {\n      if (!this.anthropicDispatcher) throw new QuotaError(\"Anthropic dispatcher not initialized\");\n\n      const decision = decideConvRouting(input);\n      const result = await this.anthropicDispatcher.generate({\n        // AnthropicDispatcher 내부에서 알아서 provider prefix 를 canonical model 로 정규화함\n        model: input.model,\n        systemPrompt: input.system,\n        outputSchema,\n        effort: input.effort,\n        coldInput: decision.coldInput,\n        coldHistory: decision.coldHistory,\n      });\n\n      return applyToolCallEmulation(\n        toEmulationResult(result),\n        input.tools,\n        issueConvContext(result.threadCoord, decision),\n      );\n    }\n\n    throw directLlmApiFallbackNotImplemented(input);\n  }\n\n  async queryStream(\n    input: QueryInput,\n    cb: StreamCallbacks<QueryOutput>,\n    abortSignal?: AbortSignal,\n  ): Promise<void> {\n    const route = parseProviderRoute(input.model);\n    const outputSchema = buildStrictOutputSchema(input);\n\n    if (route.provider === \"openai\") {\n      if (!this.openaiDispatcher) throw new QuotaError(\"OpenAI dispatcher not initialized\");\n\n      const decision = decideConvRouting(input);\n      await this.openaiDispatcher.generateStream(\n        {\n          model: route.model,\n          systemPrompt: input.system,\n          outputSchema,\n          effort: input.effort,\n          verbosity: input.verbosity,\n          reasoningSummary: input.reasoningSummary,\n          serviceTier: input.serviceTier,\n          coldInput: decision.coldInput,\n          coldHistory: decision.coldHistory,\n          reuse: decision.reuse,\n          reuseInput: decision.reuseInput,\n          abortSignal,\n        },\n        {\n          onDelta: cb.onDelta,\n          onThreadId: cb.onThreadId,\n          onTurnId: cb.onTurnId,\n          onComplete: (turnResult) => {\n            cb.onComplete(\n              applyToolCallEmulation(\n                toEmulationResult(turnResult),\n                input.tools,\n                issueConvContext(turnResult.threadCoord, decision),\n              ),\n            );\n          },\n          onError: cb.onError,\n        },\n      );\n      return;\n    } else if (route.provider === \"anthropic\") {\n      if (!this.anthropicDispatcher) throw new QuotaError(\"Anthropic dispatcher not initialized\");\n\n      const decision = decideConvRouting(input);\n      await this.anthropicDispatcher.generateStream(\n        {\n          model: input.model,\n          systemPrompt: input.system,\n          outputSchema,\n          effort: input.effort,\n          coldInput: decision.coldInput,\n          coldHistory: decision.coldHistory,\n          abortSignal,\n        },\n        {\n          onDelta: cb.onDelta,\n          onThreadId: cb.onThreadId,\n          onComplete: (turnResult) => {\n            const issuedCoord = issueConvContext(turnResult.threadCoord, decision);\n            cb.onComplete(\n              applyToolCallEmulation(toEmulationResult(turnResult), input.tools, issuedCoord),\n            );\n          },\n          onError: cb.onError,\n        },\n      );\n      return;\n    }\n\n    throw directLlmApiFallbackNotImplemented(input);\n  }\n}\n\nfunction parseProviderRoute(model: string | undefined): { provider?: string; model: string } {\n  if (!model?.includes(\"/\")) {\n    return { model: model ?? \"\" };\n  }\n\n  const [provider, routedModel] = model.split(\"/\", 2);\n  if (!provider || !routedModel) throw new ProcessError(\"unknown model\");\n  return { provider, model: routedModel };\n}\n\n// qgrid provider dispatcher 에서 처리하지 않는 모델은 향후 직접 LLM API 호출 지점으로 보낸다.\nfunction directLlmApiFallbackNotImplemented(input: QueryInput): ProcessError {\n  return new ProcessError(\n    `Direct LLM API fallback not implemented for model: ${input.model ?? \"<default>\"}`,\n  );\n}\n\n// 모든 provider(OpenAI/Anthropic)가 동일하게 strict output schema 를 쓴다.\n//\n// SON-495 교훈: 한때 Anthropic route 만 required 를 제거(optionalize)해 partial/rejected attempt 가\n// 섞여도 통과하게 했으나, 실측 결과 그게 오히려 \"모델이 비는 필드를 키째 생략\"하도록 유도했다\n// (required 살린 schema 는 누락 0, loose 는 누락 다발). strict 로 두면 모델이 빠짐없이 채우고,\n// 드물게 어겨도 retry=1 + 비정상 종료는 정직한 에러(stream-json-adapter)로 받아준다.\nexport function buildStrictOutputSchema(\n  input: Pick<QueryInput, \"tools\" | \"jsonSchema\">,\n): JsonValue | undefined {\n  const outputSchema = buildRawOutputSchema(input);\n\n  return outputSchema\n    ? (strictify(outputSchema as Parameters<typeof strictify>[0]) as JsonValue)\n    : undefined;\n}\n\nfunction buildRawOutputSchema(\n  input: Pick<QueryInput, \"tools\" | \"jsonSchema\">,\n): JsonValue | undefined {\n  return input.tools?.length\n    ? buildToolCallSchema(input.tools)\n    : input.jsonSchema\n      ? (JSON.parse(input.jsonSchema) as JsonValue)\n      : undefined;\n}\n\n// GenerateResult(provider dispatcher 응답)를 applyToolCallEmulation 입력 shape 로 매핑한다.\n// OpenAI/Anthropic, query/queryStream 4 경로가 동일하게 쓴다.\n// Anthropic adapter 는 cache creation 을 inputTokens 에 포함해 표준화하고, 별도 필드에도 보존한다.\n// per-request cost 는 provider 가 준 값을 우선 사용하고, 없으면 공통 cost 함수를 쓴다.\nfunction toEmulationResult(\n  result: GenerateResult,\n): Omit<QueryOutput, \"content\" | \"finishReason\" | \"runContext\"> {\n  return {\n    text: result.text,\n    tokenName: result.tokenName,\n    model: result.model,\n    usage: {\n      input_tokens: result.usage.inputTokens,\n      output_tokens: result.usage.outputTokens,\n      cache_creation_input_tokens: result.usage.cacheCreationInputTokens ?? 0,\n      cache_read_input_tokens: result.usage.cachedInputTokens,\n    },\n    durationMs: result.durationMs,\n    costUsd:\n      result.costUsd !== undefined && result.costUsd > 0\n        ? result.costUsd\n        : calculateCostUsd(result.model, {\n            inputTokens: result.usage.inputTokens,\n            outputTokens: result.usage.outputTokens,\n            cachedInputTokens: result.usage.cachedInputTokens,\n            cacheCreationInputTokens: result.usage.cacheCreationInputTokens ?? 0,\n          }),\n  };\n}\n\nexport const QgridDispatcher = new QgridDispatcherClass();\n"],"mappings":"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"}

package/bundle/dist/utils/providers/anthropic/anthropic-dispatcher.js

@@ -132,8 +132,9 @@ var AnthropicDispatcher = class {
 			}, onDelta);
 			if (session.quotaExhausted) throw new Error(`quota exhausted (${token.name})`);
 			if (session.isError) {
-				const detail = session.text || `empty text, outputTokens=${session.usage.outputTokens}`;
-				throw new Error(`claude error (${token.name}): ${detail}`);
+				const reason = session.subtype ?? session.terminalReason ?? (session.isError ? "is_error" : "unknown");
+				const body = session.text ? session.text.length > 500 ? `${session.text.slice(0, 500)}…(${session.text.length} chars)` : session.text : `empty text, outputTokens=${session.usage.outputTokens}`;
+				throw new Error(`claude error (${token.name}) [${reason}]: ${body}`);
 			}
 			return {
 				text: session.text,
@@ -155,4 +156,4 @@ var AnthropicDispatcher = class {
 //#endregion
 export { AnthropicDispatcher };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"anthropic-dispatcher.js","names":[],"sources":["../../../../src/utils/providers/anthropic/anthropic-dispatcher.ts"],"sourcesContent":["/**\n * AnthropicDispatcher\n *\n * OpenAIDispatcher와 달리, worker pool을 두는 대신 요청별 fresh spawn\n * 토큰은 인메모리(MAP)으로 관리하고 least-used, round-robin 으로 고른다\n *\n * - 모든 요청은 fresh `--session-id` 로 실행\n * - 멀티턴 문맥은 클라이언트가 매 호출 보내는 full history 를 평탄화해 전달한다.\n * - 발급한 session-id 를 GenerateResult.threadCoord(threadId=session-id, workerId=tokenId,\n *   epoch=0)로 올려, 상위(issueConvContext)가 클라에 회송할 좌표를 만든다. 다음 turn 이 좌표를\n *   회송해도 Anthropic 라우팅에는 쓰지 않는다.\n */\n\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { TokenModel } from \"../../../application/token/token.model\";\nimport { type AnthropicCredentials } from \"../../../application/token/token.types\";\nimport { getExpiresAt, getRefreshToken } from \"../common/credentials\";\nimport {\n  type GenerateRequest,\n  type GenerateResult,\n  type GenerateStreamCallbacks,\n  type ProviderDispatcher,\n} from \"../common/provider-dispatcher\";\nimport { assertSupportedOneMillionSuffix, canonicalAnthropicModel } from \"./anthropic-constants\";\nimport { makeAnthropicWorkerId, runClaudeSession } from \"./claude-session\";\n\nconst logger = getLogger([\"qgrid\", \"anthropic-dispatcher\"]);\n\n// 1M context 정상 생성은 실측상 100s+까지 간다. 240s는 완충 장치일 뿐,\n// 거부+거대 system 재생성 지연을 완전히 해결하는 값은 아니다.\nconst DEFAULT_TIMEOUT_MS = 240_000;\n// access token 만료 임박 임계 — 기존 standalone 경로(qgrid.dispatcher.ts)와 동일(60s).\nconst REFRESH_SAFETY_MS = 60_000;\n\ninterface PooledToken {\n  id: number;\n  name: string;\n  credentials: AnthropicCredentials;\n}\n\nexport class AnthropicDispatcher implements ProviderDispatcher {\n  // tokenId → 풀 항목. start()/token 이벤트로 채움\n  private tokenPool = new Map<number, PooledToken>();\n  // tokenId 별 사용 카운터(least-used RR). name 이 아니라 id 기준 — 이름 충돌 안전\n  private requestCounts = new Map<number, number>();\n  private rrIndex = 0;\n\n  async start(): Promise<void> {\n    // OpenAIDispatcher.start() 와 동일하게 DB 에서 기존 anthropic 토큰을 self-bootstrap 한다.\n    // (서버 재시작 시 NOTIFY 가 안 오므로 부트스트랩이 없으면 풀이 빈 채로 남는다.)\n    // 이후 변경분은 token-subscriber 가 onTokenAdded/Updated/Removed 로 전달한다.\n    // findActiveByProvider 가 active=true + provider 필터를 DB 에서 처리 → inactive 는 애초에 안 온다.\n    const tokens = await TokenModel.findActiveByProvider(\"A\", \"anthropic\");\n    for (const t of tokens) {\n      this.tokenPool.set(t.id, {\n        id: t.id,\n        name: t.name,\n        credentials: t.credentials as AnthropicCredentials,\n      });\n      logger.info(`worker spawned: ${t.name}`);\n    }\n  }\n\n  async stop(): Promise<void> {\n    this.tokenPool.clear();\n    // lifecycle 정합: RR 카운터/인덱스도 비워 stop→start 재등록 시 이전 카운트가 안 남게 한다.\n    this.requestCounts.clear();\n    this.rrIndex = 0;\n  }\n\n  // 현재 풀의 토큰 수(startup 로그/health 용).\n  get tokenCount(): number {\n    return this.tokenPool.size;\n  }\n\n  // DB active anthropic 토큰 목록으로 풀을 재동기화한다(periodic reconcile/재연결용).\n  // LISTEN/NOTIFY 가 끊긴 동안 유실된 추가/삭제/비활성화를 DB 기준으로 다시 맞춘다.\n  // 이벤트 핸들러를 재사용해 풀 갱신이 일관되게 적용되도록 한다:\n  //  - DB 에 없는데 풀에 있는 토큰 → onTokenRemoved\n  //  - DB 에 있는 토큰 → 신규면 onTokenAdded, 기존이면 onTokenUpdated\n  replaceTokens(\n    rows: Array<{ id: number; name: string; credentials: AnthropicCredentials }>,\n  ): void {\n    const next = new Set(rows.map((r) => r.id));\n    // onTokenRemoved 가 tokenPool 을 delete 하므로 순회 중 수정을 피하려 키를 먼저 스냅샷한다.\n    const currentIds = Array.from(this.tokenPool.keys());\n    for (const id of currentIds) {\n      if (!next.has(id)) this.onTokenRemoved(id);\n    }\n    for (const r of rows) {\n      if (this.tokenPool.has(r.id)) this.onTokenUpdated(r.id, r.name, r.credentials);\n      else this.onTokenAdded(r.id, r.name, r.credentials);\n    }\n  }\n\n  // token events (token-subscriber 가 호출)\n  onTokenAdded(id: number, name: string, credentials: AnthropicCredentials): void {\n    this.tokenPool.set(id, { id, name, credentials });\n  }\n\n  onTokenUpdated(id: number, name: string, credentials: AnthropicCredentials): void {\n    this.tokenPool.set(id, { id, name, credentials });\n  }\n\n  onTokenRemoved(id: number): void {\n    this.tokenPool.delete(id);\n    this.requestCounts.delete(id);\n  }\n\n  private countOf(id: number): number {\n    return this.requestCounts.get(id) ?? 0;\n  }\n\n  // 요청마다 least-used RR 로 토큰을 고른다(동점이면 rrIndex 로 회전).\n  private selectToken(): PooledToken | null {\n    const rows = [...this.tokenPool.values()];\n    if (rows.length === 0) return null;\n    const minCount = Math.min(...rows.map((r) => this.countOf(r.id)));\n    const idle = rows.filter((r) => this.countOf(r.id) === minCount);\n    const picked = idle[this.rrIndex % idle.length]!;\n    this.rrIndex++;\n    return this.charge(picked);\n  }\n\n  // 선택된 토큰의 사용 카운트를 await 전에 선반영(동시 요청이 다른 토큰을 고르도록).\n  private charge(token: PooledToken): PooledToken {\n    this.requestCounts.set(token.id, this.countOf(token.id) + 1);\n    return token;\n  }\n\n  async generate(req: GenerateRequest): Promise<GenerateResult> {\n    return this.run(req, () => {});\n  }\n\n  async generateStream(req: GenerateRequest, cb: GenerateStreamCallbacks): Promise<void> {\n    try {\n      const result = await this.run(req, cb.onDelta, { includePartialMessages: true });\n      cb.onThreadId?.(result.threadCoord.threadId);\n      cb.onComplete(result);\n    } catch (e) {\n      cb.onError(e as Error);\n    }\n  }\n\n  // generate/generateStream 공통 실행. onDelta 는 스트림이면 점진 방출, 비스트림이면 no-op.\n  private async run(\n    req: GenerateRequest,\n    onDelta: (t: string) => void,\n    opts?: { includePartialMessages?: boolean },\n  ): Promise<GenerateResult> {\n    // model 정규화를 dispatcher 진입점에서 한 번 한다: result.model / runClaudeSession 전부\n    // canonical(prefix 없는 cost 키) 을 쓰게 통일. 미지정이면 ANTHROPIC_DEFAULT_MODEL — qgrid.dispatcher\n    // 의 \"sonnet\" 별칭 우회 차단. 정규화 규칙은 fallback 경로와 공유(canonicalAnthropicModel).\n    assertSupportedOneMillionSuffix(req.model);\n    const model = canonicalAnthropicModel(req.model);\n    const jsonSchema =\n      req.outputSchema !== undefined ? JSON.stringify(req.outputSchema) : undefined;\n\n    const token = this.selectToken();\n    if (!token) throw new Error(\"No anthropic tokens available\");\n\n    const exec = async (): Promise<GenerateResult> => {\n      // 만료 임박 토큰 preemptive refresh(기존 standalone 경로와 동일). 실패해도 진행.\n      let accessToken = token.credentials.accessToken;\n      const expiresAt = getExpiresAt(token.credentials);\n      if (\n        expiresAt &&\n        expiresAt - Date.now() < REFRESH_SAFETY_MS &&\n        getRefreshToken(token.credentials)\n      ) {\n        try {\n          const { QgridFrame } = await import(\"../../../application/qgrid/qgrid.frame\");\n          // provider 를 반드시 채워야 refreshToken 내부 TokenModel.save 가 성공한다.\n          // refreshToken(TokenSubsetA) 는 id/provider/credentials/name 만 사용하므로 그 4개만 넘긴다.\n          accessToken = await QgridFrame.refreshToken({\n            id: token.id,\n            provider: \"anthropic\",\n            name: token.name,\n            credentials: token.credentials,\n          } as Parameters<typeof QgridFrame.refreshToken>[0]);\n        } catch (e) {\n          logger.warn(`refresh failed for ${token.name}: ${(e as Error).message}`);\n        }\n      }\n\n      logger.info(`→ ${token.name} (model: ${model})`);\n      const session = await runClaudeSession(\n        {\n          tokenId: token.id,\n          token: accessToken,\n          model,\n          system: req.systemPrompt,\n          jsonSchema,\n          effort: req.effort,\n          timeoutMs: DEFAULT_TIMEOUT_MS,\n          coldHistory: req.coldHistory,\n          input: req.coldInput,\n          abortSignal: req.abortSignal,\n          includePartialMessages: opts?.includePartialMessages,\n        },\n        onDelta,\n      );\n\n      if (session.quotaExhausted) throw new Error(`quota exhausted (${token.name})`);\n      if (session.isError) {\n        // text 가 비어 있을 수 있으므로 진단 가능한 형태로 메시지를 만든다(subtype 등은 raw 로그 참조).\n        const detail = session.text || `empty text, outputTokens=${session.usage.outputTokens}`;\n        throw new Error(`claude error (${token.name}): ${detail}`);\n      }\n\n      return {\n        text: session.text,\n        tokenName: token.name,\n        usage: session.usage,\n        durationMs: session.durationMs,\n        costUsd: session.costUsd,\n        model,\n        // systemHash 는 상위 issueConvContext 가 채운다(여기선 비운다).\n        threadCoord: {\n          workerId: makeAnthropicWorkerId(token.id),\n          threadId: session.sessionId,\n          epoch: 0,\n        },\n      };\n    };\n\n    return exec();\n  }\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"anthropic-dispatcher.js","names":[],"sources":["../../../../src/utils/providers/anthropic/anthropic-dispatcher.ts"],"sourcesContent":["/**\n * AnthropicDispatcher\n *\n * OpenAIDispatcher와 달리, worker pool을 두는 대신 요청별 fresh spawn\n * 토큰은 인메모리(MAP)으로 관리하고 least-used, round-robin 으로 고른다\n *\n * - 모든 요청은 fresh `--session-id` 로 실행\n * - 멀티턴 문맥은 클라이언트가 매 호출 보내는 full history 를 평탄화해 전달한다.\n * - 발급한 session-id 를 GenerateResult.threadCoord(threadId=session-id, workerId=tokenId,\n *   epoch=0)로 올려, 상위(issueConvContext)가 클라에 회송할 좌표를 만든다. 다음 turn 이 좌표를\n *   회송해도 Anthropic 라우팅에는 쓰지 않는다.\n */\n\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { TokenModel } from \"../../../application/token/token.model\";\nimport { type AnthropicCredentials } from \"../../../application/token/token.types\";\nimport { getExpiresAt, getRefreshToken } from \"../common/credentials\";\nimport {\n  type GenerateRequest,\n  type GenerateResult,\n  type GenerateStreamCallbacks,\n  type ProviderDispatcher,\n} from \"../common/provider-dispatcher\";\nimport { assertSupportedOneMillionSuffix, canonicalAnthropicModel } from \"./anthropic-constants\";\nimport { makeAnthropicWorkerId, runClaudeSession } from \"./claude-session\";\n\nconst logger = getLogger([\"qgrid\", \"anthropic-dispatcher\"]);\n\n// 1M context 정상 생성은 실측상 100s+까지 간다. 240s는 완충 장치일 뿐,\n// 거부+거대 system 재생성 지연을 완전히 해결하는 값은 아니다.\nconst DEFAULT_TIMEOUT_MS = 240_000;\n// access token 만료 임박 임계 — 기존 standalone 경로(qgrid.dispatcher.ts)와 동일(60s).\nconst REFRESH_SAFETY_MS = 60_000;\n\ninterface PooledToken {\n  id: number;\n  name: string;\n  credentials: AnthropicCredentials;\n}\n\nexport class AnthropicDispatcher implements ProviderDispatcher {\n  // tokenId → 풀 항목. start()/token 이벤트로 채움\n  private tokenPool = new Map<number, PooledToken>();\n  // tokenId 별 사용 카운터(least-used RR). name 이 아니라 id 기준 — 이름 충돌 안전\n  private requestCounts = new Map<number, number>();\n  private rrIndex = 0;\n\n  async start(): Promise<void> {\n    // OpenAIDispatcher.start() 와 동일하게 DB 에서 기존 anthropic 토큰을 self-bootstrap 한다.\n    // (서버 재시작 시 NOTIFY 가 안 오므로 부트스트랩이 없으면 풀이 빈 채로 남는다.)\n    // 이후 변경분은 token-subscriber 가 onTokenAdded/Updated/Removed 로 전달한다.\n    // findActiveByProvider 가 active=true + provider 필터를 DB 에서 처리 → inactive 는 애초에 안 온다.\n    const tokens = await TokenModel.findActiveByProvider(\"A\", \"anthropic\");\n    for (const t of tokens) {\n      this.tokenPool.set(t.id, {\n        id: t.id,\n        name: t.name,\n        credentials: t.credentials as AnthropicCredentials,\n      });\n      logger.info(`worker spawned: ${t.name}`);\n    }\n  }\n\n  async stop(): Promise<void> {\n    this.tokenPool.clear();\n    // lifecycle 정합: RR 카운터/인덱스도 비워 stop→start 재등록 시 이전 카운트가 안 남게 한다.\n    this.requestCounts.clear();\n    this.rrIndex = 0;\n  }\n\n  // 현재 풀의 토큰 수(startup 로그/health 용).\n  get tokenCount(): number {\n    return this.tokenPool.size;\n  }\n\n  // DB active anthropic 토큰 목록으로 풀을 재동기화한다(periodic reconcile/재연결용).\n  // LISTEN/NOTIFY 가 끊긴 동안 유실된 추가/삭제/비활성화를 DB 기준으로 다시 맞춘다.\n  // 이벤트 핸들러를 재사용해 풀 갱신이 일관되게 적용되도록 한다:\n  //  - DB 에 없는데 풀에 있는 토큰 → onTokenRemoved\n  //  - DB 에 있는 토큰 → 신규면 onTokenAdded, 기존이면 onTokenUpdated\n  replaceTokens(\n    rows: Array<{ id: number; name: string; credentials: AnthropicCredentials }>,\n  ): void {\n    const next = new Set(rows.map((r) => r.id));\n    // onTokenRemoved 가 tokenPool 을 delete 하므로 순회 중 수정을 피하려 키를 먼저 스냅샷한다.\n    const currentIds = Array.from(this.tokenPool.keys());\n    for (const id of currentIds) {\n      if (!next.has(id)) this.onTokenRemoved(id);\n    }\n    for (const r of rows) {\n      if (this.tokenPool.has(r.id)) this.onTokenUpdated(r.id, r.name, r.credentials);\n      else this.onTokenAdded(r.id, r.name, r.credentials);\n    }\n  }\n\n  // token events (token-subscriber 가 호출)\n  onTokenAdded(id: number, name: string, credentials: AnthropicCredentials): void {\n    this.tokenPool.set(id, { id, name, credentials });\n  }\n\n  onTokenUpdated(id: number, name: string, credentials: AnthropicCredentials): void {\n    this.tokenPool.set(id, { id, name, credentials });\n  }\n\n  onTokenRemoved(id: number): void {\n    this.tokenPool.delete(id);\n    this.requestCounts.delete(id);\n  }\n\n  private countOf(id: number): number {\n    return this.requestCounts.get(id) ?? 0;\n  }\n\n  // 요청마다 least-used RR 로 토큰을 고른다(동점이면 rrIndex 로 회전).\n  private selectToken(): PooledToken | null {\n    const rows = [...this.tokenPool.values()];\n    if (rows.length === 0) return null;\n    const minCount = Math.min(...rows.map((r) => this.countOf(r.id)));\n    const idle = rows.filter((r) => this.countOf(r.id) === minCount);\n    const picked = idle[this.rrIndex % idle.length]!;\n    this.rrIndex++;\n    return this.charge(picked);\n  }\n\n  // 선택된 토큰의 사용 카운트를 await 전에 선반영(동시 요청이 다른 토큰을 고르도록).\n  private charge(token: PooledToken): PooledToken {\n    this.requestCounts.set(token.id, this.countOf(token.id) + 1);\n    return token;\n  }\n\n  async generate(req: GenerateRequest): Promise<GenerateResult> {\n    return this.run(req, () => {});\n  }\n\n  async generateStream(req: GenerateRequest, cb: GenerateStreamCallbacks): Promise<void> {\n    try {\n      const result = await this.run(req, cb.onDelta, { includePartialMessages: true });\n      cb.onThreadId?.(result.threadCoord.threadId);\n      cb.onComplete(result);\n    } catch (e) {\n      cb.onError(e as Error);\n    }\n  }\n\n  // generate/generateStream 공통 실행. onDelta 는 스트림이면 점진 방출, 비스트림이면 no-op.\n  private async run(\n    req: GenerateRequest,\n    onDelta: (t: string) => void,\n    opts?: { includePartialMessages?: boolean },\n  ): Promise<GenerateResult> {\n    // model 정규화를 dispatcher 진입점에서 한 번 한다: result.model / runClaudeSession 전부\n    // canonical(prefix 없는 cost 키) 을 쓰게 통일. 미지정이면 ANTHROPIC_DEFAULT_MODEL — qgrid.dispatcher\n    // 의 \"sonnet\" 별칭 우회 차단. 정규화 규칙은 fallback 경로와 공유(canonicalAnthropicModel).\n    assertSupportedOneMillionSuffix(req.model);\n    const model = canonicalAnthropicModel(req.model);\n    const jsonSchema =\n      req.outputSchema !== undefined ? JSON.stringify(req.outputSchema) : undefined;\n\n    const token = this.selectToken();\n    if (!token) throw new Error(\"No anthropic tokens available\");\n\n    const exec = async (): Promise<GenerateResult> => {\n      // 만료 임박 토큰 preemptive refresh(기존 standalone 경로와 동일). 실패해도 진행.\n      let accessToken = token.credentials.accessToken;\n      const expiresAt = getExpiresAt(token.credentials);\n      if (\n        expiresAt &&\n        expiresAt - Date.now() < REFRESH_SAFETY_MS &&\n        getRefreshToken(token.credentials)\n      ) {\n        try {\n          const { QgridFrame } = await import(\"../../../application/qgrid/qgrid.frame\");\n          // provider 를 반드시 채워야 refreshToken 내부 TokenModel.save 가 성공한다.\n          // refreshToken(TokenSubsetA) 는 id/provider/credentials/name 만 사용하므로 그 4개만 넘긴다.\n          accessToken = await QgridFrame.refreshToken({\n            id: token.id,\n            provider: \"anthropic\",\n            name: token.name,\n            credentials: token.credentials,\n          } as Parameters<typeof QgridFrame.refreshToken>[0]);\n        } catch (e) {\n          logger.warn(`refresh failed for ${token.name}: ${(e as Error).message}`);\n        }\n      }\n\n      logger.info(`→ ${token.name} (model: ${model})`);\n      const session = await runClaudeSession(\n        {\n          tokenId: token.id,\n          token: accessToken,\n          model,\n          system: req.systemPrompt,\n          jsonSchema,\n          effort: req.effort,\n          timeoutMs: DEFAULT_TIMEOUT_MS,\n          coldHistory: req.coldHistory,\n          input: req.coldInput,\n          abortSignal: req.abortSignal,\n          includePartialMessages: opts?.includePartialMessages,\n        },\n        onDelta,\n      );\n\n      if (session.quotaExhausted) throw new Error(`quota exhausted (${token.name})`);\n      if (session.isError) {\n        // 진단(SON-495): isError 판정 사유(subtype/terminal_reason)를 메시지 앞에 드러낸다.\n        // 그동안 detail 이 session.text(완전한 JSON 본문)뿐이라 \"schema 위반인지 / max retries 인지 /\n        // max turns 인지\"를 구분할 수 없었다. text 는 진단에 필요한 만큼만 잘라 덧붙인다.\n        const reason =\n          session.subtype ?? session.terminalReason ?? (session.isError ? \"is_error\" : \"unknown\");\n        const body = session.text\n          ? session.text.length > 500\n            ? `${session.text.slice(0, 500)}…(${session.text.length} chars)`\n            : session.text\n          : `empty text, outputTokens=${session.usage.outputTokens}`;\n        throw new Error(`claude error (${token.name}) [${reason}]: ${body}`);\n      }\n\n      return {\n        text: session.text,\n        tokenName: token.name,\n        usage: session.usage,\n        durationMs: session.durationMs,\n        costUsd: session.costUsd,\n        model,\n        // systemHash 는 상위 issueConvContext 가 채운다(여기선 비운다).\n        threadCoord: {\n          workerId: makeAnthropicWorkerId(token.id),\n          threadId: session.sessionId,\n          epoch: 0,\n        },\n      };\n    };\n\n    return exec();\n  }\n}\n"],"mappings":"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"}

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

@@ -3,7 +3,7 @@ import { ANTHROPIC_CLAUDE_CWD, ANTHROPIC_DISALLOWED_TOOLS, anthropicConfigDir, a
 import { buildStreamJsonInput, handleStreamJsonLine } from "./stream-json-adapter.js";
 import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
-import { mkdirSync, writeFileSync } from "node:fs";
+import { mkdirSync, unlinkSync, writeFileSync } from "node:fs";
 //#region src/utils/providers/anthropic/claude-session.ts
 /**
 * claude-session — Claude CLI 세션 spawn + QgridThreadCoord 매핑 + per-session 락.
@@ -63,16 +63,25 @@ function applyOneMillionSuffix(model, needsSuffix) {
 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)) };
+}
+const SYSTEM_PROMPT_ARGV_MAX_BYTES = 64 * 1024;
 function buildClaudeArgs(opts) {
 	const useStructured = Boolean(opts.jsonSchema && opts.jsonSchema.length > 0);
+	const toolArgs = useStructured ? [
+		"--tools",
+		"",
+		"--allowed-tools",
+		"StructuredOutput"
+	] : ["--tools", ""];
+	const systemArgs = opts.systemPromptFile ? ["--system-prompt-file", opts.systemPromptFile] : ["--system-prompt", opts.system ?? ""];
 	const args = [
 		"-p",
-		...useStructured ? [
-			"--tools",
-			"",
-			"--allowed-tools",
-			"StructuredOutput"
-		] : ["--tools", ""],
+		...toolArgs,
 		"--disallowedTools",
 		...ANTHROPIC_DISALLOWED_TOOLS,
 		"--input-format",
@@ -87,8 +96,7 @@ function buildClaudeArgs(opts) {
 		"project",
 		"--model",
 		applyOneMillionSuffix(opts.model, opts.needsOneMillionSuffix ?? false),
-		"--system-prompt",
-		opts.system ?? "",
+		...systemArgs,
 		"--thinking",
 		"disabled",
 		"--effort",
@@ -115,9 +123,13 @@ function runClaudeSession(req, onDelta) {
 	return withSessionLock(sessionId, () => {
 		ensureCwd();
 		const configDir = ensureConfigDir(req.tokenId);
+		const system = req.system ?? "";
+		const useSystemPromptFile = Buffer.byteLength(system, "utf8") > SYSTEM_PROMPT_ARGV_MAX_BYTES;
+		const systemPromptFile = useSystemPromptFile ? `${configDir}/system-prompt-${sessionId}.txt` : void 0;
 		const args = buildClaudeArgs({
 			model,
-			system: req.system,
+			system: useSystemPromptFile ? void 0 : req.system,
+			systemPromptFile,
 			effort: req.effort,
 			jsonSchema: req.jsonSchema,
 			sessionId,
@@ -133,6 +145,7 @@ function runClaudeSession(req, onDelta) {
 				reject(/* @__PURE__ */ new Error("aborted"));
 				return;
 			}
+			if (systemPromptFile) writeFileSync(systemPromptFile, system);
 			const child = spawn("claude", args, {
 				stdio: [
 					"pipe",
@@ -153,7 +166,8 @@ function runClaudeSession(req, onDelta) {
 					CLAUDE_CODE_DISABLE_BUNDLED_SKILLS: "1",
 					CLAUDE_CODE_DISABLE_WORKFLOWS: "1",
 					CLAUDE_CODE_ATTRIBUTION_HEADER: "0",
-					MAX_THINKING_TOKENS: "0"
+					MAX_THINKING_TOKENS: "0",
+					...useStructured ? structuredOutputRetriesEnv() : {}
 				}
 			});
 			let settled = false;
@@ -165,11 +179,18 @@ function runClaudeSession(req, onDelta) {
 				stderrBuf = (stderrBuf + d.toString()).slice(-STDERR_CAP);
 			});
 			const stderrSuffix = () => stderrBuf.trim() ? ` — stderr: ${stderrBuf.trim()}` : "";
+			const cleanupSpawnFiles = () => {
+				if (!systemPromptFile) return;
+				try {
+					unlinkSync(systemPromptFile);
+				} catch {}
+			};
 			let cleanupAbort;
 			const timer = setTimeout(() => {
 				if (settled) return;
 				settled = true;
 				cleanupAbort?.();
+				cleanupSpawnFiles();
 				child.kill();
 				reject(/* @__PURE__ */ new Error(`Claude session timeout after ${req.timeoutMs / 1e3}s`));
 			}, req.timeoutMs);
@@ -178,6 +199,7 @@ function runClaudeSession(req, onDelta) {
 				settled = true;
 				clearTimeout(timer);
 				cleanupAbort?.();
+				cleanupSpawnFiles();
 				resolve({
 					...result,
 					sessionId,
@@ -189,6 +211,7 @@ function runClaudeSession(req, onDelta) {
 				settled = true;
 				clearTimeout(timer);
 				cleanupAbort?.();
+				cleanupSpawnFiles();
 				child.kill();
 				reject(/* @__PURE__ */ new Error("aborted"));
 			};
@@ -215,6 +238,7 @@ function runClaudeSession(req, onDelta) {
 				settled = true;
 				clearTimeout(timer);
 				cleanupAbort?.();
+				cleanupSpawnFiles();
 				reject(/* @__PURE__ */ new Error(`Claude session closed without result${stderrSuffix()}`));
 			});
 			child.on("error", (err) => {
@@ -222,6 +246,7 @@ function runClaudeSession(req, onDelta) {
 				settled = true;
 				clearTimeout(timer);
 				cleanupAbort?.();
+				cleanupSpawnFiles();
 				reject(/* @__PURE__ */ new Error(`Claude session spawn error: ${err.message}`));
 			});
 			child.stdin?.write(stdinPayload);
@@ -230,6 +255,6 @@ function runClaudeSession(req, onDelta) {
 	});
 }
 //#endregion
-export { applyOneMillionSuffix, buildClaudeArgs, decorateAndSerialize, ensureConfigDir, makeAnthropicWorkerId, oneMillionEnv, runClaudeSession, withSessionLock };
+export { SYSTEM_PROMPT_ARGV_MAX_BYTES, 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 * 멀티턴: 매 호출 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\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        },\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":"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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, unlinkSync, 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\n// Linux 단일 argv 인자 한계(MAX_ARG_STRLEN = PAGE_SIZE×32 = 128KB, 커널 하드코딩 상수)\n// 시스템 프롬프트가 이를 넘으면 execve 가 E2BIG 로 거부된다. deti 등 대형 프롬프트는 실측\n// 평균 343KB·최대 485KB(opus-4-8)라 일상적으로 초과한다. 한계의 절반(64KB)을 임계값으로 잡아\n// UTF-8 멀티바이트·예측 못 한 여유분까지 안전 마진을 둔다.\nexport const SYSTEM_PROMPT_ARGV_MAX_BYTES = 64 * 1024;\n\nexport function buildClaudeArgs(opts: {\n  model: string;\n  // 시스템 프롬프트 전달은 크기로 분기한다(호출부가 결정):\n  //  - 작으면 system(inline) → --system-prompt <text> (파일 I/O 없음, 기존 경로)\n  //  - 크면 systemPromptFile(경로) → --system-prompt-file <path> (argv 한계 회피)\n  // --system-prompt-file 은 --system-prompt 와 동일하게 default 를 replace 한다(append 아님 —\n  // R7 격리 보존, 실측 확인). 둘 다 없으면 빈 --system-prompt(default 23k 주입 방지).\n  system?: string;\n  systemPromptFile?: 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  // 시스템 프롬프트: 파일 경로가 오면 --system-prompt-file, 아니면 inline --system-prompt.\n  // (호출부가 크기로 분기해 둘 중 하나만 채운다. 둘 다 없으면 빈 --system-prompt.)\n  const systemArgs = opts.systemPromptFile\n    ? [\"--system-prompt-file\", opts.systemPromptFile]\n    : [\"--system-prompt\", opts.system ?? \"\"];\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(작음) / --system-prompt-file(큼)로 분기(systemArgs).\n    ...systemArgs,\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    // 시스템 프롬프트를 크기로 분기: 128KB(argv 한계)의 절반을 넘으면 파일로 넘겨 E2BIG 회피.\n    // 작은 프롬프트는 파일 I/O 없이 기존 inline 경로를 그대로 쓴다(대부분의 호출).\n    // 실제 파일 쓰기는 abort 체크 이후(Promise 안)로 미뤄, 이미 취소된 요청엔 쓰지 않는다.\n    const system = req.system ?? \"\";\n    const useSystemPromptFile = Buffer.byteLength(system, \"utf8\") > SYSTEM_PROMPT_ARGV_MAX_BYTES;\n    const systemPromptFile = useSystemPromptFile\n      ? `${configDir}/system-prompt-${sessionId}.txt`\n      : undefined;\n\n    const args = buildClaudeArgs({\n      model,\n      system: useSystemPromptFile ? undefined : req.system,\n      systemPromptFile,\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      // 대형 시스템 프롬프트는 spawn 직전에 파일로 기록(argv E2BIG 회피). 종료 시 정리한다.\n      if (systemPromptFile) writeFileSync(systemPromptFile, system);\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      // spawn 시 쓴 임시 시스템 프롬프트 파일 정리(한 번만). 모든 종료 경로에서 호출한다.\n      // 누락돼도 다음 ensureConfigDir 가 디렉토리를 재사용할 뿐이지만, sessionId 별 파일이라\n      // 쌓이면 디스크가 차므로 settle 시 즉시 지운다.\n      const cleanupSpawnFiles = () => {\n        if (!systemPromptFile) return;\n        try {\n          unlinkSync(systemPromptFile);\n        } catch {\n          // 이미 없거나 권한 문제면 무시 — 정리는 best-effort.\n        }\n      };\n      let cleanupAbort: (() => void) | undefined;\n      const timer = setTimeout(() => {\n        if (settled) return;\n        settled = true;\n        cleanupAbort?.();\n        cleanupSpawnFiles();\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        cleanupSpawnFiles();\n        resolve({ ...result, sessionId, workerId });\n      };\n\n      const onAbort = () => {\n        if (settled) return;\n        settled = true;\n        clearTimeout(timer);\n        cleanupAbort?.();\n        cleanupSpawnFiles();\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        cleanupSpawnFiles();\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        cleanupSpawnFiles();\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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"}

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

@@ -126,6 +126,7 @@ 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 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,
@@ -133,7 +134,9 @@ function handleStreamJsonLine(line, onDelta, opts) {
 			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;
@@ -141,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 * 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}\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 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    };\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/src/application/qgrid/qgrid.dispatcher.test.ts

@@ -229,7 +229,9 @@ describe("QgridDispatcherClass", () => {
     expect(contentsArray?.items?.additionalProperties).toBe(false);
   });
 
-  it("Anthropic provider 경로에 strictified outputSchema 를 전달한다", async () => {
+  // SON-495: anthropic route 도 strict(required 유지)를 쓴다 — required 를 살려야 모델이 필드를
+  // 빠짐없이 채운다(실측 확정). optionalize 는 제거됨.
+  it("Anthropic route 에 strict(required 유지) outputSchema 를 전달한다", async () => {
     const dispatcher = new QgridDispatcherClass();
     const generate = vi.fn(
       async (_req: GenerateRequest): Promise<GenerateResult> => ({
@@ -259,6 +261,45 @@ describe("QgridDispatcherClass", () => {
       }),
     });
 
+    const outputSchema = generate.mock.calls[0]![0].outputSchema as {
+      required?: string[];
+      additionalProperties?: boolean;
+    };
+    // anthropic 도 OpenAI 와 동일하게 strictify — required 살아있음
+    expect(outputSchema.required).toEqual(["contents"]);
+    expect(outputSchema.additionalProperties).toBe(false);
+  });
+
+  it("OpenAI route 도 strictify(required 유지)한다", async () => {
+    const dispatcher = new QgridDispatcherClass();
+    const generate = vi.fn(
+      async (_req: GenerateRequest): Promise<GenerateResult> => ({
+        text: '{"contents":[{"text":"ok"}]}',
+        tokenName: "openai/test",
+        usage: {
+          totalTokens: 10,
+          inputTokens: 5,
+          cachedInputTokens: 0,
+          outputTokens: 5,
+          reasoningOutputTokens: 0,
+        },
+        durationMs: 12,
+        costUsd: 0.01,
+        model: "gpt-5.5",
+        threadCoord: { workerId: 1, threadId: "sess-1", epoch: 0 },
+      }),
+    );
+    dispatcher.openaiDispatcher = { generate } as never;
+
+    await dispatcher.query({
+      prompt: "hi",
+      model: "openai/gpt-5.5",
+      jsonSchema: JSON.stringify({
+        type: "object",
+        properties: { contents: { type: "array", items: { type: "object" } } },
+      }),
+    });
+
     const outputSchema = generate.mock.calls[0]![0].outputSchema as {
       required?: string[];
       additionalProperties?: boolean;

package/bundle/src/application/qgrid/qgrid.dispatcher.ts

@@ -67,8 +67,8 @@ export class QgridDispatcherClass {
       throw new ProcessError("tools and jsonSchema cannot be used together");
     }
 
-    const outputSchema = buildStrictOutputSchema(input);
     const route = parseProviderRoute(input.model);
+    const outputSchema = buildStrictOutputSchema(input);
 
     // provider prefix routing: 'openai/gpt-5.4' → OpenAIDispatcher
     if (route.provider === "openai") {
@@ -123,8 +123,8 @@ export class QgridDispatcherClass {
     cb: StreamCallbacks<QueryOutput>,
     abortSignal?: AbortSignal,
   ): Promise<void> {
-    const outputSchema = buildStrictOutputSchema(input);
     const route = parseProviderRoute(input.model);
+    const outputSchema = buildStrictOutputSchema(input);
 
     if (route.provider === "openai") {
       if (!this.openaiDispatcher) throw new QuotaError("OpenAI dispatcher not initialized");
@@ -212,20 +212,32 @@ function directLlmApiFallbackNotImplemented(input: QueryInput): ProcessError {
   );
 }
 
+// 모든 provider(OpenAI/Anthropic)가 동일하게 strict output schema 를 쓴다.
+//
+// SON-495 교훈: 한때 Anthropic route 만 required 를 제거(optionalize)해 partial/rejected attempt 가
+// 섞여도 통과하게 했으나, 실측 결과 그게 오히려 "모델이 비는 필드를 키째 생략"하도록 유도했다
+// (required 살린 schema 는 누락 0, loose 는 누락 다발). strict 로 두면 모델이 빠짐없이 채우고,
+// 드물게 어겨도 retry=1 + 비정상 종료는 정직한 에러(stream-json-adapter)로 받아준다.
 export function buildStrictOutputSchema(
   input: Pick<QueryInput, "tools" | "jsonSchema">,
 ): JsonValue | undefined {
-  const outputSchema = input.tools?.length
-    ? buildToolCallSchema(input.tools)
-    : input.jsonSchema
-      ? (JSON.parse(input.jsonSchema) as JsonValue)
-      : undefined;
+  const outputSchema = buildRawOutputSchema(input);
 
   return outputSchema
     ? (strictify(outputSchema as Parameters<typeof strictify>[0]) as JsonValue)
     : undefined;
 }
 
+function buildRawOutputSchema(
+  input: Pick<QueryInput, "tools" | "jsonSchema">,
+): JsonValue | undefined {
+  return input.tools?.length
+    ? buildToolCallSchema(input.tools)
+    : input.jsonSchema
+      ? (JSON.parse(input.jsonSchema) as JsonValue)
+      : undefined;
+}
+
 // GenerateResult(provider dispatcher 응답)를 applyToolCallEmulation 입력 shape 로 매핑한다.
 // OpenAI/Anthropic, query/queryStream 4 경로가 동일하게 쓴다.
 // Anthropic adapter 는 cache creation 을 inputTokens 에 포함해 표준화하고, 별도 필드에도 보존한다.

package/bundle/src/utils/providers/anthropic/anthropic-dispatcher.ts

@@ -204,9 +204,17 @@ export class AnthropicDispatcher implements ProviderDispatcher {
 
       if (session.quotaExhausted) throw new Error(`quota exhausted (${token.name})`);
       if (session.isError) {
-        // text 가 비어 있을 수 있으므로 진단 가능한 형태로 메시지를 만든다(subtype 등은 raw 로그 참조).
-        const detail = session.text || `empty text, outputTokens=${session.usage.outputTokens}`;
-        throw new Error(`claude error (${token.name}): ${detail}`);
+        // 진단(SON-495): isError 판정 사유(subtype/terminal_reason)를 메시지 앞에 드러낸다.
+        // 그동안 detail 이 session.text(완전한 JSON 본문)뿐이라 "schema 위반인지 / max retries 인지 /
+        // max turns 인지"를 구분할 수 없었다. text 는 진단에 필요한 만큼만 잘라 덧붙인다.
+        const reason =
+          session.subtype ?? session.terminalReason ?? (session.isError ? "is_error" : "unknown");
+        const body = session.text
+          ? session.text.length > 500
+            ? `${session.text.slice(0, 500)}…(${session.text.length} chars)`
+            : session.text
+          : `empty text, outputTokens=${session.usage.outputTokens}`;
+        throw new Error(`claude error (${token.name}) [${reason}]: ${body}`);
       }
 
       return {

package/bundle/src/utils/providers/anthropic/claude-session.test.ts

@@ -11,6 +11,8 @@ import {
   makeAnthropicWorkerId,
   oneMillionEnv,
   runClaudeSession,
+  structuredOutputRetriesEnv,
+  SYSTEM_PROMPT_ARGV_MAX_BYTES,
   withSessionLock,
 } from "./claude-session";
 import { buildStreamJsonInput } from "./stream-json-adapter";
@@ -130,6 +132,23 @@ describe("buildClaudeArgs (멀티턴/격리/structured)", () => {
     expect(oneMillionEnv(false)).toEqual({ CLAUDE_CODE_DISABLE_1M_CONTEXT: "1" });
   });
 
+  // SON-495: structured output retry 를 1 로 고정한다.
+  it("structuredOutputRetriesEnv: 미설정/비정상 값은 1 로 기본 고정", () => {
+    expect(structuredOutputRetriesEnv(undefined)).toEqual({ MAX_STRUCTURED_OUTPUT_RETRIES: "1" });
+    expect(structuredOutputRetriesEnv("")).toEqual({ MAX_STRUCTURED_OUTPUT_RETRIES: "1" });
+    expect(structuredOutputRetriesEnv("abc")).toEqual({ MAX_STRUCTURED_OUTPUT_RETRIES: "1" });
+  });
+
+  it("structuredOutputRetriesEnv: 1 미만(0, 음수)은 1 로 클램프", () => {
+    expect(structuredOutputRetriesEnv("0")).toEqual({ MAX_STRUCTURED_OUTPUT_RETRIES: "1" });
+    expect(structuredOutputRetriesEnv("-3")).toEqual({ MAX_STRUCTURED_OUTPUT_RETRIES: "1" });
+  });
+
+  it("structuredOutputRetriesEnv: 1 이상 값은 그대로 유지", () => {
+    expect(structuredOutputRetriesEnv("1")).toEqual({ MAX_STRUCTURED_OUTPUT_RETRIES: "1" });
+    expect(structuredOutputRetriesEnv("5")).toEqual({ MAX_STRUCTURED_OUTPUT_RETRIES: "5" });
+  });
+
   it("cold-only: 항상 --session-id 를 사용하고 continuation flag 는 쓰지 않는다", () => {
     const args = buildClaudeArgs({ model: "m", sessionId: "uuid-1" });
     const continuationFlag = "--resume";
@@ -220,6 +239,45 @@ describe("buildClaudeArgs (멀티턴/격리/structured)", () => {
     expect(args).toContain("--system-prompt");
     expect(args[args.indexOf("--system-prompt") + 1]).toBe("you are X");
   });
+
+  // E2BIG 회피: 대형 시스템 프롬프트는 파일 경로로 넘겨 Linux argv 한계(128KB)를 피한다.
+  it("systemPromptFile 이 오면 --system-prompt-file 을 쓰고 inline --system-prompt 는 안 쓴다", () => {
+    const args = buildClaudeArgs({
+      model: "m",
+      systemPromptFile: "/cfg/7/system-prompt-u.txt",
+      sessionId: "u",
+    });
+    expect(args).toContain("--system-prompt-file");
+    expect(args[args.indexOf("--system-prompt-file") + 1]).toBe("/cfg/7/system-prompt-u.txt");
+    expect(args).not.toContain("--system-prompt");
+  });
+
+  it("systemPromptFile 이 inline system 보다 우선한다 (둘 다 와도 file 경로만)", () => {
+    const args = buildClaudeArgs({
+      model: "m",
+      system: "ignored inline",
+      systemPromptFile: "/cfg/7/sp.txt",
+      sessionId: "u",
+    });
+    expect(args).toContain("--system-prompt-file");
+    expect(args).not.toContain("--system-prompt");
+    expect(args).not.toContain("ignored inline");
+  });
+
+  it("임계값(64KB)을 넘는 시스템 프롬프트가 argv 에 통째로 들어가지 않는다 (E2BIG 회귀 방지)", () => {
+    const huge = "x".repeat(SYSTEM_PROMPT_ARGV_MAX_BYTES + 1);
+    // 실제 호출부(runClaudeSession)는 huge 를 파일로 빼고 systemPromptFile 만 넘긴다.
+    const args = buildClaudeArgs({
+      model: "m",
+      systemPromptFile: "/cfg/7/sp.txt",
+      sessionId: "u",
+    });
+    // 어떤 단일 인자도 임계값을 넘지 않아야 한다(=거대 프롬프트가 argv 에 없음).
+    for (const a of args) {
+      expect(Buffer.byteLength(a, "utf8")).toBeLessThanOrEqual(SYSTEM_PROMPT_ARGV_MAX_BYTES);
+    }
+    expect(args).not.toContain(huge);
+  });
 });
 
 describe("decorateAndSerialize (envelope, U2 P1-#3 위임분)", () => {

package/bundle/src/utils/providers/anthropic/claude-session.ts

@@ -16,7 +16,7 @@
 
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { mkdirSync, writeFileSync } from "node:fs";
+import { mkdirSync, unlinkSync, writeFileSync } from "node:fs";
 
 import { type JsonValue } from "../../../codex-protocol/serde_json/JsonValue";
 import { type TokenUsageBreakdown } from "../../../codex-protocol/v2/TokenUsageBreakdown";
@@ -143,9 +143,34 @@ export function oneMillionEnv(supported: boolean): { CLAUDE_CODE_DISABLE_1M_CONT
   return supported ? {} : { CLAUDE_CODE_DISABLE_1M_CONTEXT: "1" };
 }
 
+// SON-495: structured output retry 를 1 로 고정한다. CC 가 attempt 를 reject 하고 retry 하면
+// `{rejected}{accepted}` 누적이 AI-SDK 의 JSON.parse 를 깨뜨리므로, retry 자체를 막아 그 경로를
+// 원천 차단한다. `0` 은 CC query loop(`callsThisQuery >= maxRetries`)가 첫 attempt emit 전에
+// 실패시키므로(`error_max_structured_output_retries`) 외부 값이 1 미만이어도 1 로 클램프한다.
+export function structuredOutputRetriesEnv(raw = process.env.MAX_STRUCTURED_OUTPUT_RETRIES): {
+  MAX_STRUCTURED_OUTPUT_RETRIES: string;
+} {
+  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)) };
+}
+
+// Linux 단일 argv 인자 한계(MAX_ARG_STRLEN = PAGE_SIZE×32 = 128KB, 커널 하드코딩 상수)
+// 시스템 프롬프트가 이를 넘으면 execve 가 E2BIG 로 거부된다. deti 등 대형 프롬프트는 실측
+// 평균 343KB·최대 485KB(opus-4-8)라 일상적으로 초과한다. 한계의 절반(64KB)을 임계값으로 잡아
+// UTF-8 멀티바이트·예측 못 한 여유분까지 안전 마진을 둔다.
+export const SYSTEM_PROMPT_ARGV_MAX_BYTES = 64 * 1024;
+
 export function buildClaudeArgs(opts: {
   model: string;
+  // 시스템 프롬프트 전달은 크기로 분기한다(호출부가 결정):
+  //  - 작으면 system(inline) → --system-prompt <text> (파일 I/O 없음, 기존 경로)
+  //  - 크면 systemPromptFile(경로) → --system-prompt-file <path> (argv 한계 회피)
+  // --system-prompt-file 은 --system-prompt 와 동일하게 default 를 replace 한다(append 아님 —
+  // R7 격리 보존, 실측 확인). 둘 다 없으면 빈 --system-prompt(default 23k 주입 방지).
   system?: string;
+  systemPromptFile?: string;
   effort?: string;
   jsonSchema?: string;
   sessionId: string;
@@ -158,6 +183,12 @@ export function buildClaudeArgs(opts: {
     ? ["--tools", "", "--allowed-tools", "StructuredOutput"]
     : ["--tools", ""];
 
+  // 시스템 프롬프트: 파일 경로가 오면 --system-prompt-file, 아니면 inline --system-prompt.
+  // (호출부가 크기로 분기해 둘 중 하나만 채운다. 둘 다 없으면 빈 --system-prompt.)
+  const systemArgs = opts.systemPromptFile
+    ? ["--system-prompt-file", opts.systemPromptFile]
+    : ["--system-prompt", opts.system ?? ""];
+
   const args: Array<string> = [
     "-p",
     ...toolArgs,
@@ -176,8 +207,8 @@ export function buildClaudeArgs(opts: {
     "--model",
     applyOneMillionSuffix(opts.model, opts.needsOneMillionSuffix ?? false),
     // inline [System] 금지 — 정식 채널만(R7). 생략 시 CC default(23k) 주입되므로 반드시 명시.
-    "--system-prompt",
-    opts.system ?? "",
+    // 크기에 따라 --system-prompt(작음) / --system-prompt-file(큼)로 분기(systemArgs).
+    ...systemArgs,
     "--thinking",
     "disabled",
     "--effort",
@@ -212,9 +243,19 @@ export function runClaudeSession(
     ensureCwd();
     const configDir = ensureConfigDir(req.tokenId);
 
+    // 시스템 프롬프트를 크기로 분기: 128KB(argv 한계)의 절반을 넘으면 파일로 넘겨 E2BIG 회피.
+    // 작은 프롬프트는 파일 I/O 없이 기존 inline 경로를 그대로 쓴다(대부분의 호출).
+    // 실제 파일 쓰기는 abort 체크 이후(Promise 안)로 미뤄, 이미 취소된 요청엔 쓰지 않는다.
+    const system = req.system ?? "";
+    const useSystemPromptFile = Buffer.byteLength(system, "utf8") > SYSTEM_PROMPT_ARGV_MAX_BYTES;
+    const systemPromptFile = useSystemPromptFile
+      ? `${configDir}/system-prompt-${sessionId}.txt`
+      : undefined;
+
     const args = buildClaudeArgs({
       model,
-      system: req.system,
+      system: useSystemPromptFile ? undefined : req.system,
+      systemPromptFile,
       effort: req.effort,
       jsonSchema: req.jsonSchema,
       sessionId,
@@ -234,6 +275,9 @@ export function runClaudeSession(
         return;
       }
 
+      // 대형 시스템 프롬프트는 spawn 직전에 파일로 기록(argv E2BIG 회피). 종료 시 정리한다.
+      if (systemPromptFile) writeFileSync(systemPromptFile, system);
+
       const child = spawn("claude", args, {
         // stderr 도 캡처: invalid OAuth / 잘못된 플래그 / CLI 검증 실패가
         // "closed without result" 로 뭉개지지 않게 close/error 에 stderr 를 실어 보낸다.
@@ -253,6 +297,8 @@ export function runClaudeSession(
           CLAUDE_CODE_DISABLE_WORKFLOWS: "1",
           CLAUDE_CODE_ATTRIBUTION_HEADER: "0",
           MAX_THINKING_TOKENS: "0",
+          // structured output 일 때만 retry 를 고정한다(SON-495). text 모드는 영향 없음.
+          ...(useStructured ? structuredOutputRetriesEnv() : {}),
         },
       });
 
@@ -266,11 +312,23 @@ export function runClaudeSession(
         stderrBuf = (stderrBuf + d.toString()).slice(-STDERR_CAP);
       });
       const stderrSuffix = () => (stderrBuf.trim() ? ` — stderr: ${stderrBuf.trim()}` : "");
+      // spawn 시 쓴 임시 시스템 프롬프트 파일 정리(한 번만). 모든 종료 경로에서 호출한다.
+      // 누락돼도 다음 ensureConfigDir 가 디렉토리를 재사용할 뿐이지만, sessionId 별 파일이라
+      // 쌓이면 디스크가 차므로 settle 시 즉시 지운다.
+      const cleanupSpawnFiles = () => {
+        if (!systemPromptFile) return;
+        try {
+          unlinkSync(systemPromptFile);
+        } catch {
+          // 이미 없거나 권한 문제면 무시 — 정리는 best-effort.
+        }
+      };
       let cleanupAbort: (() => void) | undefined;
       const timer = setTimeout(() => {
         if (settled) return;
         settled = true;
         cleanupAbort?.();
+        cleanupSpawnFiles();
         child.kill();
         reject(new Error(`Claude session timeout after ${req.timeoutMs / 1000}s`));
       }, req.timeoutMs);
@@ -280,6 +338,7 @@ export function runClaudeSession(
         settled = true;
         clearTimeout(timer);
         cleanupAbort?.();
+        cleanupSpawnFiles();
         resolve({ ...result, sessionId, workerId });
       };
 
@@ -288,6 +347,7 @@ export function runClaudeSession(
         settled = true;
         clearTimeout(timer);
         cleanupAbort?.();
+        cleanupSpawnFiles();
         child.kill();
         reject(new Error("aborted"));
       };
@@ -316,6 +376,7 @@ export function runClaudeSession(
         settled = true;
         clearTimeout(timer);
         cleanupAbort?.();
+        cleanupSpawnFiles();
         reject(new Error(`Claude session closed without result${stderrSuffix()}`));
       });
       child.on("error", (err) => {
@@ -323,6 +384,7 @@ export function runClaudeSession(
         settled = true;
         clearTimeout(timer);
         cleanupAbort?.();
+        cleanupSpawnFiles();
         reject(new Error(`Claude session spawn error: ${err.message}`));
       });
 

package/bundle/src/utils/providers/anthropic/stream-json-adapter.test.ts

@@ -265,6 +265,61 @@ describe("handleStreamJsonLine (출력 어댑터)", () => {
     expect(result!.costUsd).toBe(0.0042);
   });
 
+  // SON-495: error_max_structured_output_retries 는 모델이 schema 를 못 맞춘 비정상 종료다.
+  // CC structured output 은 constrained decoding 이 아니라 사후 AJV 검증이라, 모델이 가끔
+  // placeholder($PARAMETER_NAME)·거부("just kidding")·필드 누락 같은 발작/불완전 출력을 낸다.
+  // 이를 "거의 맞았으니 살리자"고 흘리면 클라이언트 검증이 깨지거나 쓰레기가 샌다(실측 11674/11675).
+  // 그래서 보존 출력 유무·내용과 무관하게 항상 에러로 처리한다(알려진 best practice: refusal/degenerate
+  // output 은 graceful error). 보존 출력은 진단용 text 로는 남기되 isError 는 true.
+  it("error_max_structured_output_retries: 보존 출력이 valid JSON 이어도 에러로 처리", () => {
+    const attempt = {
+      scenes: [{ visual: { backgroundId: "IL-LOC-02" }, contents: [], advance: "choice" }],
+    };
+    const { result } = runLines(
+      [
+        JSON.stringify({
+          type: "assistant",
+          message: { content: [{ type: "tool_use", name: "StructuredOutput", input: attempt }] },
+        }),
+        JSON.stringify({
+          type: "result",
+          subtype: "error_max_structured_output_retries",
+          is_error: true,
+          usage: { input_tokens: 10, output_tokens: 20 },
+          duration_ms: 100,
+          total_cost_usd: 0.001,
+        }),
+      ],
+      { structuredOutput: true },
+    );
+
+    expect(result!.isError).toBe(true);
+    expect(result!.subtype).toBe("error_max_structured_output_retries");
+  });
+
+  it("error_max_structured_output_retries: placeholder 쓰레기 출력도 에러로 처리", () => {
+    const garbage = { $PARAMETER_NAME: "" };
+    const { result } = runLines(
+      [
+        JSON.stringify({
+          type: "assistant",
+          message: { content: [{ type: "tool_use", name: "StructuredOutput", input: garbage }] },
+        }),
+        JSON.stringify({
+          type: "result",
+          subtype: "error_max_structured_output_retries",
+          is_error: true,
+          usage: { input_tokens: 10, output_tokens: 0 },
+          duration_ms: 100,
+          total_cost_usd: 0.001,
+        }),
+      ],
+      { structuredOutput: true },
+    );
+
+    expect(result!.isError).toBe(true);
+  });
+
   it("text 모드: partial_json 이 와도 무시, text_delta 만", () => {
     const { deltas } = runLines(
       [

package/bundle/src/utils/providers/anthropic/stream-json-adapter.ts

@@ -133,6 +133,10 @@ export interface ClaudeStreamResult {
   quotaExhausted: boolean;
   // result.is_error / terminal model_error 등. dispatcher 가 에러로 변환.
   isError: boolean;
+  // 진단용: CC result 라인의 subtype("success" | "error_max_turns" | ...) 과 terminal_reason.
+  // isError 판정 사유를 에러 메시지에 드러내기 위해 보존한다(SON-495).
+  subtype?: string;
+  terminalReason?: string;
 }
 
 export interface ClaudeStreamJsonState {
@@ -248,6 +252,15 @@ export function handleStreamJsonLine(
     const usage = toUsageBreakdown((asObject(j.usage) ?? {}) as ClaudeUsage);
     const quotaExhausted = text.startsWith("You've hit");
     const subtype = typeof j.subtype === "string" ? j.subtype : undefined;
+    const terminalReason = typeof j.terminal_reason === "string" ? j.terminal_reason : undefined;
+
+    // SON-495: 비정상 종료(error_max_structured_output_retries 등)는 정직하게 에러로 처리한다.
+    // CC structured output 은 constrained decoding 이 아니라 "tool input 생성 후 사후 AJV 검증"이라
+    // 모델이 가끔 placeholder($PARAMETER_NAME)·거부("just kidding")·필드 누락(advance) 같은 발작/
+    // 불완전 출력을 낸다. 이를 "거의 맞았으니 살리자"고 흘리면 클라이언트 검증에서 깨지거나(필드 누락)
+    // 쓰레기가 새어 나간다(실측 11674/11675). 알려진 best practice(refusal/degenerate output 은 살리지
+    // 말고 graceful error)대로, subtype != success 는 그대로 에러로 둔다. 클라이언트가 그 턴을 실패로
+    // 다루게 한다(스트림이라 자동 재시도 없음 — 시간 2배 방지).
     const isError =
       j.is_error === true ||
       j.terminal_reason === "model_error" ||
@@ -260,6 +273,8 @@ export function handleStreamJsonLine(
       costUsd: typeof j.total_cost_usd === "number" ? j.total_cost_usd : 0,
       quotaExhausted,
       isError,
+      subtype,
+      terminalReason,
     };
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cartanova/qgrid-cli",
-  "version": "2.3.3",
+  "version": "2.3.5",
   "repository": {
     "type": "git",
     "url": "https://github.com/cartanova-ai/qgrid"