@cartanova/qgrid-cli 2.10.9 → 2.11.0

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

@@ -1,11 +1,23 @@
+import { GROK_USD_PER_TICK } from "../grok/grok-constants.js";
 //#region src/utils/providers/common/model-cost.ts
+/**
+* 모델별 토큰 가격 테이블 + cost 계산.
+*
+* claude code 와 동일 패턴: 클라이언트에서 가격 테이블로 직접 계산.
+* 가격 단위: USD per 1M tokens.
+*
+* OpenAI 모델 목록은 OpenAI 모델 문서와 현재 지원 목록을 기준으로 관리한다.
+*
+* @see https://platform.openai.com/docs/pricing
+* @see https://platform.claude.com/docs/en/about-claude/pricing
+*/
 const LONG_CONTEXT_272K = {
 	threshold: 272e3,
 	inputMultiplier: 2,
 	cachedInputMultiplier: 2,
 	outputMultiplier: 1.5
 };
-const OPENAI_COSTS = {
+const OPENAI_COSTS = new Map(Object.entries({
 	"gpt-6-astra": {
 		maxEffort: "ultra",
 		inputTokens: 10,
@@ -89,19 +101,20 @@ const OPENAI_COSTS = {
 		outputTokens: 14,
 		cachedInputTokens: .175
 	}
-};
+}));
 function anthropicCosts(inputTokens, outputTokens, overrides = {}) {
-	return {
+	const costs = {
 		inputTokens,
 		outputTokens,
 		cachedInputTokens: overrides.cachedInputTokens ?? inputTokens / 10,
 		cacheCreationInputTokens: inputTokens * 2,
 		cacheCreationInputTokens5m: inputTokens * 1.25,
-		cacheCreationInputTokens1h: inputTokens * 2,
-		...overrides.longContext ? { longContext: overrides.longContext } : {}
+		cacheCreationInputTokens1h: inputTokens * 2
 	};
+	if (overrides.longContext) costs.longContext = overrides.longContext;
+	return costs;
 }
-const ANTHROPIC_COSTS = {
+const ANTHROPIC_COSTS = new Map(Object.entries({
 	"claude-fable-5-1": anthropicCosts(10, 50, { cachedInputTokens: .25 }),
 	"claude-fable-5": anthropicCosts(10, 50),
 	sonnet: anthropicCosts(3, 15),
@@ -129,21 +142,63 @@ const ANTHROPIC_COSTS = {
 		cachedInputMultiplier: 5,
 		outputMultiplier: 5
 	} })
-};
+}));
 const DEFAULT_COSTS = {
 	inputTokens: 3,
 	outputTokens: 15,
 	cachedInputTokens: .3
 };
+const GROK_TICKS_PER_USD = Math.round(1 / GROK_USD_PER_TICK);
+/** USD for a provider-reported `cost_in_usd_ticks` amount. */
+function usdFromGrokTicks(ticks) {
+	return ticks / GROK_TICKS_PER_USD;
+}
+function grokTokenCosts(input, cached, output) {
+	const perMillion = (ticks) => ticks * 1e6 / GROK_TICKS_PER_USD;
+	return {
+		inputTokens: perMillion(input),
+		cachedInputTokens: perMillion(cached),
+		outputTokens: perMillion(output)
+	};
+}
+const GROK_COSTS = new Map(Object.entries({
+	"grok-4.7": grokTokenCosts(2e4, 5e3, 6e4),
+	"grok-4.6": grokTokenCosts(2e4, 5e3, 6e4),
+	"grok-4.5": grokTokenCosts(2e4, 5e3, 6e4)
+}));
+const GROK_IMAGE_PRICE_TICKS = new Map(Object.entries({ "grok-imagine-image-quality": 5e8 }));
+/**
+* Image cost: the reported ticks when present, otherwise the per-image catalog price times the
+* image count. Undefined when neither is known, so callers store an unknown cost, not a guess.
+*/
+function grokImageCost(model, imageCount, reportedTicks) {
+	if (reportedTicks !== void 0) return grokReportedCost(reportedTicks);
+	const perImage = GROK_IMAGE_PRICE_TICKS.get(model.split("/").pop() ?? model);
+	if (perImage === void 0) return void 0;
+	const ticks = perImage * imageCount;
+	return {
+		costUsd: usdFromGrokTicks(ticks),
+		costSource: "pricing_table",
+		ticks
+	};
+}
+/** Video/voice cost: only a provider-reported amount; there is no catalog estimate. */
+function grokReportedCost(reportedTicks) {
+	return reportedTicks === void 0 ? void 0 : {
+		costUsd: usdFromGrokTicks(reportedTicks),
+		costSource: "provider",
+		ticks: reportedTicks
+	};
+}
 /** Codex 백엔드가 이 모델에 허용하는 최대 effort. 카탈로그에 없는 모델은 xhigh 까지다. */
 function openaiModelMaxEffort(model) {
-	return OPENAI_COSTS[model]?.maxEffort ?? "xhigh";
+	return OPENAI_COSTS.get(model)?.maxEffort ?? "xhigh";
 }
 function getModelCosts(model) {
 	const normalizedModel = (model.split("/").pop() ?? model).replace(/\[1m\]$/i, "");
-	return OPENAI_COSTS[normalizedModel] ?? ANTHROPIC_COSTS[normalizedModel] ?? DEFAULT_COSTS;
+	return OPENAI_COSTS.get(normalizedModel) ?? ANTHROPIC_COSTS.get(normalizedModel) ?? GROK_COSTS.get(normalizedModel) ?? DEFAULT_COSTS;
 }
-const OPENAI_FAST_MULTIPLIERS = {
+const OPENAI_FAST_MULTIPLIERS = new Map(Object.entries({
 	"gpt-6-astra": 2,
 	"gpt-6.1-sol": 2,
 	"gpt-6-sol": 2,
@@ -151,7 +206,7 @@ const OPENAI_FAST_MULTIPLIERS = {
 	"gpt-5.6-sol": 2,
 	"gpt-5.6-terra": 2,
 	"gpt-5.6-luna": 2
-};
+}));
 function calculateCostUsd(model, usage, serviceTier) {
 	const costs = getModelCosts(model);
 	const cachedInput = usage.cachedInputTokens ?? 0;
@@ -172,9 +227,9 @@ function calculateCostUsd(model, usage, serviceTier) {
 	const outputRate = costs.outputTokens * (isLongContext ? lc.outputMultiplier : 1);
 	const standardCost = nonCachedInput / 1e6 * inputRate + usage.outputTokens / 1e6 * outputRate + cachedInput / 1e6 * cachedRate + unclassifiedCacheCreationInput / 1e6 * cacheCreationFallbackRate + classifiedCacheCreationInput5m / 1e6 * cacheCreation5mRate + classifiedCacheCreationInput1h / 1e6 * cacheCreation1hRate;
 	const normalizedModel = model.split("/").pop() ?? model;
-	return standardCost * (serviceTier === "fast" ? OPENAI_FAST_MULTIPLIERS[normalizedModel] ?? 1 : 1);
+	return standardCost * (serviceTier === "fast" ? OPENAI_FAST_MULTIPLIERS.get(normalizedModel) ?? 1 : 1);
 }
 //#endregion
-export { calculateCostUsd, getModelCosts, openaiModelMaxEffort };
+export { calculateCostUsd, getModelCosts, grokImageCost, grokReportedCost, openaiModelMaxEffort, usdFromGrokTicks };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"model-cost.js","names":[],"sources":["../../../../src/utils/providers/common/model-cost.ts"],"sourcesContent":["/**\n * 모델별 토큰 가격 테이블 + cost 계산.\n *\n * claude code 와 동일 패턴: 클라이언트에서 가격 테이블로 직접 계산.\n * 가격 단위: USD per 1M tokens.\n *\n * OpenAI 모델 목록은 OpenAI 모델 문서와 현재 지원 목록을 기준으로 관리한다.\n *\n * @see https://platform.openai.com/docs/pricing\n * @see https://platform.claude.com/docs/en/about-claude/pricing\n */\n\nimport { type OpenAIEffort } from \"./effort\";\n\nexport interface ModelCosts {\n  inputTokens: number;\n  outputTokens: number;\n  cachedInputTokens: number;\n  /** TTL breakdown 이 없는 usage 에 적용할 cache write fallback 단가. */\n  cacheCreationInputTokens?: number;\n  cacheCreationInputTokens5m?: number;\n  cacheCreationInputTokens1h?: number;\n  /**\n   * long-context 할증. 전체 입력 토큰(input_tokens, cache_read 포함)이 threshold 초과 시\n   * 초과분만이 아니라 요청 전체(full session)에 배율 적용.\n   */\n  longContext?: {\n    threshold: number;\n    inputMultiplier: number;\n    cachedInputMultiplier: number;\n    outputMultiplier: number;\n  };\n}\n\n// ── OpenAI ─────────────────────────────────────────────────────────\n//\n// Standard pricing verified 2026-09-23 (기존 모델 단가 변동 없음): https://developers.openai.com/api/docs/pricing\n// 신모델 출시마다 단가가 바뀌므로(5.2→5.4→5.5) 모델 추가 시 반드시 공식 페이지 재확인해야함\n\n// GPT-5.4에서 처음 도입된 long-context 할증 (5.2/5.3-codex는 해당 없음, 5.4-mini/nano는 공식 표에서 long-context 단가 없음)\n// 272K 초과 시 input 2x / cached 2x / output 1.5x — 초과분만이 아닌 세션 전체에 적용됨\n// @see https://developers.openai.com/api/docs/models/gpt-5.5 (\"prompts with >272K input tokens\")\nconst LONG_CONTEXT_272K: NonNullable<ModelCosts[\"longContext\"]> = {\n  threshold: 272_000,\n  inputMultiplier: 2,\n  cachedInputMultiplier: 2,\n  outputMultiplier: 1.5,\n};\n\n// OpenAI 모델 카탈로그. 단가와 함께 Codex 백엔드가 모델별로 받는 최대 reasoning effort 를 한 곳에 둔다.\n// maxEffort 출처: ~/.codex/models_cache.json 의 supported_reasoning_levels (2026-09-07 확인).\n// 미기재 모델은 xhigh 까지만 받는다.\ntype OpenAIModelSpec = ModelCosts & { maxEffort?: OpenAIEffort };\n\nconst OPENAI_COSTS: Record<string, OpenAIModelSpec> = {\n  // GPT-6 Astra: Standard API-equivalent pricing, verified 2026-09-07.\n  // Codex subscription catalog supports ultra; the public API lists only through max.\n  // @see https://developers.openai.com/api/docs/models/gpt-6-astra\n  // @see https://developers.openai.com/api/docs/pricing\n  \"gpt-6-astra\": {\n    maxEffort: \"ultra\",\n    inputTokens: 10,\n    outputTokens: 50,\n    cachedInputTokens: 1,\n    cacheCreationInputTokens: 12.5,\n    longContext: LONG_CONTEXT_272K,\n  },\n  // GPT-6.1 Sol (2026-09-29 DevDay 출시): Standard API pricing verified 2026-09-30. GPT-6 Sol 과 같고 cached input 만 절반.\n  // Codex 카탈로그(2026-09-30)는 ultra 까지 허용하고 기본 effort 는 low 다(GPT-6 Sol 은 medium).\n  // qgrid 의 요청 형태 + codex_cli_rs/0.147.0 헤더로 2026-09-30 구독 경로 라이브 생성 성공.\n  // @see https://developers.openai.com/api/docs/models/gpt-6.1-sol\n  \"gpt-6.1-sol\": {\n    maxEffort: \"ultra\",\n    inputTokens: 2,\n    outputTokens: 10,\n    cachedInputTokens: 0.1,\n    cacheCreationInputTokens: 2.5,\n    longContext: LONG_CONTEXT_272K,\n  },\n  // GPT-6 Sol, Luna (2026-09-22 출시): Standard API pricing verified 2026-09-23. GPT-5.6 Sol/Luna 의 절반 단가.\n  // Codex 카탈로그(2026-09-23)는 Sol 에 ultra, Luna 에 max 까지 허용하고 기본 effort 는 둘 다 medium 이다.\n  // @see https://developers.openai.com/api/docs/models/gpt-6-sol\n  // @see https://developers.openai.com/api/docs/models/gpt-6-luna\n  \"gpt-6-sol\": {\n    maxEffort: \"ultra\",\n    inputTokens: 2,\n    outputTokens: 10,\n    cachedInputTokens: 0.2,\n    cacheCreationInputTokens: 2.5,\n    longContext: LONG_CONTEXT_272K,\n  },\n  \"gpt-6-luna\": {\n    maxEffort: \"max\",\n    inputTokens: 0.1,\n    outputTokens: 0.5,\n    cachedInputTokens: 0.01,\n    cacheCreationInputTokens: 0.125,\n    longContext: LONG_CONTEXT_272K,\n  },\n  // GPT-5.6 Sol, Terra, Luna. cache write 단가는 외부 logger/manual usage 입력을 위해\n  // 유지한다. 현재 OpenAI 응답 usage 에 cache write 토큰 필드가 없으면 비용은 0으로 계산된다.\n  // @see https://developers.openai.com/api/docs/models/gpt-5.6-sol\n  // @see https://developers.openai.com/api/docs/models/gpt-5.6-terra\n  // @see https://developers.openai.com/api/docs/models/gpt-5.6-luna\n  // Sol promotional rates are available at least through 2026-11-21.\n  // No confirmed end date/replacement rate: recheck official pricing instead of auto-reverting.\n  \"gpt-5.6-sol\": {\n    maxEffort: \"ultra\",\n    inputTokens: 4,\n    outputTokens: 20,\n    cachedInputTokens: 0.4,\n    cacheCreationInputTokens: 5,\n    longContext: LONG_CONTEXT_272K,\n  },\n  \"gpt-5.6-terra\": {\n    maxEffort: \"ultra\",\n    inputTokens: 2,\n    outputTokens: 12,\n    cachedInputTokens: 0.2,\n    cacheCreationInputTokens: 2.5,\n    longContext: LONG_CONTEXT_272K,\n  },\n  \"gpt-5.6-luna\": {\n    maxEffort: \"max\",\n    inputTokens: 0.2,\n    outputTokens: 1.2,\n    cachedInputTokens: 0.02,\n    cacheCreationInputTokens: 0.25,\n    longContext: LONG_CONTEXT_272K,\n  },\n  // https://openai.com/index/introducing-gpt-5-5/ (2026-04 출시)\n  \"gpt-5.5\": {\n    inputTokens: 5,\n    outputTokens: 30,\n    cachedInputTokens: 0.5,\n    longContext: LONG_CONTEXT_272K,\n  },\n  // 아래 gpt-5.4 / gpt-5.4-mini / gpt-5.3-codex / gpt-5.2 는 qgrid 가 쓰는 ChatGPT 구독 Codex 경로에서\n  // 더 이상 제공되지 않는다(5.4 계열은 2026-08-31 retired, 대체 gpt-5.6-terra / gpt-5.6-luna).\n  // 과거 request log 재산정(cost_source 없는 legacy 행)에 필요하므로 단가 행은 유지한다.\n  // https://openai.com/index/introducing-gpt-5-4/ (2026-03 출시)\n  \"gpt-5.4\": {\n    inputTokens: 2.5,\n    outputTokens: 15,\n    cachedInputTokens: 0.25,\n    longContext: LONG_CONTEXT_272K,\n  },\n  \"gpt-5.4-mini\": { inputTokens: 0.75, outputTokens: 4.5, cachedInputTokens: 0.075 },\n  // gpt-5.2와 동일 단가 (cached = input의 10%)\n  \"gpt-5.3-codex\": { inputTokens: 1.75, outputTokens: 14, cachedInputTokens: 0.175 },\n  // https://openai.com/index/introducing-gpt-5-2/ (cached input 90% 할인 명시)\n  \"gpt-5.2\": { inputTokens: 1.75, outputTokens: 14, cachedInputTokens: 0.175 },\n};\n\n// ── Anthropic ───────────────────────────────────────────────────────\n\nfunction anthropicCosts(\n  inputTokens: number,\n  outputTokens: number,\n  overrides: Pick<Partial<ModelCosts>, \"cachedInputTokens\" | \"longContext\"> = {},\n): ModelCosts {\n  return {\n    inputTokens,\n    outputTokens,\n    // 표준 cache read 는 base input 의 0.1x. Fable 5.1 처럼 공식 특례 단가가 있으면 override 한다.\n    cachedInputTokens: overrides.cachedInputTokens ?? inputTokens / 10,\n    // Claude Code subscription OAuth 는 1h TTL 을 자동 선택한다. 구버전처럼 응답에\n    // TTL breakdown 이 없을 때만 이 1h 단가를 fallback 으로 사용한다.\n    cacheCreationInputTokens: inputTokens * 2,\n    cacheCreationInputTokens5m: inputTokens * 1.25,\n    cacheCreationInputTokens1h: inputTokens * 2,\n    // Haiku 5.5 처럼 프롬프트 길이 티어가 있는 모델만 long-context 배율을 가진다.\n    ...(overrides.longContext ? { longContext: overrides.longContext } : {}),\n  };\n}\n\n// 가격 출처: https://platform.claude.com/docs/en/about-claude/pricing (2026-10-08 확인. 2026-10-07 에 Sonnet 5.5\n// cache read 가 $0.20→$0.10(0.05x)으로 인하됐고, 그 외 기존 모델 단가는 변동 없음)\nconst ANTHROPIC_COSTS: Record<string, ModelCosts> = {\n  // Fable 5.1 (2026-09-01 출시): input/output 은 Fable 5 와 같고 cache read 만 0.025x($0.25) 특례.\n  // @see https://platform.claude.com/docs/en/models/fable-5-1/overview\n  \"claude-fable-5-1\": anthropicCosts(10, 50, { cachedInputTokens: 0.25 }),\n  \"claude-fable-5\": anthropicCosts(10, 50),\n  sonnet: anthropicCosts(3, 15),\n  \"claude-3-5-haiku\": anthropicCosts(0.8, 4),\n  \"claude-haiku-4-5\": anthropicCosts(1, 5),\n  \"claude-3-5-sonnet\": anthropicCosts(3, 15),\n  \"claude-3-7-sonnet\": anthropicCosts(3, 15),\n  \"claude-sonnet-4\": anthropicCosts(3, 15),\n  \"claude-sonnet-4-5\": anthropicCosts(3, 15),\n  \"claude-sonnet-4-6\": anthropicCosts(3, 15),\n  \"claude-sonnet-4-7\": anthropicCosts(3, 15),\n  \"claude-opus-4\": anthropicCosts(15, 75),\n  \"claude-opus-4-1\": anthropicCosts(15, 75),\n  \"claude-opus-4-5\": anthropicCosts(5, 25),\n  \"claude-opus-4-6\": anthropicCosts(5, 25),\n  \"claude-opus-4-7\": anthropicCosts(5, 25),\n  \"claude-opus-4-8\": anthropicCosts(5, 25),\n  \"claude-opus-5\": anthropicCosts(5, 25),\n  // Opus 5.5 (2026-09-22 출시): $4/$20. cache read 는 0.05x($0.20) 특례, cache write 는 표준 배율($5/$8).\n  // @see https://platform.claude.com/docs/en/models/opus-5-5/overview\n  \"claude-opus-5-5\": anthropicCosts(4, 20, { cachedInputTokens: 0.2 }),\n  // Sonnet 5 의 introductory $2/$10 이 정식 단가로 확정됐다. 2026-09-01 에 예정됐던 $3/$15 인상은\n  // 취소됐으므로 날짜 분기 없이 고정 단가로 계산한다.\n  \"claude-sonnet-5\": anthropicCosts(2, 10),\n  // Sonnet 5.5 (2026-09-28 출시): Sonnet 5 와 같은 $2/$10. cache read 는 출시 시 표준 0.1x($0.20)였다가\n  // 2026-10-07 Haiku 5.5 출시와 함께 Opus 5.5 와 같은 0.05x($0.10)로 인하됐다(API 릴리스 노트). 비용은 요청 시점\n  // 단가로 기록되므로 날짜 분기 없이 현행 단가만 둔다. cache write 는 표준 배율($2.50/$4).\n  // @see https://platform.claude.com/docs/en/release-notes/overview (2026-10-07)\n  \"claude-sonnet-5-5\": anthropicCosts(2, 10, { cachedInputTokens: 0.1 }),\n  // Haiku 5.5 (2026-10-07 출시): 프롬프트 길이 티어 단가. 100K 이하 $0.10/$0.50, cache read 0.1x($0.01),\n  // cache write 5m $0.125 / 1h $0.20. 입력이 100K 를 넘으면 input/cache read/cache write/output 모두 5x\n  // ($0.50/$0.05/$0.625·$1/$2.50)가 요청 전체에 적용된다. 1M 컨텍스트 모델 중 유일하게 길이별 단가를 쓴다.\n  // @see https://platform.claude.com/docs/en/models/haiku-5-5/overview\n  \"claude-haiku-5-5\": anthropicCosts(0.1, 0.5, {\n    longContext: {\n      threshold: 100_000,\n      inputMultiplier: 5,\n      cachedInputMultiplier: 5,\n      outputMultiplier: 5,\n    },\n  }),\n};\n\n// gpt-5.3-codex-spark 는 research preview 로 공식 token 단가가 아직 final 이 아니다.\n// 지원 타입은 유지하되, 공식 단가가 공개될 때까지 아래 generic estimate 로 계산한다.\n// @see https://help.openai.com/en/articles/20001106-codex-rate-card\nconst DEFAULT_COSTS: ModelCosts = { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 };\n\n/** Codex 백엔드가 이 모델에 허용하는 최대 effort. 카탈로그에 없는 모델은 xhigh 까지다. */\nexport function openaiModelMaxEffort(model: string): OpenAIEffort {\n  return OPENAI_COSTS[model]?.maxEffort ?? \"xhigh\";\n}\n\nexport function getModelCosts(model: string): ModelCosts {\n  const normalizedModel = (model.split(\"/\").pop() ?? model).replace(/\\[1m\\]$/i, \"\");\n  return OPENAI_COSTS[normalizedModel] ?? ANTHROPIC_COSTS[normalizedModel] ?? DEFAULT_COSTS;\n}\n\n// Verified Fast API rates for the currently served Codex models (2026-10-16).\n// Applies to all token categories and long context; not the 2.5x subscription quota multiplier.\n// https://developers.openai.com/api/docs/pricing\nconst OPENAI_FAST_MULTIPLIERS: Record<string, number> = {\n  \"gpt-6-astra\": 2,\n  \"gpt-6.1-sol\": 2,\n  \"gpt-6-sol\": 2,\n  \"gpt-6-luna\": 2,\n  \"gpt-5.6-sol\": 2,\n  \"gpt-5.6-terra\": 2,\n  \"gpt-5.6-luna\": 2,\n};\n\nexport function calculateCostUsd(\n  model: string,\n  usage: {\n    inputTokens: number;\n    outputTokens: number;\n    cachedInputTokens?: number;\n    cacheCreationInputTokens?: number;\n    cacheCreationInputTokens5m?: number;\n    cacheCreationInputTokens1h?: number;\n  },\n  serviceTier?: string,\n): number {\n  const costs = getModelCosts(model);\n  const cachedInput = usage.cachedInputTokens ?? 0;\n  const cacheCreationInput5m = Math.max(usage.cacheCreationInputTokens5m ?? 0, 0);\n  const cacheCreationInput1h = Math.max(usage.cacheCreationInputTokens1h ?? 0, 0);\n  const cacheCreationInput = Math.max(\n    usage.cacheCreationInputTokens ?? 0,\n    cacheCreationInput5m + cacheCreationInput1h,\n  );\n  const classifiedCacheCreationInput5m = Math.min(cacheCreationInput5m, cacheCreationInput);\n  const classifiedCacheCreationInput1h = Math.min(\n    cacheCreationInput1h,\n    cacheCreationInput - classifiedCacheCreationInput5m,\n  );\n  const unclassifiedCacheCreationInput =\n    cacheCreationInput - classifiedCacheCreationInput5m - classifiedCacheCreationInput1h;\n  const nonCachedInput = Math.max(usage.inputTokens - cachedInput - cacheCreationInput, 0);\n\n  // long-context 할증: 전체 입력(input_tokens, cache 포함)이 threshold 초과 시 요청 전체에 배율 적용\n  const lc = costs.longContext;\n  const isLongContext = lc !== undefined && usage.inputTokens > lc.threshold;\n  const inputRate = costs.inputTokens * (isLongContext ? lc.inputMultiplier : 1);\n  const cachedRate = costs.cachedInputTokens * (isLongContext ? lc.cachedInputMultiplier : 1);\n  const cacheCreationFallbackRate =\n    (costs.cacheCreationInputTokens ?? costs.inputTokens) *\n    (isLongContext ? lc.inputMultiplier : 1);\n  const cacheCreation5mRate =\n    (costs.cacheCreationInputTokens5m ?? costs.cacheCreationInputTokens ?? costs.inputTokens) *\n    (isLongContext ? lc.inputMultiplier : 1);\n  const cacheCreation1hRate =\n    (costs.cacheCreationInputTokens1h ?? costs.cacheCreationInputTokens ?? costs.inputTokens) *\n    (isLongContext ? lc.inputMultiplier : 1);\n  const outputRate = costs.outputTokens * (isLongContext ? lc.outputMultiplier : 1);\n\n  const standardCost =\n    (nonCachedInput / 1_000_000) * inputRate +\n    (usage.outputTokens / 1_000_000) * outputRate +\n    (cachedInput / 1_000_000) * cachedRate +\n    (unclassifiedCacheCreationInput / 1_000_000) * cacheCreationFallbackRate +\n    (classifiedCacheCreationInput5m / 1_000_000) * cacheCreation5mRate +\n    (classifiedCacheCreationInput1h / 1_000_000) * cacheCreation1hRate;\n  const normalizedModel = model.split(\"/\").pop() ?? model;\n  return (\n    standardCost * (serviceTier === \"fast\" ? (OPENAI_FAST_MULTIPLIERS[normalizedModel] ?? 1) : 1)\n  );\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"model-cost.js","names":[],"sources":["../../../../src/utils/providers/common/model-cost.ts"],"sourcesContent":["/**\n * 모델별 토큰 가격 테이블 + cost 계산.\n *\n * claude code 와 동일 패턴: 클라이언트에서 가격 테이블로 직접 계산.\n * 가격 단위: USD per 1M tokens.\n *\n * OpenAI 모델 목록은 OpenAI 모델 문서와 현재 지원 목록을 기준으로 관리한다.\n *\n * @see https://platform.openai.com/docs/pricing\n * @see https://platform.claude.com/docs/en/about-claude/pricing\n */\n\nimport { GROK_USD_PER_TICK } from \"../grok/grok-constants\";\nimport { type OpenAIEffort } from \"./effort\";\n\nexport interface ModelCosts {\n  inputTokens: number;\n  outputTokens: number;\n  cachedInputTokens: number;\n  /** TTL breakdown 이 없는 usage 에 적용할 cache write fallback 단가. */\n  cacheCreationInputTokens?: number;\n  cacheCreationInputTokens5m?: number;\n  cacheCreationInputTokens1h?: number;\n  /**\n   * long-context 할증. 전체 입력 토큰(input_tokens, cache_read 포함)이 threshold 초과 시\n   * 초과분만이 아니라 요청 전체(full session)에 배율 적용.\n   */\n  longContext?: {\n    threshold: number;\n    inputMultiplier: number;\n    cachedInputMultiplier: number;\n    outputMultiplier: number;\n  };\n}\n\n// ── OpenAI ─────────────────────────────────────────────────────────\n//\n// Standard pricing verified 2026-09-23 (기존 모델 단가 변동 없음): https://developers.openai.com/api/docs/pricing\n// 신모델 출시마다 단가가 바뀌므로(5.2→5.4→5.5) 모델 추가 시 반드시 공식 페이지 재확인해야함\n\n// GPT-5.4에서 처음 도입된 long-context 할증 (5.2/5.3-codex는 해당 없음, 5.4-mini/nano는 공식 표에서 long-context 단가 없음)\n// 272K 초과 시 input 2x / cached 2x / output 1.5x — 초과분만이 아닌 세션 전체에 적용됨\n// @see https://developers.openai.com/api/docs/models/gpt-5.5 (\"prompts with >272K input tokens\")\nconst LONG_CONTEXT_272K: NonNullable<ModelCosts[\"longContext\"]> = {\n  threshold: 272_000,\n  inputMultiplier: 2,\n  cachedInputMultiplier: 2,\n  outputMultiplier: 1.5,\n};\n\n// OpenAI 모델 카탈로그. 단가와 함께 Codex 백엔드가 모델별로 받는 최대 reasoning effort 를 한 곳에 둔다.\n// maxEffort 출처: ~/.codex/models_cache.json 의 supported_reasoning_levels (2026-09-07 확인).\n// 미기재 모델은 xhigh 까지만 받는다.\ntype OpenAIModelSpec = ModelCosts & { maxEffort?: OpenAIEffort };\n\nconst OPENAI_COSTS = new Map<string, OpenAIModelSpec>(\n  Object.entries({\n    // GPT-6 Astra: Standard API-equivalent pricing, verified 2026-09-07.\n    // Codex subscription catalog supports ultra; the public API lists only through max.\n    // @see https://developers.openai.com/api/docs/models/gpt-6-astra\n    // @see https://developers.openai.com/api/docs/pricing\n    \"gpt-6-astra\": {\n      maxEffort: \"ultra\",\n      inputTokens: 10,\n      outputTokens: 50,\n      cachedInputTokens: 1,\n      cacheCreationInputTokens: 12.5,\n      longContext: LONG_CONTEXT_272K,\n    },\n    // GPT-6.1 Sol (2026-09-29 DevDay 출시): Standard API pricing verified 2026-09-30. GPT-6 Sol 과 같고 cached input 만 절반.\n    // Codex 카탈로그(2026-09-30)는 ultra 까지 허용하고 기본 effort 는 low 다(GPT-6 Sol 은 medium).\n    // qgrid 의 요청 형태 + codex_cli_rs/0.147.0 헤더로 2026-09-30 구독 경로 라이브 생성 성공.\n    // @see https://developers.openai.com/api/docs/models/gpt-6.1-sol\n    \"gpt-6.1-sol\": {\n      maxEffort: \"ultra\",\n      inputTokens: 2,\n      outputTokens: 10,\n      cachedInputTokens: 0.1,\n      cacheCreationInputTokens: 2.5,\n      longContext: LONG_CONTEXT_272K,\n    },\n    // GPT-6 Sol, Luna (2026-09-22 출시): Standard API pricing verified 2026-09-23. GPT-5.6 Sol/Luna 의 절반 단가.\n    // Codex 카탈로그(2026-09-23)는 Sol 에 ultra, Luna 에 max 까지 허용하고 기본 effort 는 둘 다 medium 이다.\n    // @see https://developers.openai.com/api/docs/models/gpt-6-sol\n    // @see https://developers.openai.com/api/docs/models/gpt-6-luna\n    \"gpt-6-sol\": {\n      maxEffort: \"ultra\",\n      inputTokens: 2,\n      outputTokens: 10,\n      cachedInputTokens: 0.2,\n      cacheCreationInputTokens: 2.5,\n      longContext: LONG_CONTEXT_272K,\n    },\n    \"gpt-6-luna\": {\n      maxEffort: \"max\",\n      inputTokens: 0.1,\n      outputTokens: 0.5,\n      cachedInputTokens: 0.01,\n      cacheCreationInputTokens: 0.125,\n      longContext: LONG_CONTEXT_272K,\n    },\n    // GPT-5.6 Sol, Terra, Luna. cache write 단가는 외부 logger/manual usage 입력을 위해\n    // 유지한다. 현재 OpenAI 응답 usage 에 cache write 토큰 필드가 없으면 비용은 0으로 계산된다.\n    // @see https://developers.openai.com/api/docs/models/gpt-5.6-sol\n    // @see https://developers.openai.com/api/docs/models/gpt-5.6-terra\n    // @see https://developers.openai.com/api/docs/models/gpt-5.6-luna\n    // Sol promotional rates are available at least through 2026-11-21.\n    // No confirmed end date/replacement rate: recheck official pricing instead of auto-reverting.\n    \"gpt-5.6-sol\": {\n      maxEffort: \"ultra\",\n      inputTokens: 4,\n      outputTokens: 20,\n      cachedInputTokens: 0.4,\n      cacheCreationInputTokens: 5,\n      longContext: LONG_CONTEXT_272K,\n    },\n    \"gpt-5.6-terra\": {\n      maxEffort: \"ultra\",\n      inputTokens: 2,\n      outputTokens: 12,\n      cachedInputTokens: 0.2,\n      cacheCreationInputTokens: 2.5,\n      longContext: LONG_CONTEXT_272K,\n    },\n    \"gpt-5.6-luna\": {\n      maxEffort: \"max\",\n      inputTokens: 0.2,\n      outputTokens: 1.2,\n      cachedInputTokens: 0.02,\n      cacheCreationInputTokens: 0.25,\n      longContext: LONG_CONTEXT_272K,\n    },\n    // https://openai.com/index/introducing-gpt-5-5/ (2026-04 출시)\n    \"gpt-5.5\": {\n      inputTokens: 5,\n      outputTokens: 30,\n      cachedInputTokens: 0.5,\n      longContext: LONG_CONTEXT_272K,\n    },\n    // 아래 gpt-5.4 / gpt-5.4-mini / gpt-5.3-codex / gpt-5.2 는 qgrid 가 쓰는 ChatGPT 구독 Codex 경로에서\n    // 더 이상 제공되지 않는다(5.4 계열은 2026-08-31 retired, 대체 gpt-5.6-terra / gpt-5.6-luna).\n    // 과거 request log 재산정(cost_source 없는 legacy 행)에 필요하므로 단가 행은 유지한다.\n    // https://openai.com/index/introducing-gpt-5-4/ (2026-03 출시)\n    \"gpt-5.4\": {\n      inputTokens: 2.5,\n      outputTokens: 15,\n      cachedInputTokens: 0.25,\n      longContext: LONG_CONTEXT_272K,\n    },\n    \"gpt-5.4-mini\": { inputTokens: 0.75, outputTokens: 4.5, cachedInputTokens: 0.075 },\n    // gpt-5.2와 동일 단가 (cached = input의 10%)\n    \"gpt-5.3-codex\": { inputTokens: 1.75, outputTokens: 14, cachedInputTokens: 0.175 },\n    // https://openai.com/index/introducing-gpt-5-2/ (cached input 90% 할인 명시)\n    \"gpt-5.2\": { inputTokens: 1.75, outputTokens: 14, cachedInputTokens: 0.175 },\n  }),\n);\n\n// ── Anthropic ───────────────────────────────────────────────────────\n\nfunction anthropicCosts(\n  inputTokens: number,\n  outputTokens: number,\n  overrides: Pick<Partial<ModelCosts>, \"cachedInputTokens\" | \"longContext\"> = {},\n): ModelCosts {\n  const costs: ModelCosts = {\n    inputTokens,\n    outputTokens,\n    // 표준 cache read 는 base input 의 0.1x. Fable 5.1 처럼 공식 특례 단가가 있으면 override 한다.\n    cachedInputTokens: overrides.cachedInputTokens ?? inputTokens / 10,\n    // Claude Code subscription OAuth 는 1h TTL 을 자동 선택한다. 구버전처럼 응답에\n    // TTL breakdown 이 없을 때만 이 1h 단가를 fallback 으로 사용한다.\n    cacheCreationInputTokens: inputTokens * 2,\n    cacheCreationInputTokens5m: inputTokens * 1.25,\n    cacheCreationInputTokens1h: inputTokens * 2,\n  };\n\n  // Haiku 5.5 처럼 프롬프트 길이 티어가 있는 모델만 long-context 배율을 가진다.\n  if (overrides.longContext) costs.longContext = overrides.longContext;\n\n  return costs;\n}\n\n// 가격 출처: https://platform.claude.com/docs/en/about-claude/pricing (2026-10-08 확인. 2026-10-07 에 Sonnet 5.5\n// cache read 가 $0.20→$0.10(0.05x)으로 인하됐고, 그 외 기존 모델 단가는 변동 없음)\nconst ANTHROPIC_COSTS = new Map<string, ModelCosts>(\n  Object.entries({\n    // Fable 5.1 (2026-09-01 출시): input/output 은 Fable 5 와 같고 cache read 만 0.025x($0.25) 특례.\n    // @see https://platform.claude.com/docs/en/models/fable-5-1/overview\n    \"claude-fable-5-1\": anthropicCosts(10, 50, { cachedInputTokens: 0.25 }),\n    \"claude-fable-5\": anthropicCosts(10, 50),\n    sonnet: anthropicCosts(3, 15),\n    \"claude-3-5-haiku\": anthropicCosts(0.8, 4),\n    \"claude-haiku-4-5\": anthropicCosts(1, 5),\n    \"claude-3-5-sonnet\": anthropicCosts(3, 15),\n    \"claude-3-7-sonnet\": anthropicCosts(3, 15),\n    \"claude-sonnet-4\": anthropicCosts(3, 15),\n    \"claude-sonnet-4-5\": anthropicCosts(3, 15),\n    \"claude-sonnet-4-6\": anthropicCosts(3, 15),\n    \"claude-sonnet-4-7\": anthropicCosts(3, 15),\n    \"claude-opus-4\": anthropicCosts(15, 75),\n    \"claude-opus-4-1\": anthropicCosts(15, 75),\n    \"claude-opus-4-5\": anthropicCosts(5, 25),\n    \"claude-opus-4-6\": anthropicCosts(5, 25),\n    \"claude-opus-4-7\": anthropicCosts(5, 25),\n    \"claude-opus-4-8\": anthropicCosts(5, 25),\n    \"claude-opus-5\": anthropicCosts(5, 25),\n    // Opus 5.5 (2026-09-22 출시): $4/$20. cache read 는 0.05x($0.20) 특례, cache write 는 표준 배율($5/$8).\n    // @see https://platform.claude.com/docs/en/models/opus-5-5/overview\n    \"claude-opus-5-5\": anthropicCosts(4, 20, { cachedInputTokens: 0.2 }),\n    // Sonnet 5 의 introductory $2/$10 이 정식 단가로 확정됐다. 2026-09-01 에 예정됐던 $3/$15 인상은\n    // 취소됐으므로 날짜 분기 없이 고정 단가로 계산한다.\n    \"claude-sonnet-5\": anthropicCosts(2, 10),\n    // Sonnet 5.5 (2026-09-28 출시): Sonnet 5 와 같은 $2/$10. cache read 는 출시 시 표준 0.1x($0.20)였다가\n    // 2026-10-07 Haiku 5.5 출시와 함께 Opus 5.5 와 같은 0.05x($0.10)로 인하됐다(API 릴리스 노트). 비용은 요청 시점\n    // 단가로 기록되므로 날짜 분기 없이 현행 단가만 둔다. cache write 는 표준 배율($2.50/$4).\n    // @see https://platform.claude.com/docs/en/release-notes/overview (2026-10-07)\n    \"claude-sonnet-5-5\": anthropicCosts(2, 10, { cachedInputTokens: 0.1 }),\n    // Haiku 5.5 (2026-10-07 출시): 프롬프트 길이 티어 단가. 100K 이하 $0.10/$0.50, cache read 0.1x($0.01),\n    // cache write 5m $0.125 / 1h $0.20. 입력이 100K 를 넘으면 input/cache read/cache write/output 모두 5x\n    // ($0.50/$0.05/$0.625·$1/$2.50)가 요청 전체에 적용된다. 1M 컨텍스트 모델 중 유일하게 길이별 단가를 쓴다.\n    // @see https://platform.claude.com/docs/en/models/haiku-5-5/overview\n    \"claude-haiku-5-5\": anthropicCosts(0.1, 0.5, {\n      longContext: {\n        threshold: 100_000,\n        inputMultiplier: 5,\n        cachedInputMultiplier: 5,\n        outputMultiplier: 5,\n      },\n    }),\n  }),\n);\n\n// gpt-5.3-codex-spark 는 research preview 로 공식 token 단가가 아직 final 이 아니다.\n// 지원 타입은 유지하되, 공식 단가가 공개될 때까지 아래 generic estimate 로 계산한다.\n// @see https://help.openai.com/en/articles/20001106-codex-rate-card\nconst DEFAULT_COSTS: ModelCosts = { inputTokens: 3, outputTokens: 15, cachedInputTokens: 0.3 };\n\n// -- Grok (xAI) --\n//\n// Fallback only. Grok chat, image and video responses report `usage.cost_in_usd_ticks`, which is\n// authoritative (costSource \"provider\"); these rows price a response that omitted it.\n// Source: api.x.ai/v1/language-models and /image-generation-models read with the subscription JWT\n// in the 2026-10-16 live probe. One tick is 1e-10 USD (grok-4.7 lists 20000/5000/60000 ticks per\n// input/cached/output token against the public $2/$0.50/$6 per million).\nconst GROK_TICKS_PER_USD = Math.round(1 / GROK_USD_PER_TICK);\n\n/** USD for a provider-reported `cost_in_usd_ticks` amount. */\nexport function usdFromGrokTicks(ticks: number): number {\n  return ticks / GROK_TICKS_PER_USD;\n}\n\nfunction grokTokenCosts(input: number, cached: number, output: number): ModelCosts {\n  // ticks per token -> USD per 1M tokens.\n  const perMillion = (ticks: number) => (ticks * 1_000_000) / GROK_TICKS_PER_USD;\n\n  return {\n    inputTokens: perMillion(input),\n    cachedInputTokens: perMillion(cached),\n    outputTokens: perMillion(output),\n  };\n}\n\nconst GROK_COSTS = new Map<string, ModelCosts>(\n  Object.entries({\n    \"grok-4.7\": grokTokenCosts(20_000, 5_000, 60_000),\n    \"grok-4.6\": grokTokenCosts(20_000, 5_000, 60_000),\n    \"grok-4.5\": grokTokenCosts(20_000, 5_000, 60_000),\n  }),\n);\n\n// Ticks per generated image at the default 1k resolution (the probe's quality 1k image cost exactly\n// this amount). Unlisted image models have no estimate.\nconst GROK_IMAGE_PRICE_TICKS = new Map<string, number>(\n  Object.entries({\n    \"grok-imagine-image-quality\": 500_000_000,\n  }),\n);\n\nexport interface GrokMediaCost {\n  costUsd: number;\n  costSource: \"provider\" | \"pricing_table\";\n  /** Ticks reported by xAI, or the catalog-price estimate in ticks. */\n  ticks: number;\n}\n\n/**\n * Image cost: the reported ticks when present, otherwise the per-image catalog price times the\n * image count. Undefined when neither is known, so callers store an unknown cost, not a guess.\n */\nexport function grokImageCost(\n  model: string,\n  imageCount: number,\n  reportedTicks?: number,\n): GrokMediaCost | undefined {\n  if (reportedTicks !== undefined) return grokReportedCost(reportedTicks);\n  const perImage = GROK_IMAGE_PRICE_TICKS.get(model.split(\"/\").pop() ?? model);\n\n  if (perImage === undefined) return undefined;\n  const ticks = perImage * imageCount;\n\n  return { costUsd: usdFromGrokTicks(ticks), costSource: \"pricing_table\", ticks };\n}\n\n/** Video/voice cost: only a provider-reported amount; there is no catalog estimate. */\nexport function grokReportedCost(reportedTicks: number | undefined): GrokMediaCost | undefined {\n  return reportedTicks === undefined\n    ? undefined\n    : { costUsd: usdFromGrokTicks(reportedTicks), costSource: \"provider\", ticks: reportedTicks };\n}\n\n/** Codex 백엔드가 이 모델에 허용하는 최대 effort. 카탈로그에 없는 모델은 xhigh 까지다. */\nexport function openaiModelMaxEffort(model: string): OpenAIEffort {\n  return OPENAI_COSTS.get(model)?.maxEffort ?? \"xhigh\";\n}\n\nexport function getModelCosts(model: string): ModelCosts {\n  const normalizedModel = (model.split(\"/\").pop() ?? model).replace(/\\[1m\\]$/i, \"\");\n\n  return (\n    OPENAI_COSTS.get(normalizedModel) ??\n    ANTHROPIC_COSTS.get(normalizedModel) ??\n    GROK_COSTS.get(normalizedModel) ??\n    DEFAULT_COSTS\n  );\n}\n\n// Verified Fast API rates for the currently served Codex models (2026-10-16).\n// Applies to all token categories and long context; not the 2.5x subscription quota multiplier.\n// https://developers.openai.com/api/docs/pricing\nconst OPENAI_FAST_MULTIPLIERS = new Map<string, number>(\n  Object.entries({\n    \"gpt-6-astra\": 2,\n    \"gpt-6.1-sol\": 2,\n    \"gpt-6-sol\": 2,\n    \"gpt-6-luna\": 2,\n    \"gpt-5.6-sol\": 2,\n    \"gpt-5.6-terra\": 2,\n    \"gpt-5.6-luna\": 2,\n  }),\n);\n\nexport function calculateCostUsd(\n  model: string,\n  usage: {\n    inputTokens: number;\n    outputTokens: number;\n    cachedInputTokens?: number;\n    cacheCreationInputTokens?: number;\n    cacheCreationInputTokens5m?: number;\n    cacheCreationInputTokens1h?: number;\n  },\n  serviceTier?: string,\n): number {\n  const costs = getModelCosts(model);\n  const cachedInput = usage.cachedInputTokens ?? 0;\n  const cacheCreationInput5m = Math.max(usage.cacheCreationInputTokens5m ?? 0, 0);\n  const cacheCreationInput1h = Math.max(usage.cacheCreationInputTokens1h ?? 0, 0);\n\n  const cacheCreationInput = Math.max(\n    usage.cacheCreationInputTokens ?? 0,\n    cacheCreationInput5m + cacheCreationInput1h,\n  );\n\n  const classifiedCacheCreationInput5m = Math.min(cacheCreationInput5m, cacheCreationInput);\n\n  const classifiedCacheCreationInput1h = Math.min(\n    cacheCreationInput1h,\n    cacheCreationInput - classifiedCacheCreationInput5m,\n  );\n\n  const unclassifiedCacheCreationInput =\n    cacheCreationInput - classifiedCacheCreationInput5m - classifiedCacheCreationInput1h;\n\n  const nonCachedInput = Math.max(usage.inputTokens - cachedInput - cacheCreationInput, 0);\n\n  // long-context 할증: 전체 입력(input_tokens, cache 포함)이 threshold 초과 시 요청 전체에 배율 적용\n  const lc = costs.longContext;\n  const isLongContext = lc !== undefined && usage.inputTokens > lc.threshold;\n  const inputRate = costs.inputTokens * (isLongContext ? lc.inputMultiplier : 1);\n  const cachedRate = costs.cachedInputTokens * (isLongContext ? lc.cachedInputMultiplier : 1);\n\n  const cacheCreationFallbackRate =\n    (costs.cacheCreationInputTokens ?? costs.inputTokens) *\n    (isLongContext ? lc.inputMultiplier : 1);\n\n  const cacheCreation5mRate =\n    (costs.cacheCreationInputTokens5m ?? costs.cacheCreationInputTokens ?? costs.inputTokens) *\n    (isLongContext ? lc.inputMultiplier : 1);\n\n  const cacheCreation1hRate =\n    (costs.cacheCreationInputTokens1h ?? costs.cacheCreationInputTokens ?? costs.inputTokens) *\n    (isLongContext ? lc.inputMultiplier : 1);\n\n  const outputRate = costs.outputTokens * (isLongContext ? lc.outputMultiplier : 1);\n\n  const standardCost =\n    (nonCachedInput / 1_000_000) * inputRate +\n    (usage.outputTokens / 1_000_000) * outputRate +\n    (cachedInput / 1_000_000) * cachedRate +\n    (unclassifiedCacheCreationInput / 1_000_000) * cacheCreationFallbackRate +\n    (classifiedCacheCreationInput5m / 1_000_000) * cacheCreation5mRate +\n    (classifiedCacheCreationInput1h / 1_000_000) * cacheCreation1hRate;\n\n  const normalizedModel = model.split(\"/\").pop() ?? model;\n\n  return (\n    standardCost *\n    (serviceTier === \"fast\" ? (OPENAI_FAST_MULTIPLIERS.get(normalizedModel) ?? 1) : 1)\n  );\n}\n"],"mappings":"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"}

package/bundle/dist/utils/providers/common/provider-types.js

@@ -1 +1,29 @@
-export {};
+import { z } from "zod";
+//#region src/utils/providers/common/provider-types.ts
+const PROVIDER_IDS = [
+	"openai",
+	"anthropic",
+	"grok"
+];
+function isProviderId(value) {
+	return PROVIDER_IDS.some((id) => id === value);
+}
+/** Decodes parsed JSON text (for example `JSON.parse` output) into `JsonValue`. */
+const jsonValueSchema = z.json();
+const anyJsonObject = z.looseObject({});
+/** Narrows an already-decoded JSON value to its object member. */
+function isJsonObject(value) {
+	return anyJsonObject.safeParse(value).success;
+}
+/** The string member of a decoded JSON value, or undefined for any other member. */
+function jsonString(value) {
+	return z.string().safeParse(value).data;
+}
+/** The number member of a decoded JSON value, or undefined for any other member. */
+function jsonNumber(value) {
+	return z.number().safeParse(value).data;
+}
+//#endregion
+export { PROVIDER_IDS, isJsonObject, isProviderId, jsonNumber, jsonString, jsonValueSchema };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -1,3 +1,5 @@
+import { isJsonObject } from "./provider-types.js";
+import { z } from "zod";
 import { Buffer } from "node:buffer";
 //#region src/utils/providers/common/schema-validation.ts
 /**
@@ -33,16 +35,18 @@ function parseAndValidateCallerSchemas(input) {
 		} catch {
 			throw new CallerSchemaValidationError("jsonSchema must contain valid JSON");
 		}
-		if (!isRecord(parsed) || parsed.type !== "object") throw new CallerSchemaValidationError("jsonSchema top-level type must be \"object\"");
-		addComplexity(parsed, "jsonSchema", state);
+		if (!isJsonObject(parsed) || parsed.type !== "object") throw new CallerSchemaValidationError("jsonSchema top-level type must be \"object\"");
+		complexityWalk("jsonSchema", state, false).parse(parsed);
 		state.schemas += 1;
 		outputSchema = parsed;
 	}
 	for (const [index, tool] of (input.tools ?? []).entries()) {
 		addToolMetadataUtf8Bytes(tool, index, state);
 		const path = `tools[${index}].inputSchema`;
-		addComplexity(tool.inputSchema, path, state, true);
-		addUtf8Bytes(jsonStringContentUtf8ByteUpperBound(stringifyJsonOrThrow(tool.inputSchema, path)), path, state);
+		complexityWalk(path, state, true).parse(tool.inputSchema);
+		const serialized = callerJsonText.safeParse(tool.inputSchema);
+		if (!serialized.success) throw new CallerSchemaValidationError(`${path} must be JSON-serializable`);
+		addUtf8Bytes(jsonStringContentUtf8ByteUpperBound(serialized.data), path, state);
 		state.schemas += 1;
 	}
 	return outputSchema;
@@ -57,6 +61,26 @@ function serializeAndValidateDispatchSchema(schema, provider) {
 function assertAnthropicSchemaArgvSize(jsonSchema) {
 	if (Buffer.byteLength(jsonSchema, "utf8") > 65536) throw new CallerSchemaValidationError(`Anthropic dispatch schema exceeds argv UTF-8 byte limit of ${ANTHROPIC_SCHEMA_ARGV_MAX_UTF8_BYTES}`);
 }
+/**
+* Decodes an opaque caller value (QgridTool.inputSchema is z.unknown() at the API boundary) into
+* its JSON text. Cycles, BigInt, and values with no JSON form (bare undefined, functions) fail.
+*/
+const callerJsonText = z.unknown().transform((value, context) => {
+	let serialized;
+	try {
+		serialized = JSON.stringify(value);
+	} catch {
+		serialized = void 0;
+	}
+	if (serialized === void 0) {
+		context.addIssue({
+			code: "custom",
+			message: "value is not JSON-serializable"
+		});
+		return z.NEVER;
+	}
+	return serialized;
+});
 function stringifyJsonOrThrow(value, subject) {
 	let serialized;
 	try {
@@ -115,45 +139,62 @@ function jsonStringContentUtf8ByteUpperBound(value) {
 	}
 	return bytes;
 }
-function addComplexity(root, path, state, precheckUtf8Bytes = false) {
-	const rawUtf8Bytes = { value: 0 };
-	if (precheckUtf8Bytes && typeof root === "string") addRawUtf8LowerBound(root, path, state, rawUtf8Bytes);
-	addNode(path, state);
-	if (root === null || typeof root !== "object") return;
-	const stack = [{
-		value: root,
-		depth: 0
-	}];
-	while (stack.length > 0) {
-		const current = stack.pop();
-		if (Array.isArray(current.value)) {
-			for (let index = 0; index < current.value.length; index += 1) {
+/**
+* Bounded, iterative walk over a caller schema, run before anything materializes its
+* serialization. Values are read one at a time, in key order, so a limit stops the walk before
+* later values (including getters) are touched. That rules out decoding each value with a schema
+* first; nodes are classified by identity instead: Object(value) === value holds exactly for
+* objects, arrays, and functions.
+*/
+function complexityWalk(path, state, precheckUtf8Bytes) {
+	return z.unknown().transform((root) => {
+		const rawUtf8Bytes = { value: 0 };
+		if (precheckUtf8Bytes && isPrimitiveText(root)) addRawUtf8LowerBound(root, path, state, rawUtf8Bytes);
+		addNode(path, state);
+		if (root === null || root === void 0 || Object(root) !== root) return;
+		const stack = [{
+			value: Object(root),
+			depth: 0
+		}];
+		while (stack.length > 0) {
+			const current = stack.pop();
+			if (Array.isArray(current.value)) {
+				for (let index = 0; index < current.value.length; index += 1) {
+					const depth = current.depth + 1;
+					assertDepthWithinLimit(depth, path);
+					addNode(path, state);
+					const child = current.value[index];
+					if (precheckUtf8Bytes && isPrimitiveText(child)) addRawUtf8LowerBound(child, path, state, rawUtf8Bytes);
+					if (child !== null && child !== void 0 && Object(child) === child) stack.push({
+						value: Object(child),
+						depth
+					});
+				}
+				continue;
+			}
+			for (const key in current.value) {
+				if (!Object.hasOwn(current.value, key)) continue;
+				if (precheckUtf8Bytes) addRawUtf8LowerBound(key, path, state, rawUtf8Bytes);
 				const depth = current.depth + 1;
 				assertDepthWithinLimit(depth, path);
 				addNode(path, state);
-				const child = current.value[index];
-				if (precheckUtf8Bytes && typeof child === "string") addRawUtf8LowerBound(child, path, state, rawUtf8Bytes);
-				if (child !== null && typeof child === "object") stack.push({
-					value: child,
+				const descriptor = Object.getOwnPropertyDescriptor(current.value, key);
+				const child = descriptor?.get ? descriptor.get.call(current.value) : descriptor?.value;
+				if (precheckUtf8Bytes && isPrimitiveText(child)) addRawUtf8LowerBound(child, path, state, rawUtf8Bytes);
+				if (child !== null && child !== void 0 && Object(child) === child) stack.push({
+					value: Object(child),
 					depth
 				});
 			}
-			continue;
 		}
-		for (const key in current.value) {
-			if (!Object.hasOwn(current.value, key)) continue;
-			if (precheckUtf8Bytes) addRawUtf8LowerBound(key, path, state, rawUtf8Bytes);
-			const depth = current.depth + 1;
-			assertDepthWithinLimit(depth, path);
-			addNode(path, state);
-			const child = current.value[key];
-			if (precheckUtf8Bytes && typeof child === "string") addRawUtf8LowerBound(child, path, state, rawUtf8Bytes);
-			if (child !== null && typeof child === "object") stack.push({
-				value: child,
-				depth
-			});
-		}
-	}
+	});
+}
+/**
+* String test for the bounded walk. A failed zod parse builds a ZodError (which serializes the
+* input), so the walk uses identity: a primitive whose String() form is itself is a string.
+*/
+function isPrimitiveText(value) {
+	return Object(value) !== value && String(value) === value;
 }
 function addRawUtf8LowerBound(value, path, state, rawUtf8Bytes) {
 	rawUtf8Bytes.value += Buffer.byteLength(value, "utf8");
@@ -169,10 +210,7 @@ function addNode(path, state) {
 function throwLimitError(path, kind, limit, state) {
 	throw new CallerSchemaValidationError(state.schemas === 0 ? `${path} exceeds ${kind} limit of ${limit}` : `caller schemas exceed aggregate ${kind} limit of ${limit}`);
 }
-function isRecord(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
-}
 //#endregion
 export { ANTHROPIC_SCHEMA_ARGV_MAX_UTF8_BYTES, ARGV_SAFE_MAX_UTF8_BYTES, CALLER_SCHEMA_LIMITS, CallerSchemaValidationError, assertAnthropicSchemaArgvSize, parseAndValidateCallerSchemas, serializeAndValidateDispatchSchema };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"schema-validation.js","names":[],"sources":["../../../../src/utils/providers/common/schema-validation.ts"],"sourcesContent":["import { Buffer } from \"node:buffer\";\n\nimport { type JsonValue } from \"./provider-types\";\n\n/**\n * Caller-provided schemas are serialized, copied, and recursively normalized before dispatch.\n * Keep these limits comfortably above normal generated schemas while bounding that preprocessing\n * well below the API's 10 MiB request-body ceiling.\n */\nexport const CALLER_SCHEMA_LIMITS = {\n  maxUtf8Bytes: 512 * 1024,\n  maxNodes: 20_000,\n  maxDepth: 128,\n} as const;\n\n// Linux permits at most 128 KiB (MAX_ARG_STRLEN) for one argv value. qgrid uses a 50% safety\n// margin for every argv-delivered payload — Claude Code --json-schema here and the system-prompt\n// transport (claude-session) both derive from this single constant.\nexport const ARGV_SAFE_MAX_UTF8_BYTES = 64 * 1024;\nexport const ANTHROPIC_SCHEMA_ARGV_MAX_UTF8_BYTES = ARGV_SAFE_MAX_UTF8_BYTES;\n\nexport class CallerSchemaValidationError extends Error {\n  constructor(message: string) {\n    super(`qgrid: ${message}`);\n    this.name = \"CallerSchemaValidationError\";\n  }\n}\n\nexport interface CallerSchemasInput {\n  jsonSchema?: string;\n  tools?: Array<{ name: string; description?: string; inputSchema: unknown }>;\n}\n\ninterface ComplexityState {\n  utf8Bytes: number;\n  nodes: number;\n  schemas: number;\n}\n\nexport function parseAndValidateCallerSchemas(input: CallerSchemasInput): JsonValue | undefined {\n  const state: ComplexityState = {\n    utf8Bytes: 0,\n    nodes: 0,\n    schemas: 0,\n  };\n  let outputSchema: JsonValue | undefined;\n\n  if (input.jsonSchema !== undefined) {\n    addUtf8Bytes(Buffer.byteLength(input.jsonSchema, \"utf8\"), \"jsonSchema\", state);\n\n    let parsed: unknown;\n    try {\n      parsed = JSON.parse(input.jsonSchema);\n    } catch {\n      throw new CallerSchemaValidationError(\"jsonSchema must contain valid JSON\");\n    }\n\n    if (!isRecord(parsed) || parsed.type !== \"object\") {\n      throw new CallerSchemaValidationError('jsonSchema top-level type must be \"object\"');\n    }\n\n    addComplexity(parsed, \"jsonSchema\", state);\n    state.schemas += 1;\n    outputSchema = parsed as JsonValue;\n  }\n\n  for (const [index, tool] of (input.tools ?? []).entries()) {\n    addToolMetadataUtf8Bytes(tool, index, state);\n\n    const path = `tools[${index}].inputSchema`;\n    addComplexity(tool.inputSchema, path, state, true);\n\n    const serialized = stringifyJsonOrThrow(tool.inputSchema, path);\n\n    // buildToolCallSchema embeds this serialization inside another JSON string. Charge the\n    // escaped outer-string representation before that composed description is materialized.\n    addUtf8Bytes(jsonStringContentUtf8ByteUpperBound(serialized), path, state);\n    state.schemas += 1;\n  }\n\n  return outputSchema;\n}\n\nexport function serializeAndValidateDispatchSchema(\n  schema: unknown,\n  provider?: string,\n): string | undefined {\n  if (schema === undefined) return undefined;\n\n  const serialized = stringifyJsonOrThrow(schema, \"dispatch schema\");\n\n  const byteLength = Buffer.byteLength(serialized, \"utf8\");\n  if (byteLength > CALLER_SCHEMA_LIMITS.maxUtf8Bytes) {\n    throw new CallerSchemaValidationError(\n      `dispatch schema exceeds UTF-8 byte limit of ${CALLER_SCHEMA_LIMITS.maxUtf8Bytes}`,\n    );\n  }\n  if (provider === \"anthropic\") {\n    assertAnthropicSchemaArgvSize(serialized);\n  }\n\n  return serialized;\n}\n\nexport function assertAnthropicSchemaArgvSize(jsonSchema: string): void {\n  if (Buffer.byteLength(jsonSchema, \"utf8\") > ANTHROPIC_SCHEMA_ARGV_MAX_UTF8_BYTES) {\n    throw new CallerSchemaValidationError(\n      `Anthropic dispatch schema exceeds argv UTF-8 byte limit of ${ANTHROPIC_SCHEMA_ARGV_MAX_UTF8_BYTES}`,\n    );\n  }\n}\n\nfunction stringifyJsonOrThrow(value: unknown, subject: string): string {\n  let serialized: string | undefined;\n  try {\n    serialized = JSON.stringify(value);\n  } catch {\n    throw new CallerSchemaValidationError(`${subject} must be JSON-serializable`);\n  }\n  if (serialized === undefined) {\n    throw new CallerSchemaValidationError(`${subject} must be JSON-serializable`);\n  }\n  return serialized;\n}\n\nfunction addUtf8Bytes(byteLength: number, path: string, state: ComplexityState): void {\n  state.utf8Bytes += byteLength;\n  if (state.utf8Bytes > CALLER_SCHEMA_LIMITS.maxUtf8Bytes) {\n    throwLimitError(path, \"UTF-8 byte\", CALLER_SCHEMA_LIMITS.maxUtf8Bytes, state);\n  }\n}\n\nconst TOOL_DESCRIPTION_ENTRY_PREFIX = \"- \";\nconst TOOL_DESCRIPTION_NAME_SEPARATOR = \": \";\nconst TOOL_DESCRIPTION_INPUT_SCHEMA_PREFIX = \"\\n  inputSchema: \";\nconst TOOL_DESCRIPTION_ENTRY_SEPARATOR = \"\\n\";\n\nfunction addToolMetadataUtf8Bytes(\n  tool: NonNullable<CallerSchemasInput[\"tools\"]>[number],\n  index: number,\n  state: ComplexityState,\n): void {\n  const toolPath = `tools[${index}]`;\n\n  // buildToolCallSchema places every tool name in both the enum and the human-readable tool\n  // description. Count both escaped occurrences, plus the enum's JSON string delimiters.\n  const encodedNameBytes = jsonStringContentUtf8ByteUpperBound(tool.name);\n  addUtf8Bytes(encodedNameBytes * 2 + 2, `${toolPath}.name`, state);\n\n  if (tool.description !== undefined) {\n    addUtf8Bytes(\n      jsonStringContentUtf8ByteUpperBound(tool.description),\n      `${toolPath}.description`,\n      state,\n    );\n  }\n\n  // Per-tool framing also grows with the number of tools even when all caller strings are empty.\n  // Include both the toolDescriptions join separator and the enum comma after the first entry.\n  const framingBytes =\n    jsonStringContentUtf8ByteUpperBound(TOOL_DESCRIPTION_ENTRY_PREFIX) +\n    jsonStringContentUtf8ByteUpperBound(TOOL_DESCRIPTION_NAME_SEPARATOR) +\n    jsonStringContentUtf8ByteUpperBound(TOOL_DESCRIPTION_INPUT_SCHEMA_PREFIX) +\n    (index === 0 ? 0 : jsonStringContentUtf8ByteUpperBound(TOOL_DESCRIPTION_ENTRY_SEPARATOR) + 1);\n  addUtf8Bytes(framingBytes, toolPath, state);\n}\n\n/**\n * Returns a conservative UTF-8 byte count for a string when it becomes JSON string content,\n * without allocating the escaped representation. JSON.stringify uses short two-byte escapes for\n * five control characters; counting every control character as a six-byte `\\u00XX` escape keeps\n * this an upper bound while avoiding a second large temporary string.\n */\nfunction jsonStringContentUtf8ByteUpperBound(value: string): number {\n  let bytes = 0;\n\n  for (let index = 0; index < value.length; index += 1) {\n    const codeUnit = value.charCodeAt(index);\n\n    if (codeUnit === 0x22 || codeUnit === 0x5c) {\n      bytes += 2;\n      continue;\n    }\n    if (codeUnit <= 0x1f) {\n      bytes += 6;\n      continue;\n    }\n    if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {\n      const nextCodeUnit = value.charCodeAt(index + 1);\n      if (nextCodeUnit >= 0xdc00 && nextCodeUnit <= 0xdfff) {\n        bytes += 4;\n        index += 1;\n      } else {\n        // Well-formed JSON.stringify escapes lone surrogates as `\\uXXXX`.\n        bytes += 6;\n      }\n      continue;\n    }\n    if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) {\n      bytes += 6;\n      continue;\n    }\n\n    bytes += codeUnit <= 0x7f ? 1 : codeUnit <= 0x7ff ? 2 : 3;\n  }\n\n  return bytes;\n}\n\nfunction addComplexity(\n  root: unknown,\n  path: string,\n  state: ComplexityState,\n  precheckUtf8Bytes = false,\n): void {\n  const rawUtf8Bytes = { value: 0 };\n  if (precheckUtf8Bytes && typeof root === \"string\") {\n    addRawUtf8LowerBound(root, path, state, rawUtf8Bytes);\n  }\n  addNode(path, state);\n  if (root === null || typeof root !== \"object\") return;\n\n  const stack: Array<{ value: Record<string, unknown> | unknown[]; depth: number }> = [\n    { value: root as Record<string, unknown> | unknown[], depth: 0 },\n  ];\n\n  while (stack.length > 0) {\n    const current = stack.pop()!;\n    if (Array.isArray(current.value)) {\n      for (let index = 0; index < current.value.length; index += 1) {\n        const depth = current.depth + 1;\n        assertDepthWithinLimit(depth, path);\n        addNode(path, state);\n\n        const child = current.value[index];\n        if (precheckUtf8Bytes && typeof child === \"string\") {\n          addRawUtf8LowerBound(child, path, state, rawUtf8Bytes);\n        }\n        if (child !== null && typeof child === \"object\") {\n          stack.push({ value: child as Record<string, unknown> | unknown[], depth });\n        }\n      }\n      continue;\n    }\n\n    for (const key in current.value) {\n      if (!Object.hasOwn(current.value, key)) continue;\n      if (precheckUtf8Bytes) {\n        addRawUtf8LowerBound(key, path, state, rawUtf8Bytes);\n      }\n      const depth = current.depth + 1;\n      assertDepthWithinLimit(depth, path);\n      addNode(path, state);\n\n      const child = current.value[key];\n      if (precheckUtf8Bytes && typeof child === \"string\") {\n        addRawUtf8LowerBound(child, path, state, rawUtf8Bytes);\n      }\n      if (child !== null && typeof child === \"object\") {\n        stack.push({ value: child as Record<string, unknown> | unknown[], depth });\n      }\n    }\n  }\n}\n\nfunction addRawUtf8LowerBound(\n  value: string,\n  path: string,\n  state: ComplexityState,\n  rawUtf8Bytes: { value: number },\n): void {\n  rawUtf8Bytes.value += Buffer.byteLength(value, \"utf8\");\n  if (state.utf8Bytes + rawUtf8Bytes.value > CALLER_SCHEMA_LIMITS.maxUtf8Bytes) {\n    throwLimitError(path, \"UTF-8 byte\", CALLER_SCHEMA_LIMITS.maxUtf8Bytes, state);\n  }\n}\n\nfunction assertDepthWithinLimit(depth: number, path: string): void {\n  if (depth > CALLER_SCHEMA_LIMITS.maxDepth) {\n    throw new CallerSchemaValidationError(\n      `${path} exceeds depth limit of ${CALLER_SCHEMA_LIMITS.maxDepth}`,\n    );\n  }\n}\n\nfunction addNode(path: string, state: ComplexityState): void {\n  state.nodes += 1;\n  if (state.nodes > CALLER_SCHEMA_LIMITS.maxNodes) {\n    throwLimitError(path, \"node\", CALLER_SCHEMA_LIMITS.maxNodes, state);\n  }\n}\n\nfunction throwLimitError(\n  path: string,\n  kind: \"UTF-8 byte\" | \"node\",\n  limit: number,\n  state: ComplexityState,\n): never {\n  throw new CallerSchemaValidationError(\n    state.schemas === 0\n      ? `${path} exceeds ${kind} limit of ${limit}`\n      : `caller schemas exceed aggregate ${kind} limit of ${limit}`,\n  );\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return value !== null && typeof value === \"object\" && !Array.isArray(value);\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"schema-validation.js","names":[],"sources":["../../../../src/utils/providers/common/schema-validation.ts"],"sourcesContent":["import { Buffer } from \"node:buffer\";\n\nimport { z } from \"zod\";\n\nimport { isJsonObject, type JsonValue } from \"./provider-types\";\n\n/**\n * Caller-provided schemas are serialized, copied, and recursively normalized before dispatch.\n * Keep these limits comfortably above normal generated schemas while bounding that preprocessing\n * well below the API's 10 MiB request-body ceiling.\n */\nexport const CALLER_SCHEMA_LIMITS = {\n  maxUtf8Bytes: 512 * 1024,\n  maxNodes: 20_000,\n  maxDepth: 128,\n} as const;\n\n// Linux permits at most 128 KiB (MAX_ARG_STRLEN) for one argv value. qgrid uses a 50% safety\n// margin for every argv-delivered payload — Claude Code --json-schema here and the system-prompt\n// transport (claude-session) both derive from this single constant.\nexport const ARGV_SAFE_MAX_UTF8_BYTES = 64 * 1024;\nexport const ANTHROPIC_SCHEMA_ARGV_MAX_UTF8_BYTES = ARGV_SAFE_MAX_UTF8_BYTES;\n\nexport class CallerSchemaValidationError extends Error {\n  constructor(message: string) {\n    super(`qgrid: ${message}`);\n    this.name = \"CallerSchemaValidationError\";\n  }\n}\n\nexport interface CallerSchemasInput {\n  jsonSchema?: string;\n  tools?: Array<{ name: string; description?: string; inputSchema: unknown }>;\n}\n\ninterface ComplexityState {\n  utf8Bytes: number;\n  nodes: number;\n  schemas: number;\n}\n\nexport function parseAndValidateCallerSchemas(input: CallerSchemasInput): JsonValue | undefined {\n  const state: ComplexityState = {\n    utf8Bytes: 0,\n    nodes: 0,\n    schemas: 0,\n  };\n\n  let outputSchema: JsonValue | undefined;\n\n  if (input.jsonSchema !== undefined) {\n    addUtf8Bytes(Buffer.byteLength(input.jsonSchema, \"utf8\"), \"jsonSchema\", state);\n\n    let parsed: JsonValue;\n\n    try {\n      // JSON.parse without a reviver yields only JSON values.\n      parsed = JSON.parse(input.jsonSchema);\n    } catch {\n      throw new CallerSchemaValidationError(\"jsonSchema must contain valid JSON\");\n    }\n\n    if (!isJsonObject(parsed) || parsed.type !== \"object\") {\n      throw new CallerSchemaValidationError('jsonSchema top-level type must be \"object\"');\n    }\n\n    complexityWalk(\"jsonSchema\", state, false).parse(parsed);\n    state.schemas += 1;\n    outputSchema = parsed;\n  }\n\n  for (const [index, tool] of (input.tools ?? []).entries()) {\n    addToolMetadataUtf8Bytes(tool, index, state);\n\n    const path = `tools[${index}].inputSchema`;\n    complexityWalk(path, state, true).parse(tool.inputSchema);\n\n    const serialized = callerJsonText.safeParse(tool.inputSchema);\n\n    if (!serialized.success) {\n      throw new CallerSchemaValidationError(`${path} must be JSON-serializable`);\n    }\n\n    // buildToolCallSchema embeds this serialization inside another JSON string. Charge the\n    // escaped outer-string representation before that composed description is materialized.\n    addUtf8Bytes(jsonStringContentUtf8ByteUpperBound(serialized.data), path, state);\n    state.schemas += 1;\n  }\n\n  return outputSchema;\n}\n\nexport function serializeAndValidateDispatchSchema(\n  schema: JsonValue | undefined,\n  provider?: string,\n): string | undefined {\n  if (schema === undefined) return undefined;\n\n  const serialized = stringifyJsonOrThrow(schema, \"dispatch schema\");\n\n  const byteLength = Buffer.byteLength(serialized, \"utf8\");\n\n  if (byteLength > CALLER_SCHEMA_LIMITS.maxUtf8Bytes) {\n    throw new CallerSchemaValidationError(\n      `dispatch schema exceeds UTF-8 byte limit of ${CALLER_SCHEMA_LIMITS.maxUtf8Bytes}`,\n    );\n  }\n\n  if (provider === \"anthropic\") {\n    assertAnthropicSchemaArgvSize(serialized);\n  }\n\n  return serialized;\n}\n\nexport function assertAnthropicSchemaArgvSize(jsonSchema: string): void {\n  if (Buffer.byteLength(jsonSchema, \"utf8\") > ANTHROPIC_SCHEMA_ARGV_MAX_UTF8_BYTES) {\n    throw new CallerSchemaValidationError(\n      `Anthropic dispatch schema exceeds argv UTF-8 byte limit of ${ANTHROPIC_SCHEMA_ARGV_MAX_UTF8_BYTES}`,\n    );\n  }\n}\n\n/**\n * Decodes an opaque caller value (QgridTool.inputSchema is z.unknown() at the API boundary) into\n * its JSON text. Cycles, BigInt, and values with no JSON form (bare undefined, functions) fail.\n */\nconst callerJsonText = z.unknown().transform((value, context): string => {\n  let serialized: string | undefined;\n\n  try {\n    serialized = JSON.stringify(value);\n  } catch {\n    serialized = undefined;\n  }\n\n  if (serialized === undefined) {\n    context.addIssue({ code: \"custom\", message: \"value is not JSON-serializable\" });\n\n    return z.NEVER;\n  }\n\n  return serialized;\n});\n\nfunction stringifyJsonOrThrow(value: JsonValue, subject: string): string {\n  let serialized: string | undefined;\n\n  try {\n    serialized = JSON.stringify(value);\n  } catch {\n    throw new CallerSchemaValidationError(`${subject} must be JSON-serializable`);\n  }\n\n  if (serialized === undefined) {\n    throw new CallerSchemaValidationError(`${subject} must be JSON-serializable`);\n  }\n\n  return serialized;\n}\n\nfunction addUtf8Bytes(byteLength: number, path: string, state: ComplexityState): void {\n  state.utf8Bytes += byteLength;\n\n  if (state.utf8Bytes > CALLER_SCHEMA_LIMITS.maxUtf8Bytes) {\n    throwLimitError(path, \"UTF-8 byte\", CALLER_SCHEMA_LIMITS.maxUtf8Bytes, state);\n  }\n}\n\nconst TOOL_DESCRIPTION_ENTRY_PREFIX = \"- \";\nconst TOOL_DESCRIPTION_NAME_SEPARATOR = \": \";\nconst TOOL_DESCRIPTION_INPUT_SCHEMA_PREFIX = \"\\n  inputSchema: \";\nconst TOOL_DESCRIPTION_ENTRY_SEPARATOR = \"\\n\";\n\nfunction addToolMetadataUtf8Bytes(\n  tool: NonNullable<CallerSchemasInput[\"tools\"]>[number],\n  index: number,\n  state: ComplexityState,\n): void {\n  const toolPath = `tools[${index}]`;\n\n  // buildToolCallSchema places every tool name in both the enum and the human-readable tool\n  // description. Count both escaped occurrences, plus the enum's JSON string delimiters.\n  const encodedNameBytes = jsonStringContentUtf8ByteUpperBound(tool.name);\n  addUtf8Bytes(encodedNameBytes * 2 + 2, `${toolPath}.name`, state);\n\n  if (tool.description !== undefined) {\n    addUtf8Bytes(\n      jsonStringContentUtf8ByteUpperBound(tool.description),\n      `${toolPath}.description`,\n      state,\n    );\n  }\n\n  // Per-tool framing also grows with the number of tools even when all caller strings are empty.\n  // Include both the toolDescriptions join separator and the enum comma after the first entry.\n  const framingBytes =\n    jsonStringContentUtf8ByteUpperBound(TOOL_DESCRIPTION_ENTRY_PREFIX) +\n    jsonStringContentUtf8ByteUpperBound(TOOL_DESCRIPTION_NAME_SEPARATOR) +\n    jsonStringContentUtf8ByteUpperBound(TOOL_DESCRIPTION_INPUT_SCHEMA_PREFIX) +\n    (index === 0 ? 0 : jsonStringContentUtf8ByteUpperBound(TOOL_DESCRIPTION_ENTRY_SEPARATOR) + 1);\n\n  addUtf8Bytes(framingBytes, toolPath, state);\n}\n\n/**\n * Returns a conservative UTF-8 byte count for a string when it becomes JSON string content,\n * without allocating the escaped representation. JSON.stringify uses short two-byte escapes for\n * five control characters; counting every control character as a six-byte `\\u00XX` escape keeps\n * this an upper bound while avoiding a second large temporary string.\n */\nfunction jsonStringContentUtf8ByteUpperBound(value: string): number {\n  let bytes = 0;\n\n  for (let index = 0; index < value.length; index += 1) {\n    const codeUnit = value.charCodeAt(index);\n\n    if (codeUnit === 0x22 || codeUnit === 0x5c) {\n      bytes += 2;\n      continue;\n    }\n\n    if (codeUnit <= 0x1f) {\n      bytes += 6;\n      continue;\n    }\n\n    if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {\n      const nextCodeUnit = value.charCodeAt(index + 1);\n\n      if (nextCodeUnit >= 0xdc00 && nextCodeUnit <= 0xdfff) {\n        bytes += 4;\n        index += 1;\n      } else {\n        // Well-formed JSON.stringify escapes lone surrogates as `\\uXXXX`.\n        bytes += 6;\n      }\n\n      continue;\n    }\n\n    if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) {\n      bytes += 6;\n      continue;\n    }\n\n    bytes += codeUnit <= 0x7f ? 1 : codeUnit <= 0x7ff ? 2 : 3;\n  }\n\n  return bytes;\n}\n\n/**\n * Bounded, iterative walk over a caller schema, run before anything materializes its\n * serialization. Values are read one at a time, in key order, so a limit stops the walk before\n * later values (including getters) are touched. That rules out decoding each value with a schema\n * first; nodes are classified by identity instead: Object(value) === value holds exactly for\n * objects, arrays, and functions.\n */\nfunction complexityWalk(path: string, state: ComplexityState, precheckUtf8Bytes: boolean) {\n  return z.unknown().transform((root): void => {\n    const rawUtf8Bytes = { value: 0 };\n\n    if (precheckUtf8Bytes && isPrimitiveText(root)) {\n      addRawUtf8LowerBound(root, path, state, rawUtf8Bytes);\n    }\n\n    addNode(path, state);\n\n    if (root === null || root === undefined || Object(root) !== root) return;\n\n    const rootObject: object = Object(root);\n    const stack: Array<{ value: object; depth: number }> = [{ value: rootObject, depth: 0 }];\n\n    while (stack.length > 0) {\n      const current = stack.pop()!;\n\n      if (Array.isArray(current.value)) {\n        for (let index = 0; index < current.value.length; index += 1) {\n          const depth = current.depth + 1;\n          assertDepthWithinLimit(depth, path);\n          addNode(path, state);\n\n          const child: unknown = current.value[index];\n\n          if (precheckUtf8Bytes && isPrimitiveText(child)) {\n            addRawUtf8LowerBound(child, path, state, rawUtf8Bytes);\n          }\n\n          if (child !== null && child !== undefined && Object(child) === child) {\n            stack.push({ value: Object(child), depth });\n          }\n        }\n\n        continue;\n      }\n\n      for (const key in current.value) {\n        if (!Object.hasOwn(current.value, key)) continue;\n\n        if (precheckUtf8Bytes) {\n          addRawUtf8LowerBound(key, path, state, rawUtf8Bytes);\n        }\n\n        const depth = current.depth + 1;\n        assertDepthWithinLimit(depth, path);\n        addNode(path, state);\n\n        // Same read as current.value[key] for an own property: data value, or the getter's result.\n        const descriptor = Object.getOwnPropertyDescriptor(current.value, key);\n\n        const child: unknown = descriptor?.get\n          ? descriptor.get.call(current.value)\n          : descriptor?.value;\n\n        if (precheckUtf8Bytes && isPrimitiveText(child)) {\n          addRawUtf8LowerBound(child, path, state, rawUtf8Bytes);\n        }\n\n        if (child !== null && child !== undefined && Object(child) === child) {\n          stack.push({ value: Object(child), depth });\n        }\n      }\n    }\n  });\n}\n\n/**\n * String test for the bounded walk. A failed zod parse builds a ZodError (which serializes the\n * input), so the walk uses identity: a primitive whose String() form is itself is a string.\n */\nfunction isPrimitiveText(value: unknown): value is string {\n  return Object(value) !== value && String(value) === value;\n}\n\nfunction addRawUtf8LowerBound(\n  value: string,\n  path: string,\n  state: ComplexityState,\n  rawUtf8Bytes: { value: number },\n): void {\n  rawUtf8Bytes.value += Buffer.byteLength(value, \"utf8\");\n\n  if (state.utf8Bytes + rawUtf8Bytes.value > CALLER_SCHEMA_LIMITS.maxUtf8Bytes) {\n    throwLimitError(path, \"UTF-8 byte\", CALLER_SCHEMA_LIMITS.maxUtf8Bytes, state);\n  }\n}\n\nfunction assertDepthWithinLimit(depth: number, path: string): void {\n  if (depth > CALLER_SCHEMA_LIMITS.maxDepth) {\n    throw new CallerSchemaValidationError(\n      `${path} exceeds depth limit of ${CALLER_SCHEMA_LIMITS.maxDepth}`,\n    );\n  }\n}\n\nfunction addNode(path: string, state: ComplexityState): void {\n  state.nodes += 1;\n\n  if (state.nodes > CALLER_SCHEMA_LIMITS.maxNodes) {\n    throwLimitError(path, \"node\", CALLER_SCHEMA_LIMITS.maxNodes, state);\n  }\n}\n\nfunction throwLimitError(\n  path: string,\n  kind: \"UTF-8 byte\" | \"node\",\n  limit: number,\n  state: ComplexityState,\n): never {\n  throw new CallerSchemaValidationError(\n    state.schemas === 0\n      ? `${path} exceeds ${kind} limit of ${limit}`\n      : `caller schemas exceed aggregate ${kind} limit of ${limit}`,\n  );\n}\n"],"mappings":";;;;;;;;;AAWA,MAAa,uBAAuB;CAClC,cAAc,MAAM;CACpB,UAAU;CACV,UAAU;AACZ;AAKA,MAAa,2BAA2B,KAAK;AAC7C,MAAa,uCAAuC;AAEpD,IAAa,8BAAb,cAAiD,MAAM;CACrD,YAAY,SAAiB;EAC3B,MAAM,UAAU,SAAS;EACzB,KAAK,OAAO;CACd;AACF;AAaA,SAAgB,8BAA8B,OAAkD;CAC9F,MAAM,QAAyB;EAC7B,WAAW;EACX,OAAO;EACP,SAAS;CACX;CAEA,IAAI;CAEJ,IAAI,MAAM,eAAe,QAAW;EAClC,aAAa,OAAO,WAAW,MAAM,YAAY,MAAM,GAAG,cAAc,KAAK;EAE7E,IAAI;EAEJ,IAAI;GAEF,SAAS,KAAK,MAAM,MAAM,UAAU;EACtC,QAAQ;GACN,MAAM,IAAI,4BAA4B,oCAAoC;EAC5E;EAEA,IAAI,CAAC,aAAa,MAAM,KAAK,OAAO,SAAS,UAC3C,MAAM,IAAI,4BAA4B,8CAA4C;EAGpF,eAAe,cAAc,OAAO,KAAK,CAAC,CAAC,MAAM,MAAM;EACvD,MAAM,WAAW;EACjB,eAAe;CACjB;CAEA,KAAK,MAAM,CAAC,OAAO,UAAU,MAAM,SAAS,CAAC,EAAA,CAAG,QAAQ,GAAG;EACzD,yBAAyB,MAAM,OAAO,KAAK;EAE3C,MAAM,OAAO,SAAS,MAAM;EAC5B,eAAe,MAAM,OAAO,IAAI,CAAC,CAAC,MAAM,KAAK,WAAW;EAExD,MAAM,aAAa,eAAe,UAAU,KAAK,WAAW;EAE5D,IAAI,CAAC,WAAW,SACd,MAAM,IAAI,4BAA4B,GAAG,KAAK,2BAA2B;EAK3E,aAAa,oCAAoC,WAAW,IAAI,GAAG,MAAM,KAAK;EAC9E,MAAM,WAAW;CACnB;CAEA,OAAO;AACT;AAEA,SAAgB,mCACd,QACA,UACoB;CACpB,IAAI,WAAW,QAAW,OAAO;CAEjC,MAAM,aAAa,qBAAqB,QAAQ,iBAAiB;CAIjE,IAFmB,OAAO,WAAW,YAAY,MAE7C,IAAa,qBAAqB,cACpC,MAAM,IAAI,4BACR,+CAA+C,qBAAqB,cACtE;CAGF,IAAI,aAAa,aACf,8BAA8B,UAAU;CAG1C,OAAO;AACT;AAEA,SAAgB,8BAA8B,YAA0B;CACtE,IAAI,OAAO,WAAW,YAAY,MAAM,IAAA,OACtC,MAAM,IAAI,4BACR,8DAA8D,sCAChE;AAEJ;;;;;AAMA,MAAM,iBAAiB,EAAE,QAAQ,CAAC,CAAC,WAAW,OAAO,YAAoB;CACvE,IAAI;CAEJ,IAAI;EACF,aAAa,KAAK,UAAU,KAAK;CACnC,QAAQ;EACN,aAAa;CACf;CAEA,IAAI,eAAe,QAAW;EAC5B,QAAQ,SAAS;GAAE,MAAM;GAAU,SAAS;EAAiC,CAAC;EAE9E,OAAO,EAAE;CACX;CAEA,OAAO;AACT,CAAC;AAED,SAAS,qBAAqB,OAAkB,SAAyB;CACvE,IAAI;CAEJ,IAAI;EACF,aAAa,KAAK,UAAU,KAAK;CACnC,QAAQ;EACN,MAAM,IAAI,4BAA4B,GAAG,QAAQ,2BAA2B;CAC9E;CAEA,IAAI,eAAe,QACjB,MAAM,IAAI,4BAA4B,GAAG,QAAQ,2BAA2B;CAG9E,OAAO;AACT;AAEA,SAAS,aAAa,YAAoB,MAAc,OAA8B;CACpF,MAAM,aAAa;CAEnB,IAAI,MAAM,YAAY,qBAAqB,cACzC,gBAAgB,MAAM,cAAc,qBAAqB,cAAc,KAAK;AAEhF;AAEA,MAAM,gCAAgC;AACtC,MAAM,kCAAkC;AACxC,MAAM,uCAAuC;AAC7C,MAAM,mCAAmC;AAEzC,SAAS,yBACP,MACA,OACA,OACM;CACN,MAAM,WAAW,SAAS,MAAM;CAKhC,aADyB,oCAAoC,KAAK,IACrD,IAAmB,IAAI,GAAG,GAAG,SAAS,QAAQ,KAAK;CAEhE,IAAI,KAAK,gBAAgB,QACvB,aACE,oCAAoC,KAAK,WAAW,GACpD,GAAG,SAAS,eACZ,KACF;CAWF,aALE,oCAAoC,6BAA6B,IACjE,oCAAoC,+BAA+B,IACnE,oCAAoC,oCAAoC,KACvE,UAAU,IAAI,IAAI,oCAAoC,gCAAgC,IAAI,IAElE,UAAU,KAAK;AAC5C;;;;;;;AAQA,SAAS,oCAAoC,OAAuB;CAClE,IAAI,QAAQ;CAEZ,KAAK,IAAI,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAAS,GAAG;EACpD,MAAM,WAAW,MAAM,WAAW,KAAK;EAEvC,IAAI,aAAa,MAAQ,aAAa,IAAM;GAC1C,SAAS;GACT;EACF;EAEA,IAAI,YAAY,IAAM;GACpB,SAAS;GACT;EACF;EAEA,IAAI,YAAY,SAAU,YAAY,OAAQ;GAC5C,MAAM,eAAe,MAAM,WAAW,QAAQ,CAAC;GAE/C,IAAI,gBAAgB,SAAU,gBAAgB,OAAQ;IACpD,SAAS;IACT,SAAS;GACX,OAEE,SAAS;GAGX;EACF;EAEA,IAAI,YAAY,SAAU,YAAY,OAAQ;GAC5C,SAAS;GACT;EACF;EAEA,SAAS,YAAY,MAAO,IAAI,YAAY,OAAQ,IAAI;CAC1D;CAEA,OAAO;AACT;;;;;;;;AASA,SAAS,eAAe,MAAc,OAAwB,mBAA4B;CACxF,OAAO,EAAE,QAAQ,CAAC,CAAC,WAAW,SAAe;EAC3C,MAAM,eAAe,EAAE,OAAO,EAAE;EAEhC,IAAI,qBAAqB,gBAAgB,IAAI,GAC3C,qBAAqB,MAAM,MAAM,OAAO,YAAY;EAGtD,QAAQ,MAAM,KAAK;EAEnB,IAAI,SAAS,QAAQ,SAAS,UAAa,OAAO,IAAI,MAAM,MAAM;EAGlE,MAAM,QAAiD,CAAC;GAAE,OAD/B,OAAO,IAC+B;GAAY,OAAO;EAAE,CAAC;EAEvF,OAAO,MAAM,SAAS,GAAG;GACvB,MAAM,UAAU,MAAM,IAAI;GAE1B,IAAI,MAAM,QAAQ,QAAQ,KAAK,GAAG;IAChC,KAAK,IAAI,QAAQ,GAAG,QAAQ,QAAQ,MAAM,QAAQ,SAAS,GAAG;KAC5D,MAAM,QAAQ,QAAQ,QAAQ;KAC9B,uBAAuB,OAAO,IAAI;KAClC,QAAQ,MAAM,KAAK;KAEnB,MAAM,QAAiB,QAAQ,MAAM;KAErC,IAAI,qBAAqB,gBAAgB,KAAK,GAC5C,qBAAqB,OAAO,MAAM,OAAO,YAAY;KAGvD,IAAI,UAAU,QAAQ,UAAU,UAAa,OAAO,KAAK,MAAM,OAC7D,MAAM,KAAK;MAAE,OAAO,OAAO,KAAK;MAAG;KAAM,CAAC;IAE9C;IAEA;GACF;GAEA,KAAK,MAAM,OAAO,QAAQ,OAAO;IAC/B,IAAI,CAAC,OAAO,OAAO,QAAQ,OAAO,GAAG,GAAG;IAExC,IAAI,mBACF,qBAAqB,KAAK,MAAM,OAAO,YAAY;IAGrD,MAAM,QAAQ,QAAQ,QAAQ;IAC9B,uBAAuB,OAAO,IAAI;IAClC,QAAQ,MAAM,KAAK;IAGnB,MAAM,aAAa,OAAO,yBAAyB,QAAQ,OAAO,GAAG;IAErE,MAAM,QAAiB,YAAY,MAC/B,WAAW,IAAI,KAAK,QAAQ,KAAK,IACjC,YAAY;IAEhB,IAAI,qBAAqB,gBAAgB,KAAK,GAC5C,qBAAqB,OAAO,MAAM,OAAO,YAAY;IAGvD,IAAI,UAAU,QAAQ,UAAU,UAAa,OAAO,KAAK,MAAM,OAC7D,MAAM,KAAK;KAAE,OAAO,OAAO,KAAK;KAAG;IAAM,CAAC;GAE9C;EACF;CACF,CAAC;AACH;;;;;AAMA,SAAS,gBAAgB,OAAiC;CACxD,OAAO,OAAO,KAAK,MAAM,SAAS,OAAO,KAAK,MAAM;AACtD;AAEA,SAAS,qBACP,OACA,MACA,OACA,cACM;CACN,aAAa,SAAS,OAAO,WAAW,OAAO,MAAM;CAErD,IAAI,MAAM,YAAY,aAAa,QAAQ,qBAAqB,cAC9D,gBAAgB,MAAM,cAAc,qBAAqB,cAAc,KAAK;AAEhF;AAEA,SAAS,uBAAuB,OAAe,MAAoB;CACjE,IAAI,QAAQ,qBAAqB,UAC/B,MAAM,IAAI,4BACR,GAAG,KAAK,0BAA0B,qBAAqB,UACzD;AAEJ;AAEA,SAAS,QAAQ,MAAc,OAA8B;CAC3D,MAAM,SAAS;CAEf,IAAI,MAAM,QAAQ,qBAAqB,UACrC,gBAAgB,MAAM,QAAQ,qBAAqB,UAAU,KAAK;AAEtE;AAEA,SAAS,gBACP,MACA,MACA,OACA,OACO;CACP,MAAM,IAAI,4BACR,MAAM,YAAY,IACd,GAAG,KAAK,WAAW,KAAK,YAAY,UACpC,mCAAmC,KAAK,YAAY,OAC1D;AACF"}

package/bundle/dist/utils/providers/common/smooth-weighted-round-robin.js

@@ -39,4 +39,4 @@ var SmoothWeightedRoundRobin = class {
 //#endregion
 export { SmoothWeightedRoundRobin };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21vb3RoLXdlaWdodGVkLXJvdW5kLXJvYmluLmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy91dGlscy9wcm92aWRlcnMvY29tbW9uL3Ntb290aC13ZWlnaHRlZC1yb3VuZC1yb2Jpbi50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgU21vb3RoV2VpZ2h0ZWRSb3VuZFJvYmluIHtcbiAgcmVhZG9ubHkgd2VpZ2h0cyA9IG5ldyBNYXA8bnVtYmVyLCBudW1iZXI+KCk7XG4gIHJlYWRvbmx5IGN1cnJlbnRTY29yZXMgPSBuZXcgTWFwPG51bWJlciwgbnVtYmVyPigpO1xuXG4gIHNldFRva2VuKHRva2VuSWQ6IG51bWJlciwgd2VpZ2h0OiBudW1iZXIpOiB2b2lkIHtcbiAgICBpZiAoIU51bWJlci5pc0ludGVnZXIod2VpZ2h0KSB8fCB3ZWlnaHQgPCAxIHx8IHdlaWdodCA+IDEwMCkge1xuICAgICAgdGhyb3cgbmV3IFJhbmdlRXJyb3IoXCJ3ZWlnaHQgbXVzdCBiZSBhbiBpbnRlZ2VyIGJldHdlZW4gMSBhbmQgMTAwXCIpO1xuICAgIH1cblxuICAgIGlmICh0aGlzLndlaWdodHMuZ2V0KHRva2VuSWQpID09PSB3ZWlnaHQpIHJldHVybjtcbiAgICB0aGlzLndlaWdodHMuc2V0KHRva2VuSWQsIHdlaWdodCk7XG4gICAgdGhpcy5yZXNldFNjb3JlcygpO1xuICB9XG5cbiAgcmVtb3ZlVG9rZW4odG9rZW5JZDogbnVtYmVyKTogdm9pZCB7XG4gICAgaWYgKCF0aGlzLndlaWdodHMuZGVsZXRlKHRva2VuSWQpKSByZXR1cm47XG4gICAgdGhpcy5jdXJyZW50U2NvcmVzLmRlbGV0ZSh0b2tlbklkKTtcbiAgICB0aGlzLnJlc2V0U2NvcmVzKCk7XG4gIH1cblxuICByZXNldFNjb3JlcygpOiB2b2lkIHtcbiAgICB0aGlzLmN1cnJlbnRTY29yZXMuY2xlYXIoKTtcbiAgfVxuXG4gIHNlbGVjdChlbGlnaWJsZVRva2VuSWRzOiBSZWFkb25seVNldDxudW1iZXI+KTogbnVtYmVyIHwgbnVsbCB7XG4gICAgY29uc3QgY2FuZGlkYXRlcyA9IFsuLi5lbGlnaWJsZVRva2VuSWRzXVxuICAgICAgLmZpbHRlcigodG9rZW5JZCkgPT4gdGhpcy53ZWlnaHRzLmhhcyh0b2tlbklkKSlcbiAgICAgIC50b1NvcnRlZCgoYSwgYikgPT4gYSAtIGIpO1xuXG4gICAgaWYgKGNhbmRpZGF0ZXMubGVuZ3RoID09PSAwKSByZXR1cm4gbnVsbDtcblxuICAgIGxldCBzZWxlY3RlZCA9IGNhbmRpZGF0ZXNbMF0hO1xuICAgIGxldCBzZWxlY3RlZFNjb3JlID0gTnVtYmVyLk5FR0FUSVZFX0lORklOSVRZO1xuICAgIGxldCB0b3RhbFdlaWdodCA9IDA7XG5cbiAgICBjYW5kaWRhdGVzLmZvckVhY2goKHRva2VuSWQpID0+IHtcbiAgICAgIGNvbnN0IHdlaWdodCA9IHRoaXMud2VpZ2h0cy5nZXQodG9rZW5JZCkhO1xuICAgICAgdG90YWxXZWlnaHQgKz0gd2VpZ2h0O1xuICAgICAgY29uc3Qgc2NvcmUgPSAodGhpcy5jdXJyZW50U2NvcmVzLmdldCh0b2tlbklkKSA/PyAwKSArIHdlaWdodDtcbiAgICAgIHRoaXMuY3VycmVudFNjb3Jlcy5zZXQodG9rZW5JZCwgc2NvcmUpO1xuXG4gICAgICBpZiAoc2NvcmUgPiBzZWxlY3RlZFNjb3JlKSB7XG4gICAgICAgIHNlbGVjdGVkID0gdG9rZW5JZDtcbiAgICAgICAgc2VsZWN0ZWRTY29yZSA9IHNjb3JlO1xuICAgICAgfVxuICAgIH0pO1xuXG4gICAgdGhpcy5jdXJyZW50U2NvcmVzLnNldChzZWxlY3RlZCwgc2VsZWN0ZWRTY29yZSAtIHRvdGFsV2VpZ2h0KTtcblxuICAgIHJldHVybiBzZWxlY3RlZDtcbiAgfVxufVxuIl0sIm1hcHBpbmdzIjoiO0FBQUEsSUFBYSwyQkFBYixNQUFzQztDQUNwQywwQkFBbUIsSUFBSSxJQUFvQjtDQUMzQyxnQ0FBeUIsSUFBSSxJQUFvQjtDQUVqRCxTQUFTLFNBQWlCLFFBQXNCO0VBQzlDLElBQUksQ0FBQyxPQUFPLFVBQVUsTUFBTSxLQUFLLFNBQVMsS0FBSyxTQUFTLEtBQ3RELE1BQU0sSUFBSSxXQUFXLDZDQUE2QztFQUdwRSxJQUFJLEtBQUssUUFBUSxJQUFJLE9BQU8sTUFBTSxRQUFRO0VBQzFDLEtBQUssUUFBUSxJQUFJLFNBQVMsTUFBTTtFQUNoQyxLQUFLLFlBQVk7Q0FDbkI7Q0FFQSxZQUFZLFNBQXVCO0VBQ2pDLElBQUksQ0FBQyxLQUFLLFFBQVEsT0FBTyxPQUFPLEdBQUc7RUFDbkMsS0FBSyxjQUFjLE9BQU8sT0FBTztFQUNqQyxLQUFLLFlBQVk7Q0FDbkI7Q0FFQSxjQUFvQjtFQUNsQixLQUFLLGNBQWMsTUFBTTtDQUMzQjtDQUVBLE9BQU8sa0JBQXNEO0VBQzNELE1BQU0sYUFBYSxDQUFDLEdBQUcsZ0JBQWdCLENBQUMsQ0FDckMsUUFBUSxZQUFZLEtBQUssUUFBUSxJQUFJLE9BQU8sQ0FBQyxDQUFDLENBQzlDLFVBQVUsR0FBRyxNQUFNLElBQUksQ0FBQztFQUUzQixJQUFJLFdBQVcsV0FBVyxHQUFHLE9BQU87RUFFcEMsSUFBSSxXQUFXLFdBQVc7RUFDMUIsSUFBSSxnQkFBZ0IsT0FBTztFQUMzQixJQUFJLGNBQWM7RUFFbEIsV0FBVyxTQUFTLFlBQVk7R0FDOUIsTUFBTSxTQUFTLEtBQUssUUFBUSxJQUFJLE9BQU87R0FDdkMsZUFBZTtHQUNmLE1BQU0sU0FBUyxLQUFLLGNBQWMsSUFBSSxPQUFPLEtBQUssS0FBSztHQUN2RCxLQUFLLGNBQWMsSUFBSSxTQUFTLEtBQUs7R0FFckMsSUFBSSxRQUFRLGVBQWU7SUFDekIsV0FBVztJQUNYLGdCQUFnQjtHQUNsQjtFQUNGLENBQUM7RUFFRCxLQUFLLGNBQWMsSUFBSSxVQUFVLGdCQUFnQixXQUFXO0VBRTVELE9BQU87Q0FDVDtBQUNGIn0=