@cartanova/qgrid-cli 2.5.2 → 2.5.4

package/README.ko.md

@@ -96,10 +96,15 @@ CLI는 실행 시 npm의 최신 버전을 확인하고 patch를 포함해 설치
 | 변수 | 설명 | 기본값 |
 |------|------|--------|
 | `NODE_ENV` | Sonamu 실행 프로필. 원격 비프로덕션 배포에는 `staging` 사용 | `production` |
-| `QGRID_WORKERS_PER_TOKEN` | OpenAI 토큰당 codex worker 수 | `3` (최대 5) |
+| `QGRID_OPENAI_AUTOSCALE` | OpenAI worker autoscaling. `false` 또는 `0`이면 고정 크기 pool 사용 | 활성 |
+| `QGRID_OPENAI_MIN_WORKERS_PER_TOKEN` | autoscaling 중 OpenAI 토큰당 최소 worker 수 | `5` |
+| `QGRID_OPENAI_MAX_WORKERS_PER_TOKEN` | autoscaling 중 OpenAI 토큰당 최대 worker 수 | `15` |
+| `QGRID_WORKERS_PER_TOKEN` | OpenAI 최소/고정 worker 수의 legacy fallback | `5` |
 | `QGRID_PUBLIC_BASE_URL` | Anthropic OAuth callback 공개 베이스 URL. 원격 접속 환경에서 설정 | 미설정 시 `http://localhost:<port>/callback` |
 | `QGRID_OPENAI_THREAD_REUSE` | `false`로 설정 시 OpenAI thread reuse(prompt cache) 비활성화 | 활성 |
 
+OpenAI worker 수는 토큰당 hard cap 20으로 제한됨. autoscaling을 끄면 pool은 설정된 최소 worker 수로 고정됨.
+
 ## 사전 요구사항
 
 - Node.js >= 20
@@ -115,7 +120,7 @@ CLI는 Sonamu 기반 서버를 내장 번들로 포함. 실행 시:
 1. DB 연결 확인
 2. 서버 시작 (API + 대시보드 웹 UI)
 3. DB의 등록된 토큰 로드. 이후 토큰 등록/변경은 PostgreSQL LISTEN/NOTIFY로 실행 중인 서버에 실시간 반영
-4. **OpenAI 토큰**: 토큰당 persistent codex app-server 프로세스 N개 spawn (기본 3, 최대 5). JSON-RPC로 통신. 요청은 idle worker에 round-robin 라우팅, 전부 busy면 큐 대기 (최대 60초). `sessionKey` 멀티턴 요청은 같은 thread로 재라우팅되어 prompt cache 적중
+4. **OpenAI 토큰**: 토큰당 persistent codex app-server 프로세스를 5개에서 15개까지 autoscale (hard cap 20). JSON-RPC로 통신. 요청은 idle worker에 round-robin 라우팅, 전부 busy면 큐 대기 (최대 60초). `sessionKey` 멀티턴 요청은 같은 thread로 재라우팅되어 prompt cache 적중
 5. **Anthropic 토큰**: 요청마다 격리된 claude 프로세스를 fresh spawn (`stream-json` 입출력). 토큰은 least-used 우선으로 선택. OAuth 토큰 자동 refresh
 6. 토큰별 quota threshold(기본 80%)를 넘은 토큰은 라우팅에서 제외 (사용률 조회 실패 시에는 fail-open으로 통과)
 

package/README.md

@@ -97,10 +97,15 @@ Server behavior variables:
 | Variable | Description | Default |
 |------|------|--------|
 | `NODE_ENV` | Sonamu runtime profile. Set `staging` for a remote non-production deployment | `production` |
-| `QGRID_WORKERS_PER_TOKEN` | codex workers per OpenAI token | `3` (max 5) |
+| `QGRID_OPENAI_AUTOSCALE` | OpenAI worker autoscaling. Set to `false` or `0` to keep a fixed-size pool | enabled |
+| `QGRID_OPENAI_MIN_WORKERS_PER_TOKEN` | Minimum OpenAI workers per token while autoscaling | `5` |
+| `QGRID_OPENAI_MAX_WORKERS_PER_TOKEN` | Maximum OpenAI workers per token while autoscaling | `15` |
+| `QGRID_WORKERS_PER_TOKEN` | Legacy fallback for the OpenAI minimum/fixed worker count | `5` |
 | `QGRID_PUBLIC_BASE_URL` | Public base URL for the Anthropic OAuth callback. Set it when the server is accessed remotely | `http://localhost:<port>/callback` when unset |
 | `QGRID_OPENAI_THREAD_REUSE` | Set to `false` to disable OpenAI thread reuse (prompt caching) | enabled |
 
+OpenAI worker counts are clamped to a hard cap of 20 per token. With autoscaling disabled, the pool stays at the configured minimum.
+
 ## Prerequisites
 
 - Node.js >= 20
@@ -116,7 +121,7 @@ The CLI ships the Sonamu-based server as a built-in bundle. On launch:
 1. Verify the DB connection
 2. Start the server (API + dashboard web UI)
 3. Load registered tokens from the DB. Later token additions/changes propagate to the running server in real time via PostgreSQL LISTEN/NOTIFY
-4. **OpenAI tokens**: spawn N persistent codex app-server processes per token (default 3, max 5), communicating over JSON-RPC. Requests are routed round-robin across idle workers; when all are busy they queue (up to 60 seconds). Multi-turn requests carrying a `sessionKey` are routed back to the same thread for prompt-cache hits
+4. **OpenAI tokens**: autoscale persistent codex app-server processes per token from 5 to 15 (hard cap 20), communicating over JSON-RPC. Requests are routed round-robin across idle workers; when all are busy they queue (up to 60 seconds). Multi-turn requests carrying a `sessionKey` are routed back to the same thread for prompt-cache hits
 5. **Anthropic tokens**: spawn a fresh, isolated claude process per request (`stream-json` in/out). Tokens are selected least-used-first. OAuth tokens are refreshed automatically
 6. Tokens over their quota threshold (default 80%) are excluded from routing (usage-lookup failures fail open)
 

package/bundle/dist/application/monit/monit.frame.js

@@ -1,8 +1,8 @@
 import { monitLogBuffer } from "./log-buffer.js";
+import { resolveOpenAIWorkerPoolConfig } from "../../utils/providers/openai/openai-worker-pool-config.js";
+import { QgridDispatcher } from "../qgrid/qgrid.dispatcher.js";
 import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.140.0/helpers/esm/decorateMetadata.js";
 import __decorate from "../../_virtual/_@oxc-project_runtime@0.140.0/helpers/esm/decorate.js";
-import { resolveOpenAIWorkerPoolConfig } from "../../utils/providers/openai/openai-dispatcher.js";
-import { QgridDispatcher } from "../qgrid/qgrid.dispatcher.js";
 import { BaseFrameClass, DB, api } from "sonamu";
 //#region src/application/monit/monit.frame.ts
 /**
@@ -82,4 +82,4 @@ const MonitFrame = new MonitFrameClass();
 //#endregion
 export { MonitFrame };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9uaXQuZnJhbWUuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FwcGxpY2F0aW9uL21vbml0L21vbml0LmZyYW1lLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogTW9uaXQg4oCUIOuMgOyLnOuztOuTnCBNb25pdCDtg63smqkg7ZSE66Gc7IS47IqkIOuhnOq3uCDqtIDsuKEgQVBJLlxuICpcbiAqIOydveq4sCDsoITsmqkuIHJpbmcgYnVmZmVyIOulvCDslofqsowg7KeB7KCRIOydveycvOupsCjrspTsmqkg7L+866asIOq4sOqzhCDsl4bsnbQpLFxuICogcmVxdWVzdCBsb2cg66W8IOuCqOq4sOyngCDslYrripTri6QuIOygkeq3vCDqsr3qs4TripQg64uk66W4IOuMgOyLnOuztOuTnCBBUEkg7JmAIOuPmeydvO2VmOuLpC5cbiAqL1xuaW1wb3J0IHsgYXBpLCBCYXNlRnJhbWVDbGFzcywgREIgfSBmcm9tIFwic29uYW11XCI7XG5cbmltcG9ydCB7IHJlc29sdmVPcGVuQUlXb3JrZXJQb29sQ29uZmlnIH0gZnJvbSBcIi4uLy4uL3V0aWxzL3Byb3ZpZGVycy9vcGVuYWkvb3BlbmFpLWRpc3BhdGNoZXJcIjtcbmltcG9ydCB7IFFncmlkRGlzcGF0Y2hlciB9IGZyb20gXCIuLi9xZ3JpZC9xZ3JpZC5kaXNwYXRjaGVyXCI7XG5pbXBvcnQgeyBtb25pdExvZ0J1ZmZlciB9IGZyb20gXCIuL2xvZy1idWZmZXJcIjtcbmltcG9ydCB7IHR5cGUgTW9uaXRMb2dDaHVuaywgdHlwZSBNb25pdFNlcnZlckluZm8sIHR5cGUgTW9uaXRWaXRhbHMgfSBmcm9tIFwiLi9tb25pdC50eXBlc1wiO1xuXG4vLyDsnZHri7Xri7kg7JeU7Yq466asIOyDge2VnCDigJQg7Y+066eBIO2BtOudvOydtOyWuO2KuOuKlCDri6TsnYwg7Y+07JeQ7IScIOydtOyWtOyEnCDrlLDrnbzsnqHripTri6QuXG5jb25zdCBSRVNQT05TRV9FTlRSWV9MSU1JVCA9IDFfMDAwO1xuXG5jbGFzcyBNb25pdEZyYW1lQ2xhc3MgZXh0ZW5kcyBCYXNlRnJhbWVDbGFzcyB7XG4gIGNvbnN0cnVjdG9yKCkge1xuICAgIHN1cGVyKFwiTW9uaXRcIik7XG4gIH1cblxuICBAYXBpKHsgaHR0cE1ldGhvZDogXCJHRVRcIiwgY2xpZW50czogW1wiYXhpb3NcIiwgXCJ0YW5zdGFjay1xdWVyeVwiXSB9KVxuICBhc3luYyBtb25pdExvZ3MoY3Vyc29yPzogbnVtYmVyKTogUHJvbWlzZTxNb25pdExvZ0NodW5rPiB7XG4gICAgcmV0dXJuIHtcbiAgICAgIHByb2Nlc3NTdGFydGVkQXQ6IG1vbml0TG9nQnVmZmVyLnByb2Nlc3NTdGFydGVkQXQsXG4gICAgICAuLi5tb25pdExvZ0J1ZmZlci5hZnRlcihjdXJzb3IsIFJFU1BPTlNFX0VOVFJZX0xJTUlUKSxcbiAgICAgIHZpdGFsczogY3VycmVudFZpdGFscygpLFxuICAgIH07XG4gIH1cblxuICAvLyDtlITroZzshLjsiqQg7KCV7KCBIOygleuztCDigJQg7Y+066eBIOu2iO2VhOyalCwg7Y6Y7J207KeA64u5IDHtmowg7KGw7ZqMLlxuICBAYXBpKHsgaHR0cE1ldGhvZDogXCJHRVRcIiwgY2xpZW50czogW1wiYXhpb3NcIiwgXCJ0YW5zdGFjay1xdWVyeVwiXSB9KVxuICBhc3luYyBtb25pdEluZm8oKTogUHJvbWlzZTxNb25pdFNlcnZlckluZm8+IHtcbiAgICBjb25zdCBwb29sID0gcmVzb2x2ZU9wZW5BSVdvcmtlclBvb2xDb25maWcoKTtcbiAgICBjb25zdCBob3N0ID0gcHJvY2Vzcy5lbnYuSE9TVCA/PyBcImxvY2FsaG9zdFwiO1xuICAgIGNvbnN0IHBvcnQgPSBwcm9jZXNzLmVudi5QT1JUID8/IFwiNDQ5MDBcIjtcbiAgICBjb25zdCBjb25uID0gYWN0aXZlRGJDb25uZWN0aW9uKCk7XG4gICAgcmV0dXJuIHtcbiAgICAgIHNlcnZlclVybDogYGh0dHA6Ly8ke2hvc3R9OiR7cG9ydH1gLFxuICAgICAgZGJIb3N0OiBjb25uLmhvc3QgPz8gXCJsb2NhbGhvc3RcIixcbiAgICAgIGRiTmFtZTogY29ubi5kYXRhYmFzZSA/PyBcInFncmlkXCIsXG4gICAgICBvcGVuYWk6IHtcbiAgICAgICAgbWluV29ya2Vyc1BlclRva2VuOiBwb29sLm1pbldvcmtlcnNQZXJUb2tlbixcbiAgICAgICAgbWF4V29ya2Vyc1BlclRva2VuOiBwb29sLm1heFdvcmtlcnNQZXJUb2tlbixcbiAgICAgICAgYXV0b3NjYWxlOiBwb29sLmF1dG9zY2FsZSxcbiAgICAgIH0sXG4gICAgfTtcbiAgfVxufVxuXG4vLyBkaXNwYXRjaGVyIOuvuOy0iOq4sO2ZlCjrtoDtjIUg7KeB7ZuEKSDsi5wgMCDsnLzroZwg7J2R64u17ZWc64ukIOKAlCDqsIDrsrzsmrQg7Iqk64OF7IO37J206528IOyYpOulmOuhnCDrp4zrk6Tsp4Ag7JWK64qU64ukLlxuZnVuY3Rpb24gY3VycmVudFZpdGFscygpOiBNb25pdFZpdGFscyB7XG4gIHJldHVybiB7XG4gICAgb3BlbmFpV29ya2VyQ291bnQ6IFFncmlkRGlzcGF0Y2hlci5vcGVuYWlEaXNwYXRjaGVyPy53b3JrZXJDb3VudCA/PyAwLFxuICAgIG9wZW5haVJlYWR5V29ya2VyQ291bnQ6IFFncmlkRGlzcGF0Y2hlci5vcGVuYWlEaXNwYXRjaGVyPy5yZWFkeVdvcmtlckNvdW50ID8/IDAsXG4gICAgb3BlbmFpUXVldWVMZW5ndGg6IFFncmlkRGlzcGF0Y2hlci5vcGVuYWlEaXNwYXRjaGVyPy5xdWV1ZUxlbmd0aCA/PyAwLFxuICAgIG9wZW5haVdvcmtlcnNCeVRva2VuOiBRZ3JpZERpc3BhdGNoZXIub3BlbmFpRGlzcGF0Y2hlcj8ud29ya2VyQ291bnRzQnlUb2tlbiA/PyBbXSxcbiAgICBhbnRocm9waWNUb2tlbkNvdW50OiBRZ3JpZERpc3BhdGNoZXIuYW50aHJvcGljRGlzcGF0Y2hlcj8udG9rZW5Db3VudCA/PyAwLFxuICAgIGFudGhyb3BpY1Rva2VuTmFtZXM6IFFncmlkRGlzcGF0Y2hlci5hbnRocm9waWNEaXNwYXRjaGVyPy50b2tlbk5hbWVzID8/IFtdLFxuICB9O1xufVxuXG4vLyDsi6TsoJwg7Zmc7ISxIGtuZXgg7Jew6rKw7JeQ7IScIOydveuKlOuLpCDigJQgZGV2IOyEnOuyhOydmCDthrXtlakg7YWM7Iqk7Yq4IOufrOuEiOqwgCBwcm9jZXNzLmVudi5TT05BTVVfREJfTkFNRSDsnYRcbi8vIO2FjOyKpO2KuCBEQiDsnbTrpoTsnLzroZwg642u7Ja07JOw66+A66GcIGVudiDripQg7Iug66Kw7ZWgIOyImCDsl4bri6QuIERCIOuvuOy0iOq4sO2ZlCjrtoDtjIUg7KCEKSDsi5zsl5Drp4wgZW52IO2PtOuwsS5cbmZ1bmN0aW9uIGFjdGl2ZURiQ29ubmVjdGlvbigpOiB7IGhvc3Q/OiBzdHJpbmc7IGRhdGFiYXNlPzogc3RyaW5nIH0ge1xuICB0cnkge1xuICAgIGNvbnN0IGNvbm5lY3Rpb24gPSBEQi5nZXREQkNvbmZpZyhcIndcIikuY29ubmVjdGlvbjtcbiAgICBpZiAodHlwZW9mIGNvbm5lY3Rpb24gPT09IFwib2JqZWN0XCIgJiYgY29ubmVjdGlvbiAhPT0gbnVsbCkge1xuICAgICAgcmV0dXJuIGNvbm5lY3Rpb24gYXMgeyBob3N0Pzogc3RyaW5nOyBkYXRhYmFzZT86IHN0cmluZyB9O1xuICAgIH1cbiAgfSBjYXRjaCB7XG4gICAgLy8gREIgY29uZmlnIOuvuOy0iOq4sO2ZlCDigJQgZW52IO2PtOuwseycvOuhnCDsp4TtlolcbiAgfVxuICByZXR1cm4geyBob3N0OiBwcm9jZXNzLmVudi5TT05BTVVfREJfSE9TVCwgZGF0YWJhc2U6IHByb2Nlc3MuZW52LlNPTkFNVV9EQl9OQU1FIH07XG59XG5cbmV4cG9ydCBjb25zdCBNb25pdEZyYW1lID0gbmV3IE1vbml0RnJhbWVDbGFzcygpO1xuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7O0FBY0EsTUFBTSx1QkFBdUI7QUFFN0IsSUFBTSxrQkFBTixjQUE4QixlQUFlO0NBQzNDLGNBQWM7RUFDWixNQUFNLE9BQU87Q0FDZjtDQUVBLE1BQ00sVUFBVSxRQUF5QztFQUN2RCxPQUFPO0dBQ0wsa0JBQWtCLGVBQWU7R0FDakMsR0FBRyxlQUFlLE1BQU0sUUFBUSxvQkFBb0I7R0FDcEQsUUFBUSxjQUFjO0VBQ3hCO0NBQ0Y7Q0FHQSxNQUNNLFlBQXNDO0VBQzFDLE1BQU0sT0FBTyw4QkFBOEI7RUFDM0MsTUFBTSxPQUFPLFFBQVEsSUFBSSxRQUFRO0VBQ2pDLE1BQU0sT0FBTyxRQUFRLElBQUksUUFBUTtFQUNqQyxNQUFNLE9BQU8sbUJBQW1CO0VBQ2hDLE9BQU87R0FDTCxXQUFXLFVBQVUsS0FBSyxHQUFHO0dBQzdCLFFBQVEsS0FBSyxRQUFRO0dBQ3JCLFFBQVEsS0FBSyxZQUFZO0dBQ3pCLFFBQVE7SUFDTixvQkFBb0IsS0FBSztJQUN6QixvQkFBb0IsS0FBSztJQUN6QixXQUFXLEtBQUs7R0FDbEI7RUFDRjtDQUNGO0FBQ0Y7O0NBM0JHLElBQUk7RUFBRSxZQUFZO0VBQU8sU0FBUyxDQUFDLFNBQVMsZ0JBQWdCO0NBQUUsQ0FBQzs7Ozs7O0NBVS9ELElBQUk7RUFBRSxZQUFZO0VBQU8sU0FBUyxDQUFDLFNBQVMsZ0JBQWdCO0NBQUUsQ0FBQzs7Ozs7QUFvQmxFLFNBQVMsZ0JBQTZCO0NBQ3BDLE9BQU87RUFDTCxtQkFBbUIsZ0JBQWdCLGtCQUFrQixlQUFlO0VBQ3BFLHdCQUF3QixnQkFBZ0Isa0JBQWtCLG9CQUFvQjtFQUM5RSxtQkFBbUIsZ0JBQWdCLGtCQUFrQixlQUFlO0VBQ3BFLHNCQUFzQixnQkFBZ0Isa0JBQWtCLHVCQUF1QixDQUFDO0VBQ2hGLHFCQUFxQixnQkFBZ0IscUJBQXFCLGNBQWM7RUFDeEUscUJBQXFCLGdCQUFnQixxQkFBcUIsY0FBYyxDQUFDO0NBQzNFO0FBQ0Y7QUFJQSxTQUFTLHFCQUEyRDtDQUNsRSxJQUFJO0VBQ0YsTUFBTSxhQUFhLEdBQUcsWUFBWSxHQUFHLENBQUMsQ0FBQztFQUN2QyxJQUFJLE9BQU8sZUFBZSxZQUFZLGVBQWUsTUFDbkQsT0FBTztDQUVYLFFBQVEsQ0FFUjtDQUNBLE9BQU87RUFBRSxNQUFNLFFBQVEsSUFBSTtFQUFnQixVQUFVLFFBQVEsSUFBSTtDQUFlO0FBQ2xGO0FBRUEsTUFBYSxhQUFhLElBQUksZ0JBQWdCIn0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -1,5 +1,5 @@
-import { getLogger } from "@logtape/logtape";
 import { createHash, randomBytes } from "node:crypto";
+import { getLogger } from "@logtape/logtape";
 //#region src/application/qgrid/oauth.ts
 /**
 * OAuth 유틸 — Claude Code 소스의 OAuth 플로우 그대로 재현

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

@@ -1,9 +1,11 @@
-import { ProcessError, QuotaError, maskToken } from "./qgrid.types.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 { applyToolCallEmulation, buildToolCallSchema } from "./tool-emulation.js";
+import { ProcessError, QuotaError, maskToken } from "./qgrid.types.js";
+import { applyToolCallEmulation } from "./tool-emulation.js";
+import { buildToolCallSchema } from "./tool-emulation-schema.js";
 //#region src/application/qgrid/qgrid.dispatcher.ts
 var QgridDispatcherClass = class {
 	tokens = /* @__PURE__ */ new Map();
@@ -31,10 +33,10 @@ var QgridDispatcherClass = class {
 			requests: this.countOf(r.name)
 		}));
 	}
-	async query(input, timeoutMs) {
-		if (input.tools?.length && input.jsonSchema) throw new ProcessError("tools and jsonSchema cannot be used together");
+	async query(input, abortSignal) {
 		const route = parseProviderRoute(input.model);
-		const outputSchema = buildStrictOutputSchema(input);
+		const outputSchema = buildAndValidateStrictOutputSchema(input, route.provider);
+		const answerMode = input.jsonSchema ? "structured" : "legacy";
 		if (route.provider === "openai") {
 			if (!this.openaiDispatcher) throw new QuotaError("OpenAI dispatcher not initialized");
 			const decision = decideConvRouting(input);
@@ -50,11 +52,16 @@ var QgridDispatcherClass = class {
 				coldHistory: decision.coldHistory,
 				reuse: decision.reuse,
 				reuseInput: decision.reuseInput,
+				abortSignal,
 				imageGeneration: input.imageGeneration,
 				imageGenerationOptions: input.imageGenerationOptions
 			});
 			const coord = input.imageGeneration ? void 0 : issueConvContext(result.threadCoord, decision);
-			return applyToolCallEmulation(toEmulationResult(result), input.tools, coord, result.images);
+			return applyToolCallEmulation(toEmulationResult(result), input.tools, {
+				threadCoord: coord,
+				images: result.images,
+				answerMode
+			});
 		} else if (route.provider === "anthropic") {
 			if (!this.anthropicDispatcher) throw new QuotaError("Anthropic dispatcher not initialized");
 			const decision = decideConvRouting(input);
@@ -63,18 +70,24 @@ var QgridDispatcherClass = class {
 				systemPrompt: input.system,
 				outputSchema,
 				effort: input.effort,
+				timeoutMs: input.timeout,
+				abortSignal,
 				coldInput: decision.coldInput,
 				coldHistory: decision.coldHistory,
 				imageGeneration: input.imageGeneration,
 				imageGenerationOptions: input.imageGenerationOptions
 			});
-			return applyToolCallEmulation(toEmulationResult(result), input.tools, issueConvContext(result.threadCoord, decision));
+			return applyToolCallEmulation(toEmulationResult(result), input.tools, {
+				threadCoord: issueConvContext(result.threadCoord, decision),
+				answerMode
+			});
 		}
 		throw directLlmApiFallbackNotImplemented(input);
 	}
 	async queryStream(input, cb, abortSignal) {
 		const route = parseProviderRoute(input.model);
-		const outputSchema = buildStrictOutputSchema(input);
+		const outputSchema = buildAndValidateStrictOutputSchema(input, route.provider);
+		const answerMode = input.jsonSchema ? "structured" : "legacy";
 		if (route.provider === "openai") {
 			if (!this.openaiDispatcher) throw new QuotaError("OpenAI dispatcher not initialized");
 			const decision = decideConvRouting(input);
@@ -98,7 +111,10 @@ var QgridDispatcherClass = class {
 				onThreadId: cb.onThreadId,
 				onTurnId: cb.onTurnId,
 				onComplete: (turnResult) => {
-					cb.onComplete(applyToolCallEmulation(toEmulationResult(turnResult), input.tools, issueConvContext(turnResult.threadCoord, decision)));
+					cb.onComplete(applyToolCallEmulation(toEmulationResult(turnResult), input.tools, {
+						threadCoord: issueConvContext(turnResult.threadCoord, decision),
+						answerMode
+					}));
 				},
 				onError: cb.onError
 			});
@@ -113,6 +129,7 @@ var QgridDispatcherClass = class {
 				effort: input.effort,
 				coldInput: decision.coldInput,
 				coldHistory: decision.coldHistory,
+				timeoutMs: input.timeout,
 				abortSignal,
 				imageGeneration: input.imageGeneration,
 				imageGenerationOptions: input.imageGenerationOptions
@@ -121,7 +138,10 @@ var QgridDispatcherClass = class {
 				onThreadId: cb.onThreadId,
 				onComplete: (turnResult) => {
 					const issuedCoord = issueConvContext(turnResult.threadCoord, decision);
-					cb.onComplete(applyToolCallEmulation(toEmulationResult(turnResult), input.tools, issuedCoord));
+					cb.onComplete(applyToolCallEmulation(toEmulationResult(turnResult), input.tools, {
+						threadCoord: issuedCoord,
+						answerMode
+					}));
 				},
 				onError: cb.onError
 			});
@@ -142,12 +162,18 @@ function parseProviderRoute(model) {
 function directLlmApiFallbackNotImplemented(input) {
 	return new ProcessError(`Direct LLM API fallback not implemented for model: ${input.model ?? "<default>"}`);
 }
-function buildStrictOutputSchema(input) {
+function buildStrictOutputSchema(input, provider) {
 	const outputSchema = buildRawOutputSchema(input);
-	return outputSchema ? strictify(outputSchema) : void 0;
+	return outputSchema ? strictify(outputSchema, { provider }) : void 0;
+}
+function buildAndValidateStrictOutputSchema(input, provider = parseProviderRoute(input.model).provider) {
+	const outputSchema = buildStrictOutputSchema(input, provider);
+	serializeAndValidateDispatchSchema(outputSchema, provider);
+	return outputSchema;
 }
 function buildRawOutputSchema(input) {
-	return input.tools?.length ? buildToolCallSchema(input.tools) : input.jsonSchema ? JSON.parse(input.jsonSchema) : void 0;
+	const callerOutputSchema = parseAndValidateCallerSchemas(input);
+	return input.tools?.length ? buildToolCallSchema(input.tools, callerOutputSchema) : callerOutputSchema;
 }
 function toEmulationResult(result) {
 	const hasProviderCost = result.costUsd !== void 0 && result.costUsd > 0;
@@ -180,6 +206,6 @@ function toEmulationResult(result) {
 }
 const QgridDispatcher = new QgridDispatcherClass();
 //#endregion
-export { QgridDispatcher, QgridDispatcherClass, buildStrictOutputSchema };
+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 { strictify } from \"../../utils/providers/common/strictifier\";\nimport { type OpenAIDispatcher } from \"../../utils/providers/openai/openai-dispatcher\";\nimport { type TokenSubsetA } from \"../sonamu.generated\";\nimport { decideConvRouting, issueConvContext } from \"./conv-routing\";\nimport { type QueryInput, type QueryOutput, type TokenStats } from \"./qgrid.types\";\nimport { maskToken, ProcessError, QuotaError } from \"./qgrid.types\";\nimport { type TokenSubscriber } from \"./token-subscriber\";\nimport { applyToolCallEmulation, buildToolCallSchema } from \"./tool-emulation\";\n\nexport class QgridDispatcherClass {\n  tokens = new Map<number, TokenSubsetA>();\n\n  // TokenStats shape 보존용. 실제 provider 요청 카운팅은 각 dispatcher 로 이동했다.\n  requestCounts = new Map<string, number>();\n\n  // sonamu.config onStart 에서 처리하는 변수\n  subscriber: TokenSubscriber | null = null;\n  openaiDispatcher: OpenAIDispatcher | null = null;\n  anthropicDispatcher: AnthropicDispatcher | null = null;\n\n  countOf(name: string): number {\n    return this.requestCounts.get(name) ?? 0;\n  }\n\n  // TokenSubscriber 콜백 — 캐시 mutation\n  upsertCache(id: number, row: TokenSubsetA): void {\n    this.tokens.set(id, row);\n  }\n\n  removeCache(id: number): void {\n    this.tokens.delete(id);\n  }\n\n  replaceCache(rows: TokenSubsetA[]): void {\n    this.tokens = new Map(rows.map((r) => [r.id, r]));\n  }\n\n  getStats(): TokenStats[] {\n    return [...this.tokens.values()].map((r) => ({\n      token: maskToken(getAccessToken(r.credentials)),\n      name: r.name,\n      provider: r.provider,\n      requests: this.countOf(r.name),\n    }));\n  }\n\n  async query(input: QueryInput, timeoutMs?: number): Promise<QueryOutput> {\n    void timeoutMs;\n\n    if (input.tools?.length && input.jsonSchema) {\n      throw new ProcessError(\"tools and jsonSchema cannot be used together\");\n    }\n\n    const route = parseProviderRoute(input.model);\n    const outputSchema = buildStrictOutputSchema(input);\n\n    // provider prefix routing: 'openai/gpt-5.4' → OpenAIDispatcher\n    if (route.provider === \"openai\") {\n      if (!this.openaiDispatcher) throw new QuotaError(\"OpenAI dispatcher not initialized\");\n\n      const decision = decideConvRouting(input);\n      const result = await this.openaiDispatcher.generate({\n        model: route.model,\n        systemPrompt: input.system,\n        outputSchema,\n        effort: input.effort,\n        verbosity: input.verbosity,\n        reasoningSummary: input.reasoningSummary,\n        serviceTier: input.serviceTier,\n        coldInput: decision.coldInput,\n        coldHistory: decision.coldHistory,\n        reuse: decision.reuse,\n        reuseInput: decision.reuseInput,\n        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, coord, result.images);\n    } else if (route.provider === \"anthropic\") {\n      if (!this.anthropicDispatcher) throw new QuotaError(\"Anthropic dispatcher not initialized\");\n\n      const decision = decideConvRouting(input);\n      const result = await this.anthropicDispatcher.generate({\n        // AnthropicDispatcher 내부에서 알아서 provider prefix 를 canonical model 로 정규화함\n        model: input.model,\n        systemPrompt: input.system,\n        outputSchema,\n        effort: input.effort,\n        coldInput: decision.coldInput,\n        coldHistory: decision.coldHistory,\n        imageGeneration: input.imageGeneration,\n        imageGenerationOptions: input.imageGenerationOptions,\n      });\n\n      return applyToolCallEmulation(\n        toEmulationResult(result),\n        input.tools,\n        issueConvContext(result.threadCoord, decision),\n      );\n    }\n\n    throw directLlmApiFallbackNotImplemented(input);\n  }\n\n  async queryStream(\n    input: QueryInput,\n    cb: StreamCallbacks<QueryOutput>,\n    abortSignal?: AbortSignal,\n  ): Promise<void> {\n    const route = parseProviderRoute(input.model);\n    const outputSchema = buildStrictOutputSchema(input);\n\n    if (route.provider === \"openai\") {\n      if (!this.openaiDispatcher) throw new QuotaError(\"OpenAI dispatcher not initialized\");\n\n      const decision = decideConvRouting(input);\n      await this.openaiDispatcher.generateStream(\n        {\n          model: route.model,\n          systemPrompt: input.system,\n          outputSchema,\n          effort: input.effort,\n          verbosity: input.verbosity,\n          reasoningSummary: input.reasoningSummary,\n          serviceTier: input.serviceTier,\n          coldInput: decision.coldInput,\n          coldHistory: decision.coldHistory,\n          reuse: decision.reuse,\n          reuseInput: decision.reuseInput,\n          abortSignal,\n          // 이미지 플래그를 전달해야 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(\n                toEmulationResult(turnResult),\n                input.tools,\n                issueConvContext(turnResult.threadCoord, decision),\n              ),\n            );\n          },\n          onError: cb.onError,\n        },\n      );\n      return;\n    } else if (route.provider === \"anthropic\") {\n      if (!this.anthropicDispatcher) throw new QuotaError(\"Anthropic dispatcher not initialized\");\n\n      const decision = decideConvRouting(input);\n      await this.anthropicDispatcher.generateStream(\n        {\n          model: input.model,\n          systemPrompt: input.system,\n          outputSchema,\n          effort: input.effort,\n          coldInput: decision.coldInput,\n          coldHistory: decision.coldHistory,\n          abortSignal,\n          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, issuedCoord),\n            );\n          },\n          onError: cb.onError,\n        },\n      );\n      return;\n    }\n\n    throw directLlmApiFallbackNotImplemented(input);\n  }\n}\n\nfunction parseProviderRoute(model: string | undefined): { provider?: string; model: string } {\n  if (!model?.includes(\"/\")) {\n    return { model: model ?? \"\" };\n  }\n\n  const [provider, routedModel] = model.split(\"/\", 2);\n  if (!provider || !routedModel) throw new ProcessError(\"unknown model\");\n  return { provider, model: routedModel };\n}\n\n// qgrid provider dispatcher 에서 처리하지 않는 모델은 향후 직접 LLM API 호출 지점으로 보낸다.\nfunction directLlmApiFallbackNotImplemented(input: QueryInput): ProcessError {\n  return new ProcessError(\n    `Direct LLM API fallback not implemented for model: ${input.model ?? \"<default>\"}`,\n  );\n}\n\n// 모든 provider(OpenAI/Anthropic)가 동일하게 strict output schema 를 쓴다.\n//\n// SON-495 교훈: 한때 Anthropic route 만 required 를 제거(optionalize)해 partial/rejected attempt 가\n// 섞여도 통과하게 했으나, 실측 결과 그게 오히려 \"모델이 비는 필드를 키째 생략\"하도록 유도했다\n// (required 살린 schema 는 누락 0, loose 는 누락 다발). strict 로 두면 모델이 빠짐없이 채우고,\n// 드물게 어겨도 retry=1 + 비정상 종료는 정직한 에러(stream-json-adapter)로 받아준다.\nexport function buildStrictOutputSchema(\n  input: Pick<QueryInput, \"tools\" | \"jsonSchema\">,\n): JsonValue | undefined {\n  const outputSchema = buildRawOutputSchema(input);\n\n  return outputSchema\n    ? (strictify(outputSchema as Parameters<typeof strictify>[0]) as JsonValue)\n    : undefined;\n}\n\nfunction buildRawOutputSchema(\n  input: Pick<QueryInput, \"tools\" | \"jsonSchema\">,\n): JsonValue | undefined {\n  return input.tools?.length\n    ? buildToolCallSchema(input.tools)\n    : input.jsonSchema\n      ? (JSON.parse(input.jsonSchema) as JsonValue)\n      : undefined;\n}\n\n// GenerateResult(provider dispatcher 응답)를 applyToolCallEmulation 입력 shape 로 매핑한다.\n// OpenAI/Anthropic, query/queryStream 4 경로가 동일하게 쓴다.\n// Anthropic adapter 는 cache creation 을 inputTokens 에 포함해 표준화하고, 별도 필드에도 보존한다.\n// per-request cost 는 provider 가 준 값을 우선 사용하고, 없으면 공통 cost 함수를 쓴다.\nfunction toEmulationResult(\n  result: GenerateResult,\n): Omit<QueryOutput, \"content\" | \"finishReason\" | \"runContext\"> {\n  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 */\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    // tools+jsonSchema 합성 시 structured envelope 디코더를 쓴다. 4개 방출 지점이 공유하는 단일 판정.\n    const answerMode = input.jsonSchema ? (\"structured\" as const) : (\"legacy\" 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        answerMode,\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        answerMode,\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    // tools+jsonSchema 합성 시 structured envelope 디코더를 쓴다. 4개 방출 지점이 공유하는 단일 판정.\n    const answerMode = input.jsonSchema ? (\"structured\" as const) : (\"legacy\" 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                answerMode,\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                answerMode,\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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"}