@cartanova/qgrid-cli 2.6.2 → 2.6.5

package/README.ko.md

@@ -92,6 +92,8 @@ CLI는 실행 시 npm의 최신 버전을 확인하고 patch를 포함해 설치
 | `QGRID_DB_NAME` | `qgrid` |
 | `SLACK_BOT_TOKEN` | — (미설정 시 토큰 만료 알림 비활성) |
 | `SLACK_CHANNEL_ID` | — |
+| `SLACK_EXPIRY_DIGEST_INTERVAL_MINUTES` | — (미설정 시 비활성 토큰 재알림 끔) |
+| `SLACK_USER_MAP` | — (`토큰명:SlackUserId` 목록) |
 
 서버 동작 관련 환경변수:
 

package/README.md

@@ -93,6 +93,8 @@ Without the `--db` flag, DB connection info is read from:
 | `QGRID_DB_NAME` | `qgrid` |
 | `SLACK_BOT_TOKEN` | — (unset disables token-expiry notifications) |
 | `SLACK_CHANNEL_ID` | — |
+| `SLACK_EXPIRY_DIGEST_INTERVAL_MINUTES` | — (unset disables inactive-token reminders) |
+| `SLACK_USER_MAP` | — (`tokenName:SlackUserId` pairs) |
 
 Server behavior variables:
 

package/bundle/dist/application/qgrid/expired-token-digest.js

@@ -0,0 +1,78 @@
+import { SLACK_COLOR, notifySlack } from "../../utils/slack-notify.js";
+import { TokenModel } from "../token/token.model.js";
+import { getLogger } from "@logtape/logtape";
+//#region src/application/qgrid/expired-token-digest.ts
+/**
+* 비활성 토큰 주기 알림.
+*
+* 사망 순간의 단발 알림(`token-death.ts`)은 그 시점에 채널을 보지 않으면 놓친다. 재로그인은
+* 사람이 해야 하는 일이라 놓치면 토큰이 계속 빠진 채로 남는다. 그래서 남아 있는 비활성
+* 토큰을 주기적으로 다시 알리고, 소유자를 멘션해 개인에게 꽂는다.
+*
+* 비활성 토큰이 없으면 보내지 않는다 — "이상 없음"을 주기적으로 알리면 채널이 무뎌진다.
+*/
+const logger = getLogger(["qgrid", "expired-digest"]);
+const MINUTE_MS = 6e4;
+/**
+* `토큰명:SlackUserId` 목록. 공용 계정(bysuco, dev-common 등)은 넣지 않는다 — 매핑이 없으면
+* 멘션 없이 이름만 나가고, 그게 맞는 동작이다.
+*
+* Slack 표시 이름과 토큰명이 자주 어긋나(haze→haze.lee, byeongjun→potados) 자동 매칭은
+* 조용히 실패한다. 멘션이 빠지면 알림의 목적 자체가 사라지므로 명시 매핑만 쓴다.
+*/
+function parseUserMap(raw) {
+	const map = /* @__PURE__ */ new Map();
+	if (!raw) return map;
+	for (const entry of raw.split(",")) {
+		const [name, userId] = entry.split(":").map((s) => s.trim());
+		if (name && userId) map.set(name, userId);
+	}
+	return map;
+}
+/** `anthropic/yds` → `yds`. provider prefix 없이 저장된 이름도 그대로 받는다. */
+function ownerOf(tokenName) {
+	if (!tokenName) return "";
+	const slash = tokenName.indexOf("/");
+	return slash === -1 ? tokenName : tokenName.slice(slash + 1);
+}
+function buildDigestContext(tokens, userMap) {
+	return tokens.map((token) => {
+		const userId = userMap.get(ownerOf(token.name));
+		const label = token.name ?? "unnamed";
+		return userId ? `<@${userId}> ${token.provider}` : `${label} (${token.provider})`;
+	}).join("\n");
+}
+async function sendDigest(userMap) {
+	const inactive = await TokenModel.findInactive("A");
+	if (inactive.length === 0) return;
+	await notifySlack({
+		title: `재로그인 필요 ${inactive.length}건`,
+		context: buildDigestContext(inactive, userMap),
+		color: SLACK_COLOR.bad
+	});
+}
+let timer = null;
+/**
+* `SLACK_EXPIRY_DIGEST_INTERVAL_MINUTES` 가 양수일 때만 켜진다. 미설정·0 이면 비활성.
+*
+* 인스턴스가 여러 개면 각자 보낸다. 사망 알림과 달리 상태 변화가 없어 DB 로 억제할 수 없고,
+* 다이제스트는 하루 몇 건 수준이라 중복을 감수하는 편이 잠금 장치를 두는 것보다 낫다.
+*/
+function startExpiredTokenDigest() {
+	const minutes = Number(process.env.SLACK_EXPIRY_DIGEST_INTERVAL_MINUTES ?? 0);
+	if (!Number.isFinite(minutes) || minutes <= 0) return;
+	const userMap = parseUserMap(process.env.SLACK_USER_MAP);
+	logger.info(`expired token digest every ${minutes}m (${userMap.size} user mappings)`);
+	timer = setInterval(() => {
+		sendDigest(userMap).catch((e) => logger.warn(`digest failed: ${e.message}`));
+	}, minutes * MINUTE_MS);
+}
+function stopExpiredTokenDigest() {
+	if (!timer) return;
+	clearInterval(timer);
+	timer = null;
+}
+//#endregion
+export { buildDigestContext, startExpiredTokenDigest, stopExpiredTokenDigest };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhwaXJlZC10b2tlbi1kaWdlc3QuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FwcGxpY2F0aW9uL3FncmlkL2V4cGlyZWQtdG9rZW4tZGlnZXN0LnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICog67mE7Zmc7ISxIO2GoO2BsCDso7zquLAg7JWM66a8LlxuICpcbiAqIOyCrOunnSDsiJzqsITsnZgg64uo67CcIOyVjOumvChgdG9rZW4tZGVhdGgudHNgKeydgCDqt7gg7Iuc7KCQ7JeQIOyxhOuEkOydhCDrs7Tsp4Ag7JWK7Jy866m0IOuGk+y5nOuLpC4g7J6s66Gc6re47J247J2AXG4gKiDsgqzrnozsnbQg7ZW07JW8IO2VmOuKlCDsnbzsnbTrnbwg64aT7LmY66m0IO2GoO2BsOydtCDqs4Tsho0g67mg7KeEIOyxhOuhnCDrgqjripTri6QuIOq3uOuemOyEnCDrgqjslYQg7J6I64qUIOu5hO2ZnOyEsVxuICog7Yag7YGw7J2EIOyjvOq4sOyggeycvOuhnCDri6Tsi5wg7JWM66as6rOgLCDshozsnKDsnpDrpbwg66mY7IWY7ZW0IOqwnOyduOyXkOqyjCDqvYLripTri6QuXG4gKlxuICog67mE7Zmc7ISxIO2GoO2BsOydtCDsl4bsnLzrqbQg67O064K07KeAIOyViuuKlOuLpCDigJQgXCLsnbTsg4Eg7JeG7J2MXCLsnYQg7KO86riw7KCB7Jy866GcIOyVjOumrOuptCDssYTrhJDsnbQg66y0646M7KeE64ukLlxuICovXG5pbXBvcnQgeyBnZXRMb2dnZXIgfSBmcm9tIFwiQGxvZ3RhcGUvbG9ndGFwZVwiO1xuXG5pbXBvcnQgeyBub3RpZnlTbGFjaywgU0xBQ0tfQ09MT1IgfSBmcm9tIFwiLi4vLi4vdXRpbHMvc2xhY2stbm90aWZ5XCI7XG5pbXBvcnQgeyBUb2tlbk1vZGVsIH0gZnJvbSBcIi4uL3Rva2VuL3Rva2VuLm1vZGVsXCI7XG5cbmNvbnN0IGxvZ2dlciA9IGdldExvZ2dlcihbXCJxZ3JpZFwiLCBcImV4cGlyZWQtZGlnZXN0XCJdKTtcblxuY29uc3QgTUlOVVRFX01TID0gNjBfMDAwO1xuXG4vKipcbiAqIGDthqDtgbDrqoU6U2xhY2tVc2VySWRgIOuqqeuhnS4g6rO17JqpIOqzhOyglShieXN1Y28sIGRldi1jb21tb24g65OxKeydgCDrhKPsp4Ag7JWK64qU64ukIOKAlCDrp6TtlZHsnbQg7JeG7Jy866m0XG4gKiDrqZjshZgg7JeG7J20IOydtOumhOunjCDrgpjqsIDqs6AsIOq3uOqyjCDrp57ripQg64+Z7J6R7J2064ukLlxuICpcbiAqIFNsYWNrIO2RnOyLnCDsnbTrpoTqs7wg7Yag7YGw66qF7J20IOyekOyjvCDslrTquIvrgpgoaGF6ZeKGkmhhemUubGVlLCBieWVvbmdqdW7ihpJwb3RhZG9zKSDsnpDrj5kg66ek7Lmt7J2AXG4gKiDsobDsmqntnogg7Iuk7Yyo7ZWc64ukLiDrqZjshZjsnbQg67mg7KeA66m0IOyVjOumvOydmCDrqqnsoIEg7J6Q7LK06rCAIOyCrOudvOyngOuvgOuhnCDrqoXsi5wg66ek7ZWR66eMIOyTtOuLpC5cbiAqL1xuZnVuY3Rpb24gcGFyc2VVc2VyTWFwKHJhdzogc3RyaW5nIHwgdW5kZWZpbmVkKTogTWFwPHN0cmluZywgc3RyaW5nPiB7XG4gIGNvbnN0IG1hcCA9IG5ldyBNYXA8c3RyaW5nLCBzdHJpbmc+KCk7XG4gIGlmICghcmF3KSByZXR1cm4gbWFwO1xuXG4gIGZvciAoY29uc3QgZW50cnkgb2YgcmF3LnNwbGl0KFwiLFwiKSkge1xuICAgIGNvbnN0IFtuYW1lLCB1c2VySWRdID0gZW50cnkuc3BsaXQoXCI6XCIpLm1hcCgocykgPT4gcy50cmltKCkpO1xuICAgIGlmIChuYW1lICYmIHVzZXJJZCkgbWFwLnNldChuYW1lLCB1c2VySWQpO1xuICB9XG4gIHJldHVybiBtYXA7XG59XG5cbi8qKiBgYW50aHJvcGljL3lkc2Ag4oaSIGB5ZHNgLiBwcm92aWRlciBwcmVmaXgg7JeG7J20IOyggOyepeuQnCDsnbTrpoTrj4Qg6re464yA66GcIOuwm+uKlOuLpC4gKi9cbmZ1bmN0aW9uIG93bmVyT2YodG9rZW5OYW1lOiBzdHJpbmcgfCBudWxsKTogc3RyaW5nIHtcbiAgaWYgKCF0b2tlbk5hbWUpIHJldHVybiBcIlwiO1xuICBjb25zdCBzbGFzaCA9IHRva2VuTmFtZS5pbmRleE9mKFwiL1wiKTtcbiAgcmV0dXJuIHNsYXNoID09PSAtMSA/IHRva2VuTmFtZSA6IHRva2VuTmFtZS5zbGljZShzbGFzaCArIDEpO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gYnVpbGREaWdlc3RDb250ZXh0KFxuICB0b2tlbnM6IHsgbmFtZTogc3RyaW5nIHwgbnVsbDsgcHJvdmlkZXI6IHN0cmluZyB9W10sXG4gIHVzZXJNYXA6IE1hcDxzdHJpbmcsIHN0cmluZz4sXG4pOiBzdHJpbmcge1xuICByZXR1cm4gdG9rZW5zXG4gICAgLm1hcCgodG9rZW4pID0+IHtcbiAgICAgIGNvbnN0IHVzZXJJZCA9IHVzZXJNYXAuZ2V0KG93bmVyT2YodG9rZW4ubmFtZSkpO1xuICAgICAgY29uc3QgbGFiZWwgPSB0b2tlbi5uYW1lID8/IFwidW5uYW1lZFwiO1xuICAgICAgLy8g66mY7IWY7J20IOyeiOycvOuptCDsnbTrpoQg64yA7IugIOupmOyFmOydhCDsk7Tri6Qg4oCUIOuRmCDri6Qg7JOw66m0IOqwmeydgCDrp5DsnbQg65GQIOuyiCDrgpjsmKjri6QuXG4gICAgICByZXR1cm4gdXNlcklkID8gYDxAJHt1c2VySWR9PiAke3Rva2VuLnByb3ZpZGVyfWAgOiBgJHtsYWJlbH0gKCR7dG9rZW4ucHJvdmlkZXJ9KWA7XG4gICAgfSlcbiAgICAuam9pbihcIlxcblwiKTtcbn1cblxuYXN5bmMgZnVuY3Rpb24gc2VuZERpZ2VzdCh1c2VyTWFwOiBNYXA8c3RyaW5nLCBzdHJpbmc+KTogUHJvbWlzZTx2b2lkPiB7XG4gIGNvbnN0IGluYWN0aXZlID0gYXdhaXQgVG9rZW5Nb2RlbC5maW5kSW5hY3RpdmUoXCJBXCIpO1xuICBpZiAoaW5hY3RpdmUubGVuZ3RoID09PSAwKSByZXR1cm47XG5cbiAgYXdhaXQgbm90aWZ5U2xhY2soe1xuICAgIHRpdGxlOiBg7J6s66Gc6re47J24IO2VhOyalCAke2luYWN0aXZlLmxlbmd0aH3qsbRgLFxuICAgIGNvbnRleHQ6IGJ1aWxkRGlnZXN0Q29udGV4dChpbmFjdGl2ZSwgdXNlck1hcCksXG4gICAgY29sb3I6IFNMQUNLX0NPTE9SLmJhZCxcbiAgfSk7XG59XG5cbmxldCB0aW1lcjogUmV0dXJuVHlwZTx0eXBlb2Ygc2V0SW50ZXJ2YWw+IHwgbnVsbCA9IG51bGw7XG5cbi8qKlxuICogYFNMQUNLX0VYUElSWV9ESUdFU1RfSU5URVJWQUxfTUlOVVRFU2Ag6rCAIOyWkeyImOydvCDrlYzrp4wg7Lyc7KeE64ukLiDrr7jshKTsoJXCtzAg7J2066m0IOu5hO2ZnOyEsS5cbiAqXG4gKiDsnbjsiqTthLTsiqTqsIAg7Jes65+sIOqwnOuptCDqsIHsnpAg67O064K464ukLiDsgqzrp50g7JWM66a86rO8IOuLrOumrCDsg4Htg5wg67OA7ZmU6rCAIOyXhuyWtCBEQiDroZwg7Ja17KCc7ZWgIOyImCDsl4bqs6AsXG4gKiDri6TsnbTsoJzsiqTtirjripQg7ZWY66OoIOuqhyDqsbQg7IiY7KSA7J206528IOykkeuzteydhCDqsJDsiJjtlZjripQg7Y647J20IOyeoOq4iCDsnqXsuZjrpbwg65GQ64qUIOqyg+uztOuLpCDrgqvri6QuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBzdGFydEV4cGlyZWRUb2tlbkRpZ2VzdCgpOiB2b2lkIHtcbiAgY29uc3QgbWludXRlcyA9IE51bWJlcihwcm9jZXNzLmVudi5TTEFDS19FWFBJUllfRElHRVNUX0lOVEVSVkFMX01JTlVURVMgPz8gMCk7XG4gIGlmICghTnVtYmVyLmlzRmluaXRlKG1pbnV0ZXMpIHx8IG1pbnV0ZXMgPD0gMCkgcmV0dXJuO1xuXG4gIGNvbnN0IHVzZXJNYXAgPSBwYXJzZVVzZXJNYXAocHJvY2Vzcy5lbnYuU0xBQ0tfVVNFUl9NQVApO1xuICBsb2dnZXIuaW5mbyhgZXhwaXJlZCB0b2tlbiBkaWdlc3QgZXZlcnkgJHttaW51dGVzfW0gKCR7dXNlck1hcC5zaXplfSB1c2VyIG1hcHBpbmdzKWApO1xuXG4gIHRpbWVyID0gc2V0SW50ZXJ2YWwoKCkgPT4ge1xuICAgIHNlbmREaWdlc3QodXNlck1hcCkuY2F0Y2goKGUpID0+IGxvZ2dlci53YXJuKGBkaWdlc3QgZmFpbGVkOiAkeyhlIGFzIEVycm9yKS5tZXNzYWdlfWApKTtcbiAgfSwgbWludXRlcyAqIE1JTlVURV9NUyk7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBzdG9wRXhwaXJlZFRva2VuRGlnZXN0KCk6IHZvaWQge1xuICBpZiAoIXRpbWVyKSByZXR1cm47XG4gIGNsZWFySW50ZXJ2YWwodGltZXIpO1xuICB0aW1lciA9IG51bGw7XG59XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7QUFjQSxNQUFNLFNBQVMsVUFBVSxDQUFDLFNBQVMsZ0JBQWdCLENBQUM7QUFFcEQsTUFBTSxZQUFZOzs7Ozs7OztBQVNsQixTQUFTLGFBQWEsS0FBOEM7Q0FDbEUsTUFBTSxzQkFBTSxJQUFJLElBQW9CO0NBQ3BDLElBQUksQ0FBQyxLQUFLLE9BQU87Q0FFakIsS0FBSyxNQUFNLFNBQVMsSUFBSSxNQUFNLEdBQUcsR0FBRztFQUNsQyxNQUFNLENBQUMsTUFBTSxVQUFVLE1BQU0sTUFBTSxHQUFHLENBQUMsQ0FBQyxLQUFLLE1BQU0sRUFBRSxLQUFLLENBQUM7RUFDM0QsSUFBSSxRQUFRLFFBQVEsSUFBSSxJQUFJLE1BQU0sTUFBTTtDQUMxQztDQUNBLE9BQU87QUFDVDs7QUFHQSxTQUFTLFFBQVEsV0FBa0M7Q0FDakQsSUFBSSxDQUFDLFdBQVcsT0FBTztDQUN2QixNQUFNLFFBQVEsVUFBVSxRQUFRLEdBQUc7Q0FDbkMsT0FBTyxVQUFVLEtBQUssWUFBWSxVQUFVLE1BQU0sUUFBUSxDQUFDO0FBQzdEO0FBRUEsU0FBZ0IsbUJBQ2QsUUFDQSxTQUNRO0NBQ1IsT0FBTyxPQUNKLEtBQUssVUFBVTtFQUNkLE1BQU0sU0FBUyxRQUFRLElBQUksUUFBUSxNQUFNLElBQUksQ0FBQztFQUM5QyxNQUFNLFFBQVEsTUFBTSxRQUFRO0VBRTVCLE9BQU8sU0FBUyxLQUFLLE9BQU8sSUFBSSxNQUFNLGFBQWEsR0FBRyxNQUFNLElBQUksTUFBTSxTQUFTO0NBQ2pGLENBQUMsQ0FBQyxDQUNELEtBQUssSUFBSTtBQUNkO0FBRUEsZUFBZSxXQUFXLFNBQTZDO0NBQ3JFLE1BQU0sV0FBVyxNQUFNLFdBQVcsYUFBYSxHQUFHO0NBQ2xELElBQUksU0FBUyxXQUFXLEdBQUc7Q0FFM0IsTUFBTSxZQUFZO0VBQ2hCLE9BQU8sV0FBVyxTQUFTLE9BQU87RUFDbEMsU0FBUyxtQkFBbUIsVUFBVSxPQUFPO0VBQzdDLE9BQU8sWUFBWTtDQUNyQixDQUFDO0FBQ0g7QUFFQSxJQUFJLFFBQStDOzs7Ozs7O0FBUW5ELFNBQWdCLDBCQUFnQztDQUM5QyxNQUFNLFVBQVUsT0FBTyxRQUFRLElBQUksd0NBQXdDLENBQUM7Q0FDNUUsSUFBSSxDQUFDLE9BQU8sU0FBUyxPQUFPLEtBQUssV0FBVyxHQUFHO0NBRS9DLE1BQU0sVUFBVSxhQUFhLFFBQVEsSUFBSSxjQUFjO0NBQ3ZELE9BQU8sS0FBSyw4QkFBOEIsUUFBUSxLQUFLLFFBQVEsS0FBSyxnQkFBZ0I7Q0FFcEYsUUFBUSxrQkFBa0I7RUFDeEIsV0FBVyxPQUFPLENBQUMsQ0FBQyxPQUFPLE1BQU0sT0FBTyxLQUFLLGtCQUFtQixFQUFZLFNBQVMsQ0FBQztDQUN4RixHQUFHLFVBQVUsU0FBUztBQUN4QjtBQUVBLFNBQWdCLHlCQUErQjtDQUM3QyxJQUFJLENBQUMsT0FBTztDQUNaLGNBQWMsS0FBSztDQUNuQixRQUFRO0FBQ1YifQ==

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

@@ -1,18 +1,52 @@
+import { SD } from "../../i18n/sd.generated.js";
 import { getAccessToken } from "../../utils/providers/common/credentials.js";
 import { calculateCostUsd } from "../../utils/providers/common/model-cost.js";
 import { parseAndValidateCallerSchemas, serializeAndValidateDispatchSchema } from "../../utils/providers/common/schema-validation.js";
 import { strictify } from "../../utils/providers/common/strictifier.js";
 import { decideConvRouting, issueConvContext } from "./conv-routing.js";
-import { ProcessError, QuotaError, maskToken } from "./qgrid.types.js";
+import { ProcessError, maskToken } from "./qgrid.types.js";
 import { applyToolCallEmulation } from "./tool-emulation.js";
 import { buildToolCallSchema } from "./tool-emulation-schema.js";
+import { InternalServerErrorException, ServiceUnavailableException } from "sonamu";
 //#region src/application/qgrid/qgrid.dispatcher.ts
+/**
+* QgridDispatcher — provider dispatcher 라우팅 + 토큰 캐시/통계 싱글턴.
+*
+* - 메모리 캐시 (Map<id, TokenSubsetA>) 는 TokenSubscriber 가 pg LISTEN/NOTIFY 로 갱신
+* - OpenAI/Anthropic 요청은 각 provider dispatcher 로만 실행
+* - QuotaError 는 그대로 상위 전파
+* - dispatcher 미준비는 기동 중(503)/초기화 실패(500)로 구분해 던진다
+*/
 var QgridDispatcherClass = class {
 	tokens = /* @__PURE__ */ new Map();
 	requestCounts = /* @__PURE__ */ new Map();
 	subscriber = null;
 	openaiDispatcher = null;
 	anthropicDispatcher = null;
+	/**
+	* provider 별 기동 상태. dispatcher 가 없는 이유를 구분하기 위해 필요하다 —
+	* HTTP 리스닝은 dispatcher 준비보다 먼저 열리므로(sonamu.config onStart),
+	* 그 사이 들어온 요청은 "잠시 후 되는" 상태와 "재시도해도 안 되는" 상태가 다르다.
+	*
+	* - `starting`: 워커 spawn 중. dev0 기준 25 워커 × 500ms 간격이라 1~2분 걸린다 → 재시도 가능
+	* - `ready`: 정상
+	* - `failed`: start() 가 예외로 끝남 → 재시도해도 같은 결과
+	*/
+	startupState = {
+		openai: "starting",
+		anthropic: "starting"
+	};
+	/**
+	* dispatcher 가 준비되지 않았을 때 던질 예외를 만든다.
+	*
+	* 기동 중이면 503(+Retry-After) 으로 재시도 가능함을 알리고, 초기화가 실패로 끝났으면
+	* 500 으로 재시도가 무의미함을 알린다. 이전에는 둘 다 QuotaError 였는데, 쿼터 소진이
+	* 아닌 상태를 그렇게 표현하면 호출자가 토큰 문제로 오해하고 재시도 판단도 못 한다.
+	*/
+	notReadyError(provider) {
+		const label = provider === "openai" ? "OpenAI" : "Anthropic";
+		return this.startupState[provider] === "failed" ? new InternalServerErrorException(SD("qgrid.dispatcherFailed")(label)) : new ServiceUnavailableException(SD("qgrid.dispatcherStarting")(label));
+	}
 	countOf(name) {
 		return this.requestCounts.get(name) ?? 0;
 	}
@@ -38,7 +72,7 @@ var QgridDispatcherClass = class {
 		const outputSchema = buildAndValidateStrictOutputSchema(input, route.provider);
 		const answerKind = input.jsonSchema ? "json" : "text";
 		if (route.provider === "openai") {
-			if (!this.openaiDispatcher) throw new QuotaError("OpenAI dispatcher not initialized");
+			if (!this.openaiDispatcher) throw this.notReadyError("openai");
 			const decision = decideConvRouting(input);
 			const result = await this.openaiDispatcher.generate({
 				model: route.model,
@@ -63,7 +97,7 @@ var QgridDispatcherClass = class {
 				answerKind
 			});
 		} else if (route.provider === "anthropic") {
-			if (!this.anthropicDispatcher) throw new QuotaError("Anthropic dispatcher not initialized");
+			if (!this.anthropicDispatcher) throw this.notReadyError("anthropic");
 			const decision = decideConvRouting(input);
 			const result = await this.anthropicDispatcher.generate({
 				model: input.model,
@@ -89,7 +123,7 @@ var QgridDispatcherClass = class {
 		const outputSchema = buildAndValidateStrictOutputSchema(input, route.provider);
 		const answerKind = input.jsonSchema ? "json" : "text";
 		if (route.provider === "openai") {
-			if (!this.openaiDispatcher) throw new QuotaError("OpenAI dispatcher not initialized");
+			if (!this.openaiDispatcher) throw this.notReadyError("openai");
 			const decision = decideConvRouting(input);
 			await this.openaiDispatcher.generateStream({
 				model: route.model,
@@ -120,7 +154,7 @@ var QgridDispatcherClass = class {
 			});
 			return;
 		} else if (route.provider === "anthropic") {
-			if (!this.anthropicDispatcher) throw new QuotaError("Anthropic dispatcher not initialized");
+			if (!this.anthropicDispatcher) throw this.notReadyError("anthropic");
 			const decision = decideConvRouting(input);
 			await this.anthropicDispatcher.generateStream({
 				model: input.model,
@@ -208,4 +242,4 @@ const QgridDispatcher = new QgridDispatcherClass();
 //#endregion
 export { QgridDispatcher, QgridDispatcherClass, buildAndValidateStrictOutputSchema, 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 {\n  parseAndValidateCallerSchemas,\n  serializeAndValidateDispatchSchema,\n} from \"../../utils/providers/common/schema-validation\";\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 } from \"./tool-emulation\";\nimport { buildToolCallSchema } from \"./tool-emulation-schema\";\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, abortSignal?: AbortSignal): Promise<QueryOutput> {\n    const route = parseProviderRoute(input.model);\n    const outputSchema = buildAndValidateStrictOutputSchema(input, route.provider);\n    // answer 인코딩 판정: jsonSchema 있으면 사용자 스키마 JSON, 없으면 평문 string. 4개 방출 지점이 공유.\n    const answerKind = input.jsonSchema ? (\"json\" as const) : (\"text\" as const);\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        abortSignal,\n        imageGeneration: input.imageGeneration,\n        imageGenerationOptions: input.imageGenerationOptions,\n      });\n\n      // 이미지 요청은 cold-only(R8)라 재사용 좌표를 발급하지 않는다. 좌표를 실으면\n      // sessionKey 소비자의 warm 좌표를 죽은 좌표로 덮어써 다음 텍스트 turn 이 cold 로 떨어진다.\n      const coord = input.imageGeneration\n        ? undefined\n        : issueConvContext(result.threadCoord, decision);\n\n      return applyToolCallEmulation(toEmulationResult(result), input.tools, {\n        threadCoord: coord,\n        images: result.images,\n        answerKind,\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        timeoutMs: input.timeout,\n        abortSignal,\n        coldInput: decision.coldInput,\n        coldHistory: decision.coldHistory,\n        imageGeneration: input.imageGeneration,\n        imageGenerationOptions: input.imageGenerationOptions,\n      });\n\n      return applyToolCallEmulation(toEmulationResult(result), input.tools, {\n        threadCoord: issueConvContext(result.threadCoord, decision),\n        answerKind,\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 = buildAndValidateStrictOutputSchema(input, route.provider);\n    // answer 인코딩 판정: jsonSchema 있으면 사용자 스키마 JSON, 없으면 평문 string. 4개 방출 지점이 공유.\n    const answerKind = input.jsonSchema ? (\"json\" as const) : (\"text\" as const);\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          // 이미지 플래그를 전달해야 generateStream 의 non-stream 전용 거부(R2)가 발동한다.\n          imageGeneration: input.imageGeneration,\n          imageGenerationOptions: input.imageGenerationOptions,\n        },\n        {\n          onDelta: cb.onDelta,\n          onThreadId: cb.onThreadId,\n          onTurnId: cb.onTurnId,\n          onComplete: (turnResult) => {\n            cb.onComplete(\n              applyToolCallEmulation(toEmulationResult(turnResult), input.tools, {\n                threadCoord: issueConvContext(turnResult.threadCoord, decision),\n                answerKind,\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          timeoutMs: input.timeout,\n          abortSignal,\n          imageGeneration: input.imageGeneration,\n          imageGenerationOptions: input.imageGenerationOptions,\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, {\n                threadCoord: issuedCoord,\n                answerKind,\n              }),\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// 드물게 어겨 provider retry 예산을 소진한 비정상 종료도 정직한 에러로 받아준다.\nexport function buildStrictOutputSchema(\n  input: Pick<QueryInput, \"tools\" | \"jsonSchema\">,\n  provider?: string,\n): JsonValue | undefined {\n  const outputSchema = buildRawOutputSchema(input);\n\n  return outputSchema\n    ? (strictify(outputSchema as Parameters<typeof strictify>[0], { provider }) as JsonValue)\n    : undefined;\n}\n\nexport function buildAndValidateStrictOutputSchema(\n  input: Pick<QueryInput, \"model\" | \"tools\" | \"jsonSchema\">,\n  provider = parseProviderRoute(input.model).provider,\n): JsonValue | undefined {\n  const outputSchema = buildStrictOutputSchema(input, provider);\n  serializeAndValidateDispatchSchema(outputSchema, provider);\n  return outputSchema;\n}\n\nfunction buildRawOutputSchema(\n  input: Pick<QueryInput, \"tools\" | \"jsonSchema\">,\n): JsonValue | undefined {\n  const callerOutputSchema = parseAndValidateCallerSchemas(input);\n\n  return input.tools?.length\n    ? buildToolCallSchema(input.tools, callerOutputSchema)\n    : callerOutputSchema;\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  const hasProviderCost = result.costUsd !== undefined && result.costUsd > 0;\n  return {\n    text: result.text,\n    tokenName: result.tokenName,\n    model: result.model,\n    requestedModel: result.requestedModel,\n    modelFallbacks: result.modelFallbacks,\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_creation_5m_input_tokens: result.usage.cacheCreationInputTokens5m,\n      cache_creation_1h_input_tokens: result.usage.cacheCreationInputTokens1h,\n      cache_read_input_tokens: result.usage.cachedInputTokens,\n    },\n    durationMs: result.durationMs,\n    ttftMs: result.ttftMs ?? 0,\n    costUsd: hasProviderCost\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          cacheCreationInputTokens5m: result.usage.cacheCreationInputTokens5m,\n          cacheCreationInputTokens1h: result.usage.cacheCreationInputTokens1h,\n        }),\n    costSource: hasProviderCost ? \"provider\" : \"pricing_table\",\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 * - dispatcher 미준비는 기동 중(503)/초기화 실패(500)로 구분해 던진다\n */\n\nimport { InternalServerErrorException, ServiceUnavailableException } from \"sonamu\";\n\nimport { type JsonValue } from \"../../codex-protocol/serde_json/JsonValue\";\nimport { SD } from \"../../i18n/sd.generated\";\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 {\n  parseAndValidateCallerSchemas,\n  serializeAndValidateDispatchSchema,\n} from \"../../utils/providers/common/schema-validation\";\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 {\n  maskToken,\n  ProcessError,\n  type ProviderStartupState,\n  type QueryInput,\n  type QueryOutput,\n  type TokenStats,\n} from \"./qgrid.types\";\nimport { type TokenSubscriber } from \"./token-subscriber\";\nimport { applyToolCallEmulation } from \"./tool-emulation\";\nimport { buildToolCallSchema } from \"./tool-emulation-schema\";\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  /**\n   * provider 별 기동 상태. dispatcher 가 없는 이유를 구분하기 위해 필요하다 —\n   * HTTP 리스닝은 dispatcher 준비보다 먼저 열리므로(sonamu.config onStart),\n   * 그 사이 들어온 요청은 \"잠시 후 되는\" 상태와 \"재시도해도 안 되는\" 상태가 다르다.\n   *\n   * - `starting`: 워커 spawn 중. dev0 기준 25 워커 × 500ms 간격이라 1~2분 걸린다 → 재시도 가능\n   * - `ready`: 정상\n   * - `failed`: start() 가 예외로 끝남 → 재시도해도 같은 결과\n   */\n  startupState: Record<\"openai\" | \"anthropic\", ProviderStartupState> = {\n    openai: \"starting\",\n    anthropic: \"starting\",\n  };\n\n  /**\n   * dispatcher 가 준비되지 않았을 때 던질 예외를 만든다.\n   *\n   * 기동 중이면 503(+Retry-After) 으로 재시도 가능함을 알리고, 초기화가 실패로 끝났으면\n   * 500 으로 재시도가 무의미함을 알린다. 이전에는 둘 다 QuotaError 였는데, 쿼터 소진이\n   * 아닌 상태를 그렇게 표현하면 호출자가 토큰 문제로 오해하고 재시도 판단도 못 한다.\n   */\n  private notReadyError(provider: \"openai\" | \"anthropic\"): Error {\n    const label = provider === \"openai\" ? \"OpenAI\" : \"Anthropic\";\n    return this.startupState[provider] === \"failed\"\n      ? new InternalServerErrorException(SD(\"qgrid.dispatcherFailed\")(label))\n      : new ServiceUnavailableException(SD(\"qgrid.dispatcherStarting\")(label));\n  }\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, abortSignal?: AbortSignal): Promise<QueryOutput> {\n    const route = parseProviderRoute(input.model);\n    const outputSchema = buildAndValidateStrictOutputSchema(input, route.provider);\n    // answer 인코딩 판정: jsonSchema 있으면 사용자 스키마 JSON, 없으면 평문 string. 4개 방출 지점이 공유.\n    const answerKind = input.jsonSchema ? (\"json\" as const) : (\"text\" as const);\n\n    // provider prefix routing: 'openai/gpt-5.4' → OpenAIDispatcher\n    if (route.provider === \"openai\") {\n      if (!this.openaiDispatcher) throw this.notReadyError(\"openai\");\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        abortSignal,\n        imageGeneration: input.imageGeneration,\n        imageGenerationOptions: input.imageGenerationOptions,\n      });\n\n      // 이미지 요청은 cold-only(R8)라 재사용 좌표를 발급하지 않는다. 좌표를 실으면\n      // sessionKey 소비자의 warm 좌표를 죽은 좌표로 덮어써 다음 텍스트 turn 이 cold 로 떨어진다.\n      const coord = input.imageGeneration\n        ? undefined\n        : issueConvContext(result.threadCoord, decision);\n\n      return applyToolCallEmulation(toEmulationResult(result), input.tools, {\n        threadCoord: coord,\n        images: result.images,\n        answerKind,\n      });\n    } else if (route.provider === \"anthropic\") {\n      if (!this.anthropicDispatcher) throw this.notReadyError(\"anthropic\");\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        timeoutMs: input.timeout,\n        abortSignal,\n        coldInput: decision.coldInput,\n        coldHistory: decision.coldHistory,\n        imageGeneration: input.imageGeneration,\n        imageGenerationOptions: input.imageGenerationOptions,\n      });\n\n      return applyToolCallEmulation(toEmulationResult(result), input.tools, {\n        threadCoord: issueConvContext(result.threadCoord, decision),\n        answerKind,\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 = buildAndValidateStrictOutputSchema(input, route.provider);\n    // answer 인코딩 판정: jsonSchema 있으면 사용자 스키마 JSON, 없으면 평문 string. 4개 방출 지점이 공유.\n    const answerKind = input.jsonSchema ? (\"json\" as const) : (\"text\" as const);\n\n    if (route.provider === \"openai\") {\n      if (!this.openaiDispatcher) throw this.notReadyError(\"openai\");\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          // 이미지 플래그를 전달해야 generateStream 의 non-stream 전용 거부(R2)가 발동한다.\n          imageGeneration: input.imageGeneration,\n          imageGenerationOptions: input.imageGenerationOptions,\n        },\n        {\n          onDelta: cb.onDelta,\n          onThreadId: cb.onThreadId,\n          onTurnId: cb.onTurnId,\n          onComplete: (turnResult) => {\n            cb.onComplete(\n              applyToolCallEmulation(toEmulationResult(turnResult), input.tools, {\n                threadCoord: issueConvContext(turnResult.threadCoord, decision),\n                answerKind,\n              }),\n            );\n          },\n          onError: cb.onError,\n        },\n      );\n      return;\n    } else if (route.provider === \"anthropic\") {\n      if (!this.anthropicDispatcher) throw this.notReadyError(\"anthropic\");\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          timeoutMs: input.timeout,\n          abortSignal,\n          imageGeneration: input.imageGeneration,\n          imageGenerationOptions: input.imageGenerationOptions,\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, {\n                threadCoord: issuedCoord,\n                answerKind,\n              }),\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// 드물게 어겨 provider retry 예산을 소진한 비정상 종료도 정직한 에러로 받아준다.\nexport function buildStrictOutputSchema(\n  input: Pick<QueryInput, \"tools\" | \"jsonSchema\">,\n  provider?: string,\n): JsonValue | undefined {\n  const outputSchema = buildRawOutputSchema(input);\n\n  return outputSchema\n    ? (strictify(outputSchema as Parameters<typeof strictify>[0], { provider }) as JsonValue)\n    : undefined;\n}\n\nexport function buildAndValidateStrictOutputSchema(\n  input: Pick<QueryInput, \"model\" | \"tools\" | \"jsonSchema\">,\n  provider = parseProviderRoute(input.model).provider,\n): JsonValue | undefined {\n  const outputSchema = buildStrictOutputSchema(input, provider);\n  serializeAndValidateDispatchSchema(outputSchema, provider);\n  return outputSchema;\n}\n\nfunction buildRawOutputSchema(\n  input: Pick<QueryInput, \"tools\" | \"jsonSchema\">,\n): JsonValue | undefined {\n  const callerOutputSchema = parseAndValidateCallerSchemas(input);\n\n  return input.tools?.length\n    ? buildToolCallSchema(input.tools, callerOutputSchema)\n    : callerOutputSchema;\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  const hasProviderCost = result.costUsd !== undefined && result.costUsd > 0;\n  return {\n    text: result.text,\n    tokenName: result.tokenName,\n    model: result.model,\n    requestedModel: result.requestedModel,\n    modelFallbacks: result.modelFallbacks,\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_creation_5m_input_tokens: result.usage.cacheCreationInputTokens5m,\n      cache_creation_1h_input_tokens: result.usage.cacheCreationInputTokens1h,\n      cache_read_input_tokens: result.usage.cachedInputTokens,\n    },\n    durationMs: result.durationMs,\n    ttftMs: result.ttftMs ?? 0,\n    costUsd: hasProviderCost\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          cacheCreationInputTokens5m: result.usage.cacheCreationInputTokens5m,\n          cacheCreationInputTokens1h: result.usage.cacheCreationInputTokens1h,\n        }),\n    costSource: hasProviderCost ? \"provider\" : \"pricing_table\",\n  };\n}\n\nexport const QgridDispatcher = new QgridDispatcherClass();\n"],"mappings":"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"}