@cartanova/qgrid-cli 2.7.0 → 2.7.2

package/README.ko.md

@@ -106,7 +106,6 @@ CLI는 실행 시 npm의 최신 버전을 확인하고 patch를 포함해 설치
 - Node.js >= 20
 - PostgreSQL
 - Docker (로컬 PostgreSQL을 컨테이너로 실행할 경우)
-- [Codex CLI](https://github.com/openai/codex) (OpenAI 모델 사용 시)
 - [Claude Code](https://www.anthropic.com/claude-code) (Anthropic 모델 사용 시)
 
 ## 동작 방식
@@ -116,12 +115,14 @@ CLI는 Sonamu 기반 서버를 내장 번들로 포함. 실행 시:
 1. DB 연결 확인
 2. 서버 시작 (API + 대시보드 웹 UI)
 3. DB의 등록된 토큰 로드. 이후 토큰 등록/변경은 PostgreSQL LISTEN/NOTIFY로 실행 중인 서버에 실시간 반영
-4. **OpenAI 토큰**: persistent codex app-server worker pool과 JSON-RPC로 통신. Qgrid가 capacity, queue, thread retention을 내부적으로 관리. `sessionKey` 멀티턴 요청은 같은 thread로 재라우팅되어 prompt cache 적중
+4. **OpenAI 토큰**: `https://chatgpt.com/backend-api/codex/responses`를 HTTPS로 직접 호출하고 SSE를 해석합니다. 토큰 단위 concurrent permit에 smooth weighted routing을 적용하며, 50개 queue는 최대 60초 대기합니다. 전체 history를 재전송하고 `sessionKey`에서 파생한 불투명 prompt-cache affinity를 사용하며, `AbortSignal`로 queue와 실행 중 요청을 취소합니다
 5. **Anthropic 토큰**: 요청마다 격리된 claude 프로세스를 fresh spawn (`stream-json` 입출력). 토큰은 least-used 우선으로 선택. OAuth 토큰 자동 refresh
 6. 토큰별 quota threshold(기본 80%)를 넘은 토큰은 라우팅에서 제외 (사용률 조회 실패 시에는 fail-open으로 통과)
 
 Qgrid 앱 자체는 Docker에 의존하지 않지만 PostgreSQL은 필요함. 로컬 PostgreSQL이 없으면 Docker로 PostgreSQL을 띄우는 구성이 가장 간단함.
 
+OpenAI 로그인은 direct PKCE OAuth를 사용하고 quota는 Codex CLI identity header와 함께 private `wham/usage` endpoint를 직접 조회합니다. 이 ChatGPT backend interface는 문서화되지 않아 예고 없이 바뀔 수 있습니다. Mock test는 live provider 호환성을 입증하지 않습니다.
+
 ## SDK 연동
 
 서버를 띄운 뒤 [`@cartanova/qgrid-ai-sdk`](../ai-sdk/README.ko.md)로 호출:

package/README.md

@@ -107,7 +107,6 @@ Server behavior variables:
 - Node.js >= 20
 - PostgreSQL
 - Docker (if running PostgreSQL locally as a container)
-- [Codex CLI](https://github.com/openai/codex) (for OpenAI models)
 - [Claude Code](https://www.anthropic.com/claude-code) (for Anthropic models)
 
 ## How it works
@@ -117,12 +116,14 @@ 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**: use a persistent codex app-server worker pool over JSON-RPC. Qgrid manages capacity, queueing, and thread retention internally. Multi-turn requests carrying a `sessionKey` are routed back to the same thread for prompt-cache hits
+4. **OpenAI tokens**: call `https://chatgpt.com/backend-api/codex/responses` directly over HTTPS and decode SSE. Token-level concurrent permits use smooth weighted routing; a 50-item queue waits at most 60 seconds. Full history is replayed with opaque `sessionKey`-derived prompt-cache affinity, and `AbortSignal` cancels queued or active work
 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)
 
 The Qgrid app itself does not depend on Docker, but PostgreSQL is required. If you don't run PostgreSQL locally, running it in Docker is the simplest setup.
 
+OpenAI login uses direct PKCE OAuth, and quota checks call the private `wham/usage` endpoint directly with Codex CLI identity headers. These ChatGPT backend interfaces are undocumented and may change without notice. Mocked tests do not establish live-provider compatibility.
+
 ## SDK integration
 
 Once the server is running, call it with [`@cartanova/qgrid-ai-sdk`](../ai-sdk/README.md):

package/bundle/dist/_virtual/_rolldown/runtime.js

@@ -1,5 +1,10 @@
 //#region \0rolldown/runtime.js
+var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -10,5 +15,19 @@ var __exportAll = (all, no_symbols) => {
 	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
 	return target;
 };
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
 //#endregion
-export { __commonJSMin, __exportAll };
+export { __commonJSMin, __exportAll, __toESM };

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

@@ -1,8 +1,9 @@
 import { monitLogBuffer } from "./log-buffer.js";
+import { resolveOpenAITransportKind } from "../../utils/providers/openai/openai-transport-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-worker-pool-config.js";
-import { QgridDispatcher } from "../qgrid/qgrid.dispatcher.js";
+import { RequestLogModel } from "../request-log/request-log.model.js";
 import { BaseFrameClass, DB, api } from "sonamu";
 //#region src/application/monit/monit.frame.ts
 /**
@@ -24,7 +25,7 @@ var MonitFrameClass = class extends BaseFrameClass {
 		};
 	}
 	async monitInfo() {
-		const pool = resolveOpenAIWorkerPoolConfig();
+		const transport = resolveOpenAITransportKind();
 		const host = process.env.HOST ?? "localhost";
 		const port = process.env.PORT ?? "44900";
 		const conn = activeDbConnection();
@@ -32,11 +33,15 @@ var MonitFrameClass = class extends BaseFrameClass {
 			serverUrl: `http://${host}:${port}`,
 			dbHost: conn.host ?? "localhost",
 			dbName: conn.database ?? "qgrid",
-			openai: {
-				minWorkersPerToken: pool.minWorkersPerToken,
-				maxWorkersPerToken: pool.maxWorkersPerToken,
-				autoscale: pool.autoscale
-			}
+			openai: { transport }
+		};
+	}
+	async monitStats() {
+		const windowMinutes = 60;
+		const since = /* @__PURE__ */ new Date(Date.now() - windowMinutes * 6e4);
+		return {
+			windowMinutes,
+			providers: await RequestLogModel.providerStatsSince(since)
 		};
 	}
 };
@@ -58,14 +63,22 @@ __decorate([
 	__decorateMetadata("design:paramtypes", []),
 	__decorateMetadata("design:returntype", Promise)
 ], MonitFrameClass.prototype, "monitInfo", null);
+__decorate([
+	api({
+		httpMethod: "GET",
+		clients: ["axios", "tanstack-query"]
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", []),
+	__decorateMetadata("design:returntype", Promise)
+], MonitFrameClass.prototype, "monitStats", null);
 function currentVitals() {
 	return {
-		openaiWorkerCount: QgridDispatcher.openaiDispatcher?.workerCount ?? 0,
-		openaiReadyWorkerCount: QgridDispatcher.openaiDispatcher?.readyWorkerCount ?? 0,
-		openaiQueueLength: QgridDispatcher.openaiDispatcher?.queueLength ?? 0,
-		openaiWorkersByToken: QgridDispatcher.openaiDispatcher?.workerCountsByToken ?? [],
+		openaiInFlight: QgridDispatcher.openaiDispatcher?.inFlight ?? 0,
+		openaiQuotaByToken: QgridDispatcher.openaiDispatcher?.quotaByToken ?? [],
 		anthropicTokenCount: QgridDispatcher.anthropicDispatcher?.tokenCount ?? 0,
-		anthropicTokenNames: QgridDispatcher.anthropicDispatcher?.tokenNames ?? []
+		anthropicTokenNames: QgridDispatcher.anthropicDispatcher?.tokenNames ?? [],
+		anthropicInFlight: QgridDispatcher.anthropicDispatcher?.inFlight ?? 0
 	};
 }
 function activeDbConnection() {
@@ -82,4 +95,4 @@ const MonitFrame = new MonitFrameClass();
 //#endregion
 export { MonitFrame };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9uaXQuZnJhbWUuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FwcGxpY2F0aW9uL21vbml0L21vbml0LmZyYW1lLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogTW9uaXQg4oCUIOuMgOyLnOuztOuTnCBNb25pdCDtg63smqkg7ZSE66Gc7IS47IqkIOuhnOq3uCDqtIDsuKEgQVBJLlxuICpcbiAqIOydveq4sCDsoITsmqkuIHJpbmcgYnVmZmVyIOulvCDslofqsowg7KeB7KCRIOydveycvOupsCjrspTsmqkg7L+866asIOq4sOqzhCDsl4bsnbQpLFxuICogcmVxdWVzdCBsb2cg66W8IOuCqOq4sOyngCDslYrripTri6QuIOygkeq3vCDqsr3qs4TripQg64uk66W4IOuMgOyLnOuztOuTnCBBUEkg7JmAIOuPmeydvO2VmOuLpC5cbiAqL1xuaW1wb3J0IHsgYXBpLCBCYXNlRnJhbWVDbGFzcywgREIgfSBmcm9tIFwic29uYW11XCI7XG5cbmltcG9ydCB7IHJlc29sdmVPcGVuQUlUcmFuc3BvcnRLaW5kIH0gZnJvbSBcIi4uLy4uL3V0aWxzL3Byb3ZpZGVycy9vcGVuYWkvb3BlbmFpLXRyYW5zcG9ydC1jb25maWdcIjtcbmltcG9ydCB7IFFncmlkRGlzcGF0Y2hlciB9IGZyb20gXCIuLi9xZ3JpZC9xZ3JpZC5kaXNwYXRjaGVyXCI7XG5pbXBvcnQgeyBSZXF1ZXN0TG9nTW9kZWwgfSBmcm9tIFwiLi4vcmVxdWVzdC1sb2cvcmVxdWVzdC1sb2cubW9kZWxcIjtcbmltcG9ydCB7IG1vbml0TG9nQnVmZmVyIH0gZnJvbSBcIi4vbG9nLWJ1ZmZlclwiO1xuaW1wb3J0IHtcbiAgdHlwZSBNb25pdExvZ0NodW5rLFxuICB0eXBlIE1vbml0U2VydmVySW5mbyxcbiAgdHlwZSBNb25pdFN0YXRzLFxuICB0eXBlIE1vbml0Vml0YWxzLFxufSBmcm9tIFwiLi9tb25pdC50eXBlc1wiO1xuXG4vLyDsnZHri7Xri7kg7JeU7Yq466asIOyDge2VnCDigJQg7Y+066eBIO2BtOudvOydtOyWuO2KuOuKlCDri6TsnYwg7Y+07JeQ7IScIOydtOyWtOyEnCDrlLDrnbzsnqHripTri6QuXG5jb25zdCBSRVNQT05TRV9FTlRSWV9MSU1JVCA9IDFfMDAwO1xuXG5jbGFzcyBNb25pdEZyYW1lQ2xhc3MgZXh0ZW5kcyBCYXNlRnJhbWVDbGFzcyB7XG4gIGNvbnN0cnVjdG9yKCkge1xuICAgIHN1cGVyKFwiTW9uaXRcIik7XG4gIH1cblxuICBAYXBpKHsgaHR0cE1ldGhvZDogXCJHRVRcIiwgY2xpZW50czogW1wiYXhpb3NcIiwgXCJ0YW5zdGFjay1xdWVyeVwiXSB9KVxuICBhc3luYyBtb25pdExvZ3MoY3Vyc29yPzogbnVtYmVyKTogUHJvbWlzZTxNb25pdExvZ0NodW5rPiB7XG4gICAgcmV0dXJuIHtcbiAgICAgIHByb2Nlc3NTdGFydGVkQXQ6IG1vbml0TG9nQnVmZmVyLnByb2Nlc3NTdGFydGVkQXQsXG4gICAgICAuLi5tb25pdExvZ0J1ZmZlci5hZnRlcihjdXJzb3IsIFJFU1BPTlNFX0VOVFJZX0xJTUlUKSxcbiAgICAgIHZpdGFsczogY3VycmVudFZpdGFscygpLFxuICAgIH07XG4gIH1cblxuICAvLyDtlITroZzshLjsiqQg7KCV7KCBIOygleuztCDigJQg7Y+066eBIOu2iO2VhOyalCwg7Y6Y7J207KeA64u5IDHtmowg7KGw7ZqMLlxuICBAYXBpKHsgaHR0cE1ldGhvZDogXCJHRVRcIiwgY2xpZW50czogW1wiYXhpb3NcIiwgXCJ0YW5zdGFjay1xdWVyeVwiXSB9KVxuICBhc3luYyBtb25pdEluZm8oKTogUHJvbWlzZTxNb25pdFNlcnZlckluZm8+IHtcbiAgICBjb25zdCB0cmFuc3BvcnQgPSByZXNvbHZlT3BlbkFJVHJhbnNwb3J0S2luZCgpO1xuICAgIGNvbnN0IGhvc3QgPSBwcm9jZXNzLmVudi5IT1NUID8/IFwibG9jYWxob3N0XCI7XG4gICAgY29uc3QgcG9ydCA9IHByb2Nlc3MuZW52LlBPUlQgPz8gXCI0NDkwMFwiO1xuICAgIGNvbnN0IGNvbm4gPSBhY3RpdmVEYkNvbm5lY3Rpb24oKTtcbiAgICByZXR1cm4ge1xuICAgICAgc2VydmVyVXJsOiBgaHR0cDovLyR7aG9zdH06JHtwb3J0fWAsXG4gICAgICBkYkhvc3Q6IGNvbm4uaG9zdCA/PyBcImxvY2FsaG9zdFwiLFxuICAgICAgZGJOYW1lOiBjb25uLmRhdGFiYXNlID8/IFwicWdyaWRcIixcbiAgICAgIG9wZW5haTogeyB0cmFuc3BvcnQgfSxcbiAgICB9O1xuICB9XG5cbiAgLy8g7LWc6re8IDHsi5zqsIQgcHJvdmlkZXIg67OEIOyalOyyrS/smKTrpZgv7LqQ7IucIO2GteqzhC4gdml0YWxzIOyZgCDri6zrpqwgcmVxdWVzdF9sb2dzIOulvCDtg4Drr4DroZxcbiAgLy8g67aE66as65CcIGVuZHBvaW50IOuhnCDrkZDqs6Ag7Ju57JeQ7IScIOuNlCDripDsiqjtlZwg7KO86riw66GcIO2PtOunge2VnOuLpC4g7J296riwIOyghOyaqeydtOupsCByZXF1ZXN0IGxvZyDrpbxcbiAgLy8g64Ko6riw7KeAIOyViuuKlCBtb25pdCDqsr3qs4TripQg64+Z7J287ZWY64ukLlxuICBAYXBpKHsgaHR0cE1ldGhvZDogXCJHRVRcIiwgY2xpZW50czogW1wiYXhpb3NcIiwgXCJ0YW5zdGFjay1xdWVyeVwiXSB9KVxuICBhc3luYyBtb25pdFN0YXRzKCk6IFByb21pc2U8TW9uaXRTdGF0cz4ge1xuICAgIGNvbnN0IHdpbmRvd01pbnV0ZXMgPSA2MDtcbiAgICBjb25zdCBzaW5jZSA9IG5ldyBEYXRlKERhdGUubm93KCkgLSB3aW5kb3dNaW51dGVzICogNjBfMDAwKTtcbiAgICByZXR1cm4geyB3aW5kb3dNaW51dGVzLCBwcm92aWRlcnM6IGF3YWl0IFJlcXVlc3RMb2dNb2RlbC5wcm92aWRlclN0YXRzU2luY2Uoc2luY2UpIH07XG4gIH1cbn1cblxuLy8gZGlzcGF0Y2hlciDrr7jstIjquLDtmZQo67aA7YyFIOynge2bhCkg7IucIDAg7Jy866GcIOydkeuLte2VnOuLpCDigJQg6rCA67K87Jq0IOyKpOuDheyDt+ydtOudvCDsmKTrpZjroZwg66eM65Ok7KeAIOyViuuKlOuLpC5cbmZ1bmN0aW9uIGN1cnJlbnRWaXRhbHMoKTogTW9uaXRWaXRhbHMge1xuICByZXR1cm4ge1xuICAgIG9wZW5haUluRmxpZ2h0OiBRZ3JpZERpc3BhdGNoZXIub3BlbmFpRGlzcGF0Y2hlcj8uaW5GbGlnaHQgPz8gMCxcbiAgICBvcGVuYWlRdW90YUJ5VG9rZW46IFFncmlkRGlzcGF0Y2hlci5vcGVuYWlEaXNwYXRjaGVyPy5xdW90YUJ5VG9rZW4gPz8gW10sXG4gICAgYW50aHJvcGljVG9rZW5Db3VudDogUWdyaWREaXNwYXRjaGVyLmFudGhyb3BpY0Rpc3BhdGNoZXI/LnRva2VuQ291bnQgPz8gMCxcbiAgICBhbnRocm9waWNUb2tlbk5hbWVzOiBRZ3JpZERpc3BhdGNoZXIuYW50aHJvcGljRGlzcGF0Y2hlcj8udG9rZW5OYW1lcyA/PyBbXSxcbiAgICBhbnRocm9waWNJbkZsaWdodDogUWdyaWREaXNwYXRjaGVyLmFudGhyb3BpY0Rpc3BhdGNoZXI/LmluRmxpZ2h0ID8/IDAsXG4gIH07XG59XG5cbi8vIOyLpOygnCDtmZzshLEga25leCDsl7DqsrDsl5DshJwg7J2964qU64ukIOKAlCBkZXYg7ISc67KE7J2YIO2Gte2VqSDthYzsiqTtirgg65+s64SI6rCAIHByb2Nlc3MuZW52LlNPTkFNVV9EQl9OQU1FIOydhFxuLy8g7YWM7Iqk7Yq4IERCIOydtOumhOycvOuhnCDrja7slrTsk7Drr4DroZwgZW52IOuKlCDsi6DrorDtlaAg7IiYIOyXhuuLpC4gREIg66+47LSI6riw7ZmUKOu2gO2MhSDsoIQpIOyLnOyXkOunjCBlbnYg7Y+067CxLlxuZnVuY3Rpb24gYWN0aXZlRGJDb25uZWN0aW9uKCk6IHsgaG9zdD86IHN0cmluZzsgZGF0YWJhc2U/OiBzdHJpbmcgfSB7XG4gIHRyeSB7XG4gICAgY29uc3QgY29ubmVjdGlvbiA9IERCLmdldERCQ29uZmlnKFwid1wiKS5jb25uZWN0aW9uO1xuICAgIGlmICh0eXBlb2YgY29ubmVjdGlvbiA9PT0gXCJvYmplY3RcIiAmJiBjb25uZWN0aW9uICE9PSBudWxsKSB7XG4gICAgICByZXR1cm4gY29ubmVjdGlvbiBhcyB7IGhvc3Q/OiBzdHJpbmc7IGRhdGFiYXNlPzogc3RyaW5nIH07XG4gICAgfVxuICB9IGNhdGNoIHtcbiAgICAvLyBEQiBjb25maWcg66+47LSI6riw7ZmUIOKAlCBlbnYg7Y+067Cx7Jy866GcIOynhO2WiVxuICB9XG4gIHJldHVybiB7IGhvc3Q6IHByb2Nlc3MuZW52LlNPTkFNVV9EQl9IT1NULCBkYXRhYmFzZTogcHJvY2Vzcy5lbnYuU09OQU1VX0RCX05BTUUgfTtcbn1cblxuZXhwb3J0IGNvbnN0IE1vbml0RnJhbWUgPSBuZXcgTW9uaXRGcmFtZUNsYXNzKCk7XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7O0FBb0JBLE1BQU0sdUJBQXVCO0FBRTdCLElBQU0sa0JBQU4sY0FBOEIsZUFBZTtDQUMzQyxjQUFjO0VBQ1osTUFBTSxPQUFPO0NBQ2Y7Q0FFQSxNQUNNLFVBQVUsUUFBeUM7RUFDdkQsT0FBTztHQUNMLGtCQUFrQixlQUFlO0dBQ2pDLEdBQUcsZUFBZSxNQUFNLFFBQVEsb0JBQW9CO0dBQ3BELFFBQVEsY0FBYztFQUN4QjtDQUNGO0NBR0EsTUFDTSxZQUFzQztFQUMxQyxNQUFNLFlBQVksMkJBQTJCO0VBQzdDLE1BQU0sT0FBTyxRQUFRLElBQUksUUFBUTtFQUNqQyxNQUFNLE9BQU8sUUFBUSxJQUFJLFFBQVE7RUFDakMsTUFBTSxPQUFPLG1CQUFtQjtFQUNoQyxPQUFPO0dBQ0wsV0FBVyxVQUFVLEtBQUssR0FBRztHQUM3QixRQUFRLEtBQUssUUFBUTtHQUNyQixRQUFRLEtBQUssWUFBWTtHQUN6QixRQUFRLEVBQUUsVUFBVTtFQUN0QjtDQUNGO0NBS0EsTUFDTSxhQUFrQztFQUN0QyxNQUFNLGdCQUFnQjtFQUN0QixNQUFNLHdCQUFRLElBQUksS0FBSyxLQUFLLElBQUksSUFBSSxnQkFBZ0IsR0FBTTtFQUMxRCxPQUFPO0dBQUU7R0FBZSxXQUFXLE1BQU0sZ0JBQWdCLG1CQUFtQixLQUFLO0VBQUU7Q0FDckY7QUFDRjs7Q0FqQ0csSUFBSTtFQUFFLFlBQVk7RUFBTyxTQUFTLENBQUMsU0FBUyxnQkFBZ0I7Q0FBRSxDQUFDOzs7Ozs7Q0FVL0QsSUFBSTtFQUFFLFlBQVk7RUFBTyxTQUFTLENBQUMsU0FBUyxnQkFBZ0I7Q0FBRSxDQUFDOzs7Ozs7Q0FpQi9ELElBQUk7RUFBRSxZQUFZO0VBQU8sU0FBUyxDQUFDLFNBQVMsZ0JBQWdCO0NBQUUsQ0FBQzs7Ozs7QUFTbEUsU0FBUyxnQkFBNkI7Q0FDcEMsT0FBTztFQUNMLGdCQUFnQixnQkFBZ0Isa0JBQWtCLFlBQVk7RUFDOUQsb0JBQW9CLGdCQUFnQixrQkFBa0IsZ0JBQWdCLENBQUM7RUFDdkUscUJBQXFCLGdCQUFnQixxQkFBcUIsY0FBYztFQUN4RSxxQkFBcUIsZ0JBQWdCLHFCQUFxQixjQUFjLENBQUM7RUFDekUsbUJBQW1CLGdCQUFnQixxQkFBcUIsWUFBWTtDQUN0RTtBQUNGO0FBSUEsU0FBUyxxQkFBMkQ7Q0FDbEUsSUFBSTtFQUNGLE1BQU0sYUFBYSxHQUFHLFlBQVksR0FBRyxDQUFDLENBQUM7RUFDdkMsSUFBSSxPQUFPLGVBQWUsWUFBWSxlQUFlLE1BQ25ELE9BQU87Q0FFWCxRQUFRLENBRVI7Q0FDQSxPQUFPO0VBQUUsTUFBTSxRQUFRLElBQUk7RUFBZ0IsVUFBVSxRQUFRLElBQUk7Q0FBZTtBQUNsRjtBQUVBLE1BQWEsYUFBYSxJQUFJLGdCQUFnQiJ9

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

@@ -8,15 +8,17 @@ const MonitLogEntry = z.object({
 	text: z.string()
 });
 const MonitVitals = z.object({
-	openaiWorkerCount: z.number(),
-	openaiReadyWorkerCount: z.number(),
-	openaiQueueLength: z.number(),
-	openaiWorkersByToken: z.array(z.object({
+	openaiInFlight: z.number(),
+	openaiQuotaByToken: z.array(z.object({
 		name: z.string(),
-		count: z.number()
+		usedPercent: z.number().nullable(),
+		threshold: z.number().nullable(),
+		blocked: z.boolean(),
+		resetsAt: z.number().nullable()
 	})),
 	anthropicTokenCount: z.number(),
-	anthropicTokenNames: z.array(z.string())
+	anthropicTokenNames: z.array(z.string()),
+	anthropicInFlight: z.number()
 });
 const MonitLogChunk = z.object({
 	processStartedAt: z.number(),
@@ -29,13 +31,20 @@ const MonitServerInfo = z.object({
 	serverUrl: z.string(),
 	dbHost: z.string(),
 	dbName: z.string(),
-	openai: z.object({
-		minWorkersPerToken: z.number(),
-		maxWorkersPerToken: z.number(),
-		autoscale: z.boolean()
-	})
+	openai: z.object({ transport: z.string() })
+});
+const MonitProviderStats = z.object({
+	provider: z.string(),
+	requests: z.number(),
+	errors: z.number(),
+	inputTokens: z.number(),
+	cacheReadTokens: z.number()
+});
+const MonitStats = z.object({
+	windowMinutes: z.number(),
+	providers: z.array(MonitProviderStats)
 });
 //#endregion
-export { MonitLogChunk, MonitLogEntry, MonitServerInfo, MonitVitals };
+export { MonitLogChunk, MonitLogEntry, MonitProviderStats, MonitServerInfo, MonitStats, MonitVitals };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/bundle/dist/application/qgrid/conv-routing.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 //#region src/application/qgrid/conv-routing.ts
 /**
-* conv-routing — conversation(=codex thread) 재사용을 위한 thread 좌표 검증/구성.
+* conv-routing — 대화 연속성(cache affinity) 좌표 검증/구성.
 *
 * 목표: thread(=conversation_id=prompt_cache_key)를 재사용해 OpenAI prompt caching 적중.
 * - 후속 turn: 기존 thread 에 delta(마지막 user / tool 결과)만 보냄 (history inject 없음).
@@ -10,8 +10,8 @@ import { createHash } from "node:crypto";
 * 식별: 서버 발급 불투명 thread 좌표(QgridThreadCoord)를 클라가 그대로 회송.
 * 검증: systemHash(다른 대화 오접속 차단) + (dispatcher의) epoch/worker 생존.
 */
-function systemHash(system) {
-	return createHash("sha256").update(system ?? "").digest("hex").slice(0, 16);
+function systemHash(system, modelNamespace) {
+	return createHash("sha256").update(modelNamespace === void 0 ? system ?? "" : `${modelNamespace}\0${system ?? ""}`).digest("hex").slice(0, 16);
 }
 function toolResultsToText(toolResults) {
 	return `${toolResults.map((tr) => {
@@ -20,21 +20,25 @@ function toolResultsToText(toolResults) {
 		return `Tool result for call ${tr.toolCallId}${name}${errMark}: ${tr.output}`;
 	}).join("\n")}\n\nNow continue answering the user's request using these results.`;
 }
-function decideConvRouting(input) {
-	const sysHash = systemHash(input.system);
+function decideConvRouting(input, options = {}) {
+	const sysHash = systemHash(input.system, options.directOpenAI ? options.modelNamespace ?? input.model ?? "openai" : void 0);
 	const history = input.history ? JSON.parse(input.history) : void 0;
 	const coord = input.runContext?.threadCoord;
-	const eligible = coord !== void 0 && coord.systemHash === sysHash;
+	const directCoordEligible = options.directOpenAI === true && coord?.epoch === -1 && coord.systemHash === sysHash && input.cacheAffinityKey !== void 0 && coord.threadId === input.cacheAffinityKey;
+	const legacyReuseEligible = options.directOpenAI !== true && coord !== void 0 && coord.systemHash === sysHash;
+	const cacheKey = options.directOpenAI ? input.cacheAffinityKey : void 0;
 	return {
-		reuse: eligible && coord ? {
+		reuse: legacyReuseEligible && coord ? {
 			workerId: coord.workerId,
 			threadId: coord.threadId,
 			epoch: coord.epoch
 		} : void 0,
-		reuseInput: eligible ? buildDeltaInput(input) : void 0,
+		reuseInput: legacyReuseEligible ? buildDeltaInput(input) : void 0,
 		coldInput: buildDeltaInput(input),
 		coldHistory: history,
-		systemHash: sysHash
+		systemHash: sysHash,
+		promptCacheKey: cacheKey,
+		preferredTokenId: directCoordEligible ? coord.workerId : void 0
 	};
 }
 function buildDeltaInput(input) {
@@ -69,7 +73,13 @@ function buildDeltaInput(input) {
 		text_elements: []
 	}];
 }
-function issueConvContext(threadCoord, decision) {
+function issueConvContext(threadCoord, decision, preferredTokenId = threadCoord.workerId) {
+	if (decision.promptCacheKey) return {
+		workerId: preferredTokenId,
+		threadId: decision.promptCacheKey,
+		epoch: -1,
+		systemHash: decision.systemHash
+	};
 	return {
 		workerId: threadCoord.workerId,
 		threadId: threadCoord.threadId,
@@ -80,4 +90,4 @@ function issueConvContext(threadCoord, decision) {
 //#endregion
 export { decideConvRouting, issueConvContext, systemHash };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"conv-routing.js","names":[],"sources":["../../../src/application/qgrid/conv-routing.ts"],"sourcesContent":["/**\n * conv-routing — conversation(=codex thread) 재사용을 위한 thread 좌표 검증/구성.\n *\n * 목표: thread(=conversation_id=prompt_cache_key)를 재사용해 OpenAI prompt caching 적중.\n * - 후속 turn: 기존 thread 에 delta(마지막 user / tool 결과)만 보냄 (history inject 없음).\n * - 첫 turn / 검증 실패: 새 thread + history inject (폴백, 정확성 보존).\n *\n * 식별: 서버 발급 불투명 thread 좌표(QgridThreadCoord)를 클라가 그대로 회송.\n * 검증: systemHash(다른 대화 오접속 차단) + (dispatcher의) epoch/worker 생존.\n */\nimport { createHash } from \"node:crypto\";\n\nimport { type JsonValue } from \"../../codex-protocol/serde_json/JsonValue\";\nimport { type UserInput } from \"../../codex-protocol/v2/UserInput\";\nimport { type ReuseThreadCoord } from \"../../utils/providers/common/provider-dispatcher\";\nimport { type QgridThreadCoord, type QueryInput, type QgridToolResultInput } from \"./qgrid.types\";\n\nexport function systemHash(system?: string): string {\n  return createHash(\"sha256\")\n    .update(system ?? \"\")\n    .digest(\"hex\")\n    .slice(0, 16);\n}\n\n// tool 결과를 다음 turn 의 input text 로 변환 (codex turn/start.input 은 UserInput 만 받음).\nfunction toolResultsToText(toolResults: QgridToolResultInput[]): string {\n  const lines = toolResults.map((tr) => {\n    const name = tr.toolName ? ` (${tr.toolName})` : \"\";\n    const errMark = tr.isError ? \" [error]\" : \"\";\n    return `Tool result for call ${tr.toolCallId}${name}${errMark}: ${tr.output}`;\n  });\n  return `${lines.join(\"\\n\")}\\n\\nNow continue answering the user's request using these results.`;\n}\n\nexport interface ConvDecision {\n  // dispatcher 로 넘길 reuse 좌표 (검증 통과 시에만). dispatcher 가 epoch/worker 생존 재검증 후 폴백 가능.\n  reuse?: ReuseThreadCoord;\n  // 재사용 성공 시 turn/start 에 보낼 input — delta(마지막 user/tool 결과)만. reuse 가 있을 때만 설정.\n  reuseInput?: Array<UserInput>;\n  // 첫 turn / 재사용 폴백 시 보낼 input — 전체 prompt. 항상 설정(폴백 안전망).\n  coldInput: Array<UserInput>;\n  // 새 thread 일 때 inject 할 전체 history. 재사용 성공 시엔 dispatcher 가 안 쓴다(thread 가 이미 누적).\n  coldHistory?: Array<JsonValue>;\n  // 이 요청 시점의 system 해시 (응답에서 thread 좌표 발급 시 사용).\n  systemHash: string;\n}\n\n// thread 좌표 + 들어온 요청으로 \"재사용 가능한가\"를 판정하고, reuse/cold 양쪽 payload 를 구성한다.\n// dispatcher 단의 epoch/worker 생존 검증은 여기서 못 하므로(상태 없음) reuse 좌표 + 두 payload 를\n// 모두 넘기고, dispatcher 의 acquireReuseWorker 결과에 따라 reuse(delta) 또는 cold(전체) 를 고른다.\n// 양쪽을 다 들고 가야 reuse 가 실패로 폴백돼도 전체 history 로 문맥을 복구할 수 있다.\nexport function decideConvRouting(input: QueryInput): ConvDecision {\n  const sysHash = systemHash(input.system);\n  const history: Array<JsonValue> | undefined = input.history\n    ? (JSON.parse(input.history) as Array<JsonValue>)\n    : undefined;\n\n  const coord = input.runContext?.threadCoord;\n\n  // 재사용 자격: 좌표 존재 + system 동일. sessionKey 격리 + systemHash 로 대화 동일성이\n  // 보장되고, 공통 prefix 는 codex 가 prompt_cache_key 고정으로 알아서 캐시한다.\n  const eligible = coord !== undefined && coord.systemHash === sysHash;\n\n  return {\n    reuse:\n      eligible && coord\n        ? { workerId: coord.workerId, threadId: coord.threadId, epoch: coord.epoch }\n        : undefined,\n    // 재사용 turn 은 delta(마지막 user/tool 결과)만 — thread 가 이미 이전 turn 들을 누적.\n    reuseInput: eligible ? buildDeltaInput(input) : undefined,\n    // 첫 turn / 폴백: 전체 prompt + history inject. tool 결과 follow-up 이 cold 로 떨어져도\n    // 실행 user 줄에는 \"이 결과로 계속 답하라\"는 continuation 이 들어가야 한다.\n    coldInput: buildDeltaInput(input),\n    coldHistory: history,\n    systemHash: sysHash,\n  };\n}\n\n// 후속 turn 의 input: tool 결과가 있으면 그걸 text 로, 없으면 마지막 user(prompt).\nfunction buildDeltaInput(input: QueryInput): Array<UserInput> {\n  if (input.toolResults && input.toolResults.length > 0) {\n    return [{ type: \"text\", text: toolResultsToText(input.toolResults), text_elements: [] }];\n  }\n  if (input.input && input.input.length > 0) {\n    const hasText = input.input.some((part) => part.type === \"text\");\n    const parts: Array<UserInput> = input.input.map((part) => {\n      if (part.type === \"text\") {\n        return { type: \"text\", text: part.text, text_elements: part.text_elements };\n      }\n      return { type: \"image\", url: part.url };\n    });\n    if (!hasText && input.prompt.length > 0) {\n      return [{ type: \"text\", text: input.prompt, text_elements: [] }, ...parts];\n    }\n    return parts;\n  }\n  return [{ type: \"text\", text: input.prompt, text_elements: [] }];\n}\n\n// 응답 threadCoord + 요청 시점 정보로 다음 thread 좌표를 발급한다.\nexport function issueConvContext(\n  threadCoord: ReuseThreadCoord,\n  decision: ConvDecision,\n): QgridThreadCoord {\n  return {\n    workerId: threadCoord.workerId,\n    threadId: threadCoord.threadId,\n    epoch: threadCoord.epoch,\n    systemHash: decision.systemHash,\n  };\n}\n"],"mappings":";;;;;;;;;;;;AAiBA,SAAgB,WAAW,QAAyB;CAClD,OAAO,WAAW,QAAQ,CAAC,CACxB,OAAO,UAAU,EAAE,CAAC,CACpB,OAAO,KAAK,CAAC,CACb,MAAM,GAAG,EAAE;AAChB;AAGA,SAAS,kBAAkB,aAA6C;CAMtE,OAAO,GALO,YAAY,KAAK,OAAO;EACpC,MAAM,OAAO,GAAG,WAAW,KAAK,GAAG,SAAS,KAAK;EACjD,MAAM,UAAU,GAAG,UAAU,aAAa;EAC1C,OAAO,wBAAwB,GAAG,aAAa,OAAO,QAAQ,IAAI,GAAG;CACvE,CACU,CAAA,CAAM,KAAK,IAAI,EAAE;AAC7B;AAmBA,SAAgB,kBAAkB,OAAiC;CACjE,MAAM,UAAU,WAAW,MAAM,MAAM;CACvC,MAAM,UAAwC,MAAM,UAC/C,KAAK,MAAM,MAAM,OAAO,IACzB;CAEJ,MAAM,QAAQ,MAAM,YAAY;CAIhC,MAAM,WAAW,UAAU,UAAa,MAAM,eAAe;CAE7D,OAAO;EACL,OACE,YAAY,QACR;GAAE,UAAU,MAAM;GAAU,UAAU,MAAM;GAAU,OAAO,MAAM;EAAM,IACzE;EAEN,YAAY,WAAW,gBAAgB,KAAK,IAAI;EAGhD,WAAW,gBAAgB,KAAK;EAChC,aAAa;EACb,YAAY;CACd;AACF;AAGA,SAAS,gBAAgB,OAAqC;CAC5D,IAAI,MAAM,eAAe,MAAM,YAAY,SAAS,GAClD,OAAO,CAAC;EAAE,MAAM;EAAQ,MAAM,kBAAkB,MAAM,WAAW;EAAG,eAAe,CAAC;CAAE,CAAC;CAEzF,IAAI,MAAM,SAAS,MAAM,MAAM,SAAS,GAAG;EACzC,MAAM,UAAU,MAAM,MAAM,MAAM,SAAS,KAAK,SAAS,MAAM;EAC/D,MAAM,QAA0B,MAAM,MAAM,KAAK,SAAS;GACxD,IAAI,KAAK,SAAS,QAChB,OAAO;IAAE,MAAM;IAAQ,MAAM,KAAK;IAAM,eAAe,KAAK;GAAc;GAE5E,OAAO;IAAE,MAAM;IAAS,KAAK,KAAK;GAAI;EACxC,CAAC;EACD,IAAI,CAAC,WAAW,MAAM,OAAO,SAAS,GACpC,OAAO,CAAC;GAAE,MAAM;GAAQ,MAAM,MAAM;GAAQ,eAAe,CAAC;EAAE,GAAG,GAAG,KAAK;EAE3E,OAAO;CACT;CACA,OAAO,CAAC;EAAE,MAAM;EAAQ,MAAM,MAAM;EAAQ,eAAe,CAAC;CAAE,CAAC;AACjE;AAGA,SAAgB,iBACd,aACA,UACkB;CAClB,OAAO;EACL,UAAU,YAAY;EACtB,UAAU,YAAY;EACtB,OAAO,YAAY;EACnB,YAAY,SAAS;CACvB;AACF"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"conv-routing.js","names":[],"sources":["../../../src/application/qgrid/conv-routing.ts"],"sourcesContent":["/**\n * conv-routing — 대화 연속성(cache affinity) 좌표 검증/구성.\n *\n * 목표: thread(=conversation_id=prompt_cache_key)를 재사용해 OpenAI prompt caching 적중.\n * - 후속 turn: 기존 thread 에 delta(마지막 user / tool 결과)만 보냄 (history inject 없음).\n * - 첫 turn / 검증 실패: 새 thread + history inject (폴백, 정확성 보존).\n *\n * 식별: 서버 발급 불투명 thread 좌표(QgridThreadCoord)를 클라가 그대로 회송.\n * 검증: systemHash(다른 대화 오접속 차단) + (dispatcher의) epoch/worker 생존.\n */\nimport { createHash } from \"node:crypto\";\n\nimport { type ReuseThreadCoord } from \"../../utils/providers/common/provider-dispatcher\";\nimport { type JsonValue, type UserInput } from \"../../utils/providers/common/provider-types\";\nimport { type QgridThreadCoord, type QueryInput, type QgridToolResultInput } from \"./qgrid.types\";\n\nexport function systemHash(system?: string, modelNamespace?: string): string {\n  return createHash(\"sha256\")\n    .update(modelNamespace === undefined ? (system ?? \"\") : `${modelNamespace}\\0${system ?? \"\"}`)\n    .digest(\"hex\")\n    .slice(0, 16);\n}\n\n// tool 결과를 다음 turn 의 input text 로 변환 (provider 입력은 UserInput 만 받음).\nfunction toolResultsToText(toolResults: QgridToolResultInput[]): string {\n  const lines = toolResults.map((tr) => {\n    const name = tr.toolName ? ` (${tr.toolName})` : \"\";\n    const errMark = tr.isError ? \" [error]\" : \"\";\n    return `Tool result for call ${tr.toolCallId}${name}${errMark}: ${tr.output}`;\n  });\n  return `${lines.join(\"\\n\")}\\n\\nNow continue answering the user's request using these results.`;\n}\n\nexport interface ConvDecision {\n  // dispatcher 로 넘길 reuse 좌표 (검증 통과 시에만). dispatcher 가 epoch/worker 생존 재검증 후 폴백 가능.\n  reuse?: ReuseThreadCoord;\n  // 재사용 성공 시 turn/start 에 보낼 input — delta(마지막 user/tool 결과)만. reuse 가 있을 때만 설정.\n  reuseInput?: Array<UserInput>;\n  // 첫 turn / 재사용 폴백 시 보낼 input — 전체 prompt. 항상 설정(폴백 안전망).\n  coldInput: Array<UserInput>;\n  // 새 thread 일 때 inject 할 전체 history. 재사용 성공 시엔 dispatcher 가 안 쓴다(thread 가 이미 누적).\n  coldHistory?: Array<JsonValue>;\n  // 이 요청 시점의 system 해시 (응답에서 thread 좌표 발급 시 사용).\n  systemHash: string;\n  // Direct-provider cache affinity. Presence marks the epoch=-1 coordinate semantics.\n  promptCacheKey?: string;\n  preferredTokenId?: number;\n}\n\nexport interface ConvRoutingOptions {\n  directOpenAI?: boolean;\n  modelNamespace?: string;\n}\n\n// thread 좌표 + 들어온 요청으로 \"재사용 가능한가\"를 판정하고, reuse/cold 양쪽 payload 를 구성한다.\n// dispatcher 단의 epoch/worker 생존 검증은 여기서 못 하므로(상태 없음) reuse 좌표 + 두 payload 를\n// 모두 넘기고, dispatcher 의 acquireReuseWorker 결과에 따라 reuse(delta) 또는 cold(전체) 를 고른다.\n// 양쪽을 다 들고 가야 reuse 가 실패로 폴백돼도 전체 history 로 문맥을 복구할 수 있다.\nexport function decideConvRouting(\n  input: QueryInput,\n  options: ConvRoutingOptions = {},\n): ConvDecision {\n  const sysHash = systemHash(\n    input.system,\n    options.directOpenAI ? (options.modelNamespace ?? input.model ?? \"openai\") : undefined,\n  );\n  const history: Array<JsonValue> | undefined = input.history\n    ? (JSON.parse(input.history) as Array<JsonValue>)\n    : undefined;\n\n  const coord = input.runContext?.threadCoord;\n\n  // 재사용 자격: 좌표 존재 + system 동일. sessionKey 격리 + systemHash 로 대화 동일성이\n  // 보장되고, 공통 prefix 는 백엔드가 prompt_cache_key 고정으로 알아서 캐시한다.\n  const directCoordEligible =\n    options.directOpenAI === true &&\n    coord?.epoch === -1 &&\n    coord.systemHash === sysHash &&\n    input.cacheAffinityKey !== undefined &&\n    coord.threadId === input.cacheAffinityKey;\n  const legacyReuseEligible =\n    options.directOpenAI !== true && coord !== undefined && coord.systemHash === sysHash;\n  // affinity 를 요청하지 않은 one-shot 요청에 임의 키를 붙이면 transport 가 그 소켓을\n  // affinity 소켓으로 오인해 재사용되지 않을 연결을 계속 붙들어 둔다 → 키를 비워 둔다.\n  const cacheKey = options.directOpenAI ? input.cacheAffinityKey : undefined;\n\n  return {\n    reuse:\n      legacyReuseEligible && coord\n        ? { workerId: coord.workerId, threadId: coord.threadId, epoch: coord.epoch }\n        : undefined,\n    // 재사용 turn 은 delta(마지막 user/tool 결과)만 — thread 가 이미 이전 turn 들을 누적.\n    reuseInput: legacyReuseEligible ? buildDeltaInput(input) : undefined,\n    // 첫 turn / 폴백: 전체 prompt + history inject. tool 결과 follow-up 이 cold 로 떨어져도\n    // 실행 user 줄에는 \"이 결과로 계속 답하라\"는 continuation 이 들어가야 한다.\n    coldInput: buildDeltaInput(input),\n    coldHistory: history,\n    systemHash: sysHash,\n    promptCacheKey: cacheKey,\n    preferredTokenId: directCoordEligible ? coord.workerId : undefined,\n  };\n}\n\n// 후속 turn 의 input: tool 결과가 있으면 그걸 text 로, 없으면 마지막 user(prompt).\nfunction buildDeltaInput(input: QueryInput): Array<UserInput> {\n  if (input.toolResults && input.toolResults.length > 0) {\n    return [{ type: \"text\", text: toolResultsToText(input.toolResults), text_elements: [] }];\n  }\n  if (input.input && input.input.length > 0) {\n    const hasText = input.input.some((part) => part.type === \"text\");\n    const parts: Array<UserInput> = input.input.map((part) => {\n      if (part.type === \"text\") {\n        return { type: \"text\", text: part.text, text_elements: part.text_elements };\n      }\n      return { type: \"image\", url: part.url };\n    });\n    if (!hasText && input.prompt.length > 0) {\n      return [{ type: \"text\", text: input.prompt, text_elements: [] }, ...parts];\n    }\n    return parts;\n  }\n  return [{ type: \"text\", text: input.prompt, text_elements: [] }];\n}\n\n// 응답 threadCoord + 요청 시점 정보로 다음 thread 좌표를 발급한다.\nexport function issueConvContext(\n  threadCoord: ReuseThreadCoord,\n  decision: ConvDecision,\n  preferredTokenId = threadCoord.workerId,\n): QgridThreadCoord {\n  if (decision.promptCacheKey) {\n    return {\n      workerId: preferredTokenId,\n      threadId: decision.promptCacheKey,\n      epoch: -1,\n      systemHash: decision.systemHash,\n    };\n  }\n  return {\n    workerId: threadCoord.workerId,\n    threadId: threadCoord.threadId,\n    epoch: threadCoord.epoch,\n    systemHash: decision.systemHash,\n  };\n}\n"],"mappings":";;;;;;;;;;;;AAgBA,SAAgB,WAAW,QAAiB,gBAAiC;CAC3E,OAAO,WAAW,QAAQ,CAAC,CACxB,OAAO,mBAAmB,SAAa,UAAU,KAAM,GAAG,eAAe,IAAI,UAAU,IAAI,CAAC,CAC5F,OAAO,KAAK,CAAC,CACb,MAAM,GAAG,EAAE;AAChB;AAGA,SAAS,kBAAkB,aAA6C;CAMtE,OAAO,GALO,YAAY,KAAK,OAAO;EACpC,MAAM,OAAO,GAAG,WAAW,KAAK,GAAG,SAAS,KAAK;EACjD,MAAM,UAAU,GAAG,UAAU,aAAa;EAC1C,OAAO,wBAAwB,GAAG,aAAa,OAAO,QAAQ,IAAI,GAAG;CACvE,CACU,CAAA,CAAM,KAAK,IAAI,EAAE;AAC7B;AA2BA,SAAgB,kBACd,OACA,UAA8B,CAAC,GACjB;CACd,MAAM,UAAU,WACd,MAAM,QACN,QAAQ,eAAgB,QAAQ,kBAAkB,MAAM,SAAS,WAAY,MAC/E;CACA,MAAM,UAAwC,MAAM,UAC/C,KAAK,MAAM,MAAM,OAAO,IACzB;CAEJ,MAAM,QAAQ,MAAM,YAAY;CAIhC,MAAM,sBACJ,QAAQ,iBAAiB,QACzB,OAAO,UAAU,MACjB,MAAM,eAAe,WACrB,MAAM,qBAAqB,UAC3B,MAAM,aAAa,MAAM;CAC3B,MAAM,sBACJ,QAAQ,iBAAiB,QAAQ,UAAU,UAAa,MAAM,eAAe;CAG/E,MAAM,WAAW,QAAQ,eAAe,MAAM,mBAAmB;CAEjE,OAAO;EACL,OACE,uBAAuB,QACnB;GAAE,UAAU,MAAM;GAAU,UAAU,MAAM;GAAU,OAAO,MAAM;EAAM,IACzE;EAEN,YAAY,sBAAsB,gBAAgB,KAAK,IAAI;EAG3D,WAAW,gBAAgB,KAAK;EAChC,aAAa;EACb,YAAY;EACZ,gBAAgB;EAChB,kBAAkB,sBAAsB,MAAM,WAAW;CAC3D;AACF;AAGA,SAAS,gBAAgB,OAAqC;CAC5D,IAAI,MAAM,eAAe,MAAM,YAAY,SAAS,GAClD,OAAO,CAAC;EAAE,MAAM;EAAQ,MAAM,kBAAkB,MAAM,WAAW;EAAG,eAAe,CAAC;CAAE,CAAC;CAEzF,IAAI,MAAM,SAAS,MAAM,MAAM,SAAS,GAAG;EACzC,MAAM,UAAU,MAAM,MAAM,MAAM,SAAS,KAAK,SAAS,MAAM;EAC/D,MAAM,QAA0B,MAAM,MAAM,KAAK,SAAS;GACxD,IAAI,KAAK,SAAS,QAChB,OAAO;IAAE,MAAM;IAAQ,MAAM,KAAK;IAAM,eAAe,KAAK;GAAc;GAE5E,OAAO;IAAE,MAAM;IAAS,KAAK,KAAK;GAAI;EACxC,CAAC;EACD,IAAI,CAAC,WAAW,MAAM,OAAO,SAAS,GACpC,OAAO,CAAC;GAAE,MAAM;GAAQ,MAAM,MAAM;GAAQ,eAAe,CAAC;EAAE,GAAG,GAAG,KAAK;EAE3E,OAAO;CACT;CACA,OAAO,CAAC;EAAE,MAAM;EAAQ,MAAM,MAAM;EAAQ,eAAe,CAAC;CAAE,CAAC;AACjE;AAGA,SAAgB,iBACd,aACA,UACA,mBAAmB,YAAY,UACb;CAClB,IAAI,SAAS,gBACX,OAAO;EACL,UAAU;EACV,UAAU,SAAS;EACnB,OAAO;EACP,YAAY,SAAS;CACvB;CAEF,OAAO;EACL,UAAU,YAAY;EACtB,UAAU,YAAY;EACtB,OAAO,YAAY;EACnB,YAAY,SAAS;CACvB;AACF"}

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-run-lifecycle.js

@@ -1,8 +1,8 @@
 import { SD } from "../../i18n/sd.generated.js";
+import { RequestLogModel } from "../request-log/request-log.model.js";
 import { isRestartPending } from "../../utils/server-restart.js";
 import { estimateImageGenerationCostMicroUsd, imageGenerationCostMethod } from "./qgrid-image-generation.js";
 import { buildImageGenerationToolSteps, formatResponseForLog, getImageParts } from "./qgrid-response-format.js";
-import { RequestLogModel } from "../request-log/request-log.model.js";
 import { ServiceUnavailableException } from "sonamu";
 import { getLogger } from "@logtape/logtape";
 //#region src/application/qgrid/qgrid-run-lifecycle.ts
@@ -63,6 +63,14 @@ function filterHistoryForStorage(rawHistory) {
 		return;
 	}
 }
+function isParseableJson(text) {
+	try {
+		JSON.parse(text);
+		return true;
+	} catch {
+		return false;
+	}
+}
 /**
 * logger-enabled query/stream 응답 전후에 호출.
 *
@@ -87,7 +95,8 @@ async function beforeQuery(args) {
 			project_name: args.projectName,
 			history: filterHistoryForStorage(args.history),
 			tools: args.tools?.length ? args.tools : void 0,
-			is_image_generation: args.imageGeneration
+			is_image_generation: args.imageGeneration,
+			json_schema: args.jsonSchema ?? null
 		});
 	}
 	if (isRestartPending()) {
@@ -144,9 +153,11 @@ async function afterQuery(requestLogId, stepIndex, args, result) {
 				return { runContext: { requestLogId } };
 			}
 			const agg = await RequestLogModel.aggregateStepUsage(requestLogId);
+			const responseText = formatResponseForLog(result);
 			await RequestLogModel.finishRun(requestLogId, {
 				status: "succeeded",
-				response: formatResponseForLog(result),
+				response: responseText,
+				response_json_ok: args.jsonSchema ? isParseableJson(responseText) : null,
 				token_name: result.tokenName,
 				input_tokens: agg.input_tokens,
 				output_tokens: agg.output_tokens,
@@ -264,4 +275,4 @@ async function performStaleRunCleanup() {
 //#endregion
 export { afterQuery, assertNativeRunAdmission, beforeQuery, finishActiveNativeRunsForRestart, finishRunAborted, finishRunWithError, resetNativeRunRegistryForTests };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"qgrid-run-lifecycle.js","names":[],"sources":["../../../src/application/qgrid/qgrid-run-lifecycle.ts"],"sourcesContent":["import { getLogger } from \"@logtape/logtape\";\nimport { ServiceUnavailableException } from \"sonamu\";\n\nimport { SD } from \"../../i18n/sd.generated\";\nimport { isRestartPending } from \"../../utils/server-restart\";\nimport { RequestLogModel } from \"../request-log/request-log.model\";\nimport {\n  estimateImageGenerationCostMicroUsd,\n  imageGenerationCostMethod,\n} from \"./qgrid-image-generation\";\nimport {\n  buildImageGenerationToolSteps,\n  formatResponseForLog,\n  getImageParts,\n} from \"./qgrid-response-format\";\nimport { type QgridRunContext, type QueryInput, type QueryOutput } from \"./qgrid.types\";\n\nconst logger = getLogger([\"qgrid\", \"run-lifecycle\"]);\nconst STALE_RUN_THRESHOLD_MS = 30 * 60 * 1000;\nconst STALE_CLEANUP_INTERVAL_MS = 60 * 1000;\nlet staleCleanupInFlight: Promise<void> | undefined;\nlet lastStaleCleanupStartedAt = 0;\nconst activeNativeRunRefs = new Map<number, number>();\nconst interruptedNativeRunIds = new Set<number>();\nconst activeNativeFinalizers = new Map<number, Set<Promise<void>>>();\n\nfunction restartUnavailable(): ServiceUnavailableException {\n  return new ServiceUnavailableException(SD(\"qgrid.restartPending\")());\n}\n\nfunction registerNativeRun(requestLogId: number): void {\n  activeNativeRunRefs.set(requestLogId, (activeNativeRunRefs.get(requestLogId) ?? 0) + 1);\n}\n\nfunction releaseNativeRun(requestLogId: number): void {\n  const refs = activeNativeRunRefs.get(requestLogId);\n  if (refs === undefined || refs <= 1) activeNativeRunRefs.delete(requestLogId);\n  else activeNativeRunRefs.set(requestLogId, refs - 1);\n}\n\nfunction trackNativeFinalizer<T>(requestLogId: number, finalize: () => Promise<T>): Promise<T> {\n  const operation = finalize();\n  const settled = operation.then(\n    () => undefined,\n    () => undefined,\n  );\n  const finalizers = activeNativeFinalizers.get(requestLogId) ?? new Set<Promise<void>>();\n  finalizers.add(settled);\n  activeNativeFinalizers.set(requestLogId, finalizers);\n  void settled.then(() => {\n    finalizers.delete(settled);\n    if (finalizers.size === 0) activeNativeFinalizers.delete(requestLogId);\n  });\n  return operation;\n}\n\nexport function assertNativeRunAdmission(): void {\n  if (isRestartPending()) throw restartUnavailable();\n}\n\nfunction withProviderPrefix(\n  routeModel: string | undefined,\n  model: string | undefined,\n): string | undefined {\n  if (!model) return undefined;\n  if (model.includes(\"/\")) return model;\n  const slash = routeModel?.indexOf(\"/\") ?? -1;\n  const provider = slash > 0 ? routeModel?.slice(0, slash) : undefined;\n  return provider ? `${provider}/${model}` : model;\n}\n\n/**\n * history는 원본 그대로 저장하기보다는, run 분석에 필요한 user/assistant 정보만 필터링해서 저장\n */\nfunction filterHistoryForStorage(rawHistory: string | undefined): unknown {\n  if (!rawHistory) return undefined;\n  try {\n    const items = JSON.parse(rawHistory) as unknown[];\n    const filtered = items.filter((item) => {\n      if (!item || typeof item !== \"object\") return false;\n      const record = item as Record<string, unknown>;\n      return record.type === \"message\" && (record.role === \"user\" || record.role === \"assistant\");\n    });\n    return filtered.length > 0 ? filtered : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\nexport type RunLifecycleResult = {\n  runContext?: QgridRunContext;\n};\n\n/**\n * logger-enabled query/stream 응답 전후에 호출.\n *\n * 1) beforeQuery: run 생성/계속 + tool result 완료 + stale tool-wait cleanup\n * 2) afterQuery: generate step + tool-call step + finish/keep-open\n */\nexport async function beforeQuery(args: QueryInput): Promise<{\n  requestLogId: number;\n  stepIndex: number;\n}> {\n  assertNativeRunAdmission();\n\n  let requestLogId: number;\n  let stepIndex = 0;\n\n  // requestLogId 가 있을 때만 기존 run 연장. threadCoord 만 있는 conv 는 새 run 으로 시작.\n  // continuation 은 createRun 을 건너뛰므로 run 의 tools 는 첫 스텝 장착분으로 고정된다 —\n  // AI SDK prepareStep/activeTools 로 스텝마다 툴셋이 바뀌어도 로그에는 반영되지 않는다.\n  if (args.runContext?.requestLogId !== undefined) {\n    requestLogId = args.runContext.requestLogId;\n    // cleanup과 같은 DB advisory lock을 잡고 tool 결과 반영 + 다음 step 예약을 한\n    // transaction에서 처리한다. 여러 qgrid 프로세스 사이에서도 stale expiry가\n    // 도착 중인 follow-up을 error로 덮어쓰지 못한다.\n    stepIndex = await RequestLogModel.continueToolRun(requestLogId, args.toolResults ?? []);\n    await cleanupStaleRuns();\n  } else {\n    await cleanupStaleRuns();\n    requestLogId = await RequestLogModel.createRun({\n      user_prompt: args.prompt,\n      system_prompt: args.system,\n      requested_model_name: args.model,\n      effort: args.effort,\n      project_name: args.projectName,\n      history: filterHistoryForStorage(args.history),\n      tools: args.tools?.length ? args.tools : undefined,\n      is_image_generation: args.imageGeneration,\n    });\n  }\n\n  // DB 준비 중에 재시작이 시작됐다면 provider 실행으로 넘어가지 않는다.\n  // 이 요청은 재시작 snapshot에 없었으므로 방금 준비한 run을 직접 마감한다.\n  if (isRestartPending()) {\n    await finishTerminalRun(requestLogId, \"error\", \"server restarted\");\n    throw restartUnavailable();\n  }\n\n  registerNativeRun(requestLogId);\n  return { requestLogId, stepIndex };\n}\n\nexport async function afterQuery(\n  requestLogId: number,\n  stepIndex: number,\n  args: QueryInput,\n  result: QueryOutput,\n): Promise<RunLifecycleResult> {\n  if (interruptedNativeRunIds.has(requestLogId)) return {};\n\n  return trackNativeFinalizer(requestLogId, async () => {\n    try {\n      // provider가 canonical model을 돌려줘도 요청 route 자체([1m] 등)는 보존한다.\n      const requestedModelName = withProviderPrefix(\n        args.model,\n        args.model ?? result.requestedModel ?? result.model,\n      );\n      const servedModelName = withProviderPrefix(args.model, result.model);\n\n      // generate step 기록\n      await RequestLogModel.appendStep(requestLogId, {\n        step_index: stepIndex,\n        type: \"generate\",\n        model_name: servedModelName,\n        requested_model_name: requestedModelName,\n        fallback_count: result.modelFallbacks?.length ?? 0,\n        input_tokens: result.usage.input_tokens,\n        output_tokens: result.usage.output_tokens,\n        cache_read_tokens: result.usage.cache_read_input_tokens,\n        cache_creation_tokens: result.usage.cache_creation_input_tokens,\n        cache_creation_5m_tokens: result.usage.cache_creation_5m_input_tokens,\n        cache_creation_1h_tokens: result.usage.cache_creation_1h_input_tokens,\n        cost_usd: Math.round(result.costUsd * 1_000_000),\n        cost_source: result.costSource,\n        duration_ms: result.durationMs,\n        ttft_ms: result.ttftMs,\n        finish_reason: result.finishReason,\n      });\n\n      const imageParts = getImageParts(result);\n      const imageCostMicroUsd = estimateImageGenerationCostMicroUsd(\n        result,\n        args.imageGenerationOptions,\n      );\n      for (const step of buildImageGenerationToolSteps(args, imageParts, stepIndex)) {\n        await RequestLogModel.appendStep(requestLogId, step);\n      }\n\n      if (result.finishReason === \"tool-calls\") {\n        // tool-call step을 즉시 기록하고, 다음 follow-up이 같은 row에 결과를 채운다.\n        const toolCalls = result.content.filter((c) => c.type === \"tool-call\");\n        for (let i = 0; i < toolCalls.length; i++) {\n          const tc = toolCalls[i]!;\n          if (tc.type !== \"tool-call\") continue;\n          await RequestLogModel.appendStep(requestLogId, {\n            step_index: stepIndex,\n            type: \"tool_call\",\n            tool_call_index: imageParts.length + i,\n            tool_call_id: tc.toolCallId,\n            tool_name: tc.toolName,\n            tool_args: tc.input,\n          });\n        }\n\n        return { runContext: { requestLogId } };\n      }\n\n      // finishReason === \"stop\" → run 종료 (전체 step usage 합산)\n      const agg = await RequestLogModel.aggregateStepUsage(requestLogId);\n      await RequestLogModel.finishRun(requestLogId, {\n        status: \"succeeded\",\n        response: formatResponseForLog(result),\n        token_name: result.tokenName,\n        input_tokens: agg.input_tokens,\n        output_tokens: agg.output_tokens,\n        cache_read_tokens: agg.cache_read_tokens,\n        cache_creation_tokens: agg.cache_creation_tokens,\n        cache_creation_5m_tokens: agg.cache_creation_5m_tokens,\n        cache_creation_1h_tokens: agg.cache_creation_1h_tokens,\n        duration_ms: agg.duration_ms,\n        // multi-step run 부모의 모델은 최종 turn을 서빙한 모델이다.\n        requested_model_name: requestedModelName,\n        model_name: servedModelName,\n        fallback_count: agg.fallback_count,\n        cost_usd: agg.cost_usd,\n        cost_source: agg.cost_source,\n        image_cost_usd: imageCostMicroUsd,\n        image_cost_method:\n          imageCostMicroUsd !== null\n            ? imageGenerationCostMethod(args.imageGenerationOptions)\n            : null,\n        history: filterHistoryForStorage(args.history),\n      });\n\n      return {};\n    } finally {\n      releaseNativeRun(requestLogId);\n    }\n  });\n}\n\nexport async function finishRunWithError(\n  requestLogId: number,\n  errorMessage: string,\n  args?: QueryInput,\n): Promise<void> {\n  if (interruptedNativeRunIds.has(requestLogId)) return;\n  return trackNativeFinalizer(requestLogId, async () => {\n    try {\n      await finishTerminalRun(requestLogId, \"error\", errorMessage, args);\n    } finally {\n      releaseNativeRun(requestLogId);\n    }\n  });\n}\n\nexport async function finishRunAborted(requestLogId: number, args?: QueryInput): Promise<void> {\n  if (interruptedNativeRunIds.has(requestLogId)) return;\n  return trackNativeFinalizer(requestLogId, async () => {\n    try {\n      await finishTerminalRun(requestLogId, \"aborted\", \"client disconnected\", args);\n    } finally {\n      releaseNativeRun(requestLogId);\n    }\n  });\n}\n\n/** 현재 이 프로세스가 provider를 실행 중인 native run만 재시작 오류로 마감한다. */\nexport async function finishActiveNativeRunsForRestart(): Promise<void> {\n  const requestLogIds = [...activeNativeRunRefs.keys()];\n  for (const requestLogId of requestLogIds) {\n    interruptedNativeRunIds.add(requestLogId);\n    activeNativeRunRefs.delete(requestLogId);\n  }\n\n  await Promise.all(\n    requestLogIds.map(async (requestLogId) => {\n      await Promise.all(activeNativeFinalizers.get(requestLogId) ?? []);\n      await finishTerminalRun(requestLogId, \"error\", \"server restarted\");\n    }),\n  );\n}\n\n/** 프로세스 전역 registry를 격리해야 하는 단위 테스트 전용. */\nexport function resetNativeRunRegistryForTests(): void {\n  activeNativeRunRefs.clear();\n  interruptedNativeRunIds.clear();\n  activeNativeFinalizers.clear();\n}\n\nasync function finishTerminalRun(\n  requestLogId: number,\n  status: \"error\" | \"aborted\",\n  errorMessage: string,\n  args?: QueryInput,\n): Promise<void> {\n  try {\n    let aggregate: Awaited<ReturnType<typeof RequestLogModel.aggregateStepUsage>> | undefined;\n    try {\n      aggregate = await RequestLogModel.aggregateStepUsage(requestLogId);\n    } catch (e) {\n      logger.error(`aggregateStepUsage failed while finishing ${status}: ${(e as Error).message}`);\n    }\n\n    await RequestLogModel.finishRun(requestLogId, {\n      status,\n      error_message: errorMessage,\n      history: args ? filterHistoryForStorage(args.history) : undefined,\n      ...(aggregate\n        ? {\n            input_tokens: aggregate.input_tokens,\n            output_tokens: aggregate.output_tokens,\n            cache_read_tokens: aggregate.cache_read_tokens,\n            cache_creation_tokens: aggregate.cache_creation_tokens,\n            cache_creation_5m_tokens: aggregate.cache_creation_5m_tokens,\n            cache_creation_1h_tokens: aggregate.cache_creation_1h_tokens,\n            duration_ms: aggregate.duration_ms,\n            fallback_count: aggregate.fallback_count,\n            cost_usd: aggregate.cost_usd,\n            cost_source: aggregate.cost_source,\n          }\n        : {}),\n    });\n  } catch (e) {\n    logger.error(`finishTerminalRun(${status}) failed: ${(e as Error).message}`);\n  }\n}\n\nasync function cleanupStaleRuns(): Promise<void> {\n  if (staleCleanupInFlight) {\n    await staleCleanupInFlight;\n    return;\n  }\n\n  const now = Date.now();\n  if (now - lastStaleCleanupStartedAt < STALE_CLEANUP_INTERVAL_MS) return;\n  lastStaleCleanupStartedAt = now;\n\n  const cleanup = performStaleRunCleanup();\n  staleCleanupInFlight = cleanup;\n  try {\n    await cleanup;\n  } finally {\n    if (staleCleanupInFlight === cleanup) staleCleanupInFlight = undefined;\n  }\n}\n\nasync function performStaleRunCleanup(): Promise<void> {\n  try {\n    const errorMessage = \"tool-call run: no follow-up within 30 minutes\";\n    const staleIds = await RequestLogModel.expireStaleToolWaitingRuns(\n      STALE_RUN_THRESHOLD_MS,\n      errorMessage,\n    );\n    const cleanedCount = staleIds.length;\n    if (cleanedCount > 0) {\n      logger.info(`cleaned up ${cleanedCount} stale running request logs`);\n    }\n  } catch (e) {\n    logger.error(`stale cleanup failed: ${(e as Error).message}`);\n  }\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"qgrid-run-lifecycle.js","names":[],"sources":["../../../src/application/qgrid/qgrid-run-lifecycle.ts"],"sourcesContent":["import { getLogger } from \"@logtape/logtape\";\nimport { ServiceUnavailableException } from \"sonamu\";\n\nimport { SD } from \"../../i18n/sd.generated\";\nimport { isRestartPending } from \"../../utils/server-restart\";\nimport { RequestLogModel } from \"../request-log/request-log.model\";\nimport {\n  estimateImageGenerationCostMicroUsd,\n  imageGenerationCostMethod,\n} from \"./qgrid-image-generation\";\nimport {\n  buildImageGenerationToolSteps,\n  formatResponseForLog,\n  getImageParts,\n} from \"./qgrid-response-format\";\nimport { type QgridRunContext, type QueryInput, type QueryOutput } from \"./qgrid.types\";\n\nconst logger = getLogger([\"qgrid\", \"run-lifecycle\"]);\nconst STALE_RUN_THRESHOLD_MS = 30 * 60 * 1000;\nconst STALE_CLEANUP_INTERVAL_MS = 60 * 1000;\nlet staleCleanupInFlight: Promise<void> | undefined;\nlet lastStaleCleanupStartedAt = 0;\nconst activeNativeRunRefs = new Map<number, number>();\nconst interruptedNativeRunIds = new Set<number>();\nconst activeNativeFinalizers = new Map<number, Set<Promise<void>>>();\n\nfunction restartUnavailable(): ServiceUnavailableException {\n  return new ServiceUnavailableException(SD(\"qgrid.restartPending\")());\n}\n\nfunction registerNativeRun(requestLogId: number): void {\n  activeNativeRunRefs.set(requestLogId, (activeNativeRunRefs.get(requestLogId) ?? 0) + 1);\n}\n\nfunction releaseNativeRun(requestLogId: number): void {\n  const refs = activeNativeRunRefs.get(requestLogId);\n  if (refs === undefined || refs <= 1) activeNativeRunRefs.delete(requestLogId);\n  else activeNativeRunRefs.set(requestLogId, refs - 1);\n}\n\nfunction trackNativeFinalizer<T>(requestLogId: number, finalize: () => Promise<T>): Promise<T> {\n  const operation = finalize();\n  const settled = operation.then(\n    () => undefined,\n    () => undefined,\n  );\n  const finalizers = activeNativeFinalizers.get(requestLogId) ?? new Set<Promise<void>>();\n  finalizers.add(settled);\n  activeNativeFinalizers.set(requestLogId, finalizers);\n  void settled.then(() => {\n    finalizers.delete(settled);\n    if (finalizers.size === 0) activeNativeFinalizers.delete(requestLogId);\n  });\n  return operation;\n}\n\nexport function assertNativeRunAdmission(): void {\n  if (isRestartPending()) throw restartUnavailable();\n}\n\nfunction withProviderPrefix(\n  routeModel: string | undefined,\n  model: string | undefined,\n): string | undefined {\n  if (!model) return undefined;\n  if (model.includes(\"/\")) return model;\n  const slash = routeModel?.indexOf(\"/\") ?? -1;\n  const provider = slash > 0 ? routeModel?.slice(0, slash) : undefined;\n  return provider ? `${provider}/${model}` : model;\n}\n\n/**\n * history는 원본 그대로 저장하기보다는, run 분석에 필요한 user/assistant 정보만 필터링해서 저장\n */\nfunction filterHistoryForStorage(rawHistory: string | undefined): unknown {\n  if (!rawHistory) return undefined;\n  try {\n    const items = JSON.parse(rawHistory) as unknown[];\n    const filtered = items.filter((item) => {\n      if (!item || typeof item !== \"object\") return false;\n      const record = item as Record<string, unknown>;\n      return record.type === \"message\" && (record.role === \"user\" || record.role === \"assistant\");\n    });\n    return filtered.length > 0 ? filtered : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\nfunction isParseableJson(text: string): boolean {\n  try {\n    JSON.parse(text);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nexport type RunLifecycleResult = {\n  runContext?: QgridRunContext;\n};\n\n/**\n * logger-enabled query/stream 응답 전후에 호출.\n *\n * 1) beforeQuery: run 생성/계속 + tool result 완료 + stale tool-wait cleanup\n * 2) afterQuery: generate step + tool-call step + finish/keep-open\n */\nexport async function beforeQuery(args: QueryInput): Promise<{\n  requestLogId: number;\n  stepIndex: number;\n}> {\n  assertNativeRunAdmission();\n\n  let requestLogId: number;\n  let stepIndex = 0;\n\n  // requestLogId 가 있을 때만 기존 run 연장. threadCoord 만 있는 conv 는 새 run 으로 시작.\n  // continuation 은 createRun 을 건너뛰므로 run 의 tools 는 첫 스텝 장착분으로 고정된다 —\n  // AI SDK prepareStep/activeTools 로 스텝마다 툴셋이 바뀌어도 로그에는 반영되지 않는다.\n  if (args.runContext?.requestLogId !== undefined) {\n    requestLogId = args.runContext.requestLogId;\n    // cleanup과 같은 DB advisory lock을 잡고 tool 결과 반영 + 다음 step 예약을 한\n    // transaction에서 처리한다. 여러 qgrid 프로세스 사이에서도 stale expiry가\n    // 도착 중인 follow-up을 error로 덮어쓰지 못한다.\n    stepIndex = await RequestLogModel.continueToolRun(requestLogId, args.toolResults ?? []);\n    await cleanupStaleRuns();\n  } else {\n    await cleanupStaleRuns();\n    requestLogId = await RequestLogModel.createRun({\n      user_prompt: args.prompt,\n      system_prompt: args.system,\n      requested_model_name: args.model,\n      effort: args.effort,\n      project_name: args.projectName,\n      history: filterHistoryForStorage(args.history),\n      tools: args.tools?.length ? args.tools : undefined,\n      is_image_generation: args.imageGeneration,\n      json_schema: args.jsonSchema ?? null,\n    });\n  }\n\n  // DB 준비 중에 재시작이 시작됐다면 provider 실행으로 넘어가지 않는다.\n  // 이 요청은 재시작 snapshot에 없었으므로 방금 준비한 run을 직접 마감한다.\n  if (isRestartPending()) {\n    await finishTerminalRun(requestLogId, \"error\", \"server restarted\");\n    throw restartUnavailable();\n  }\n\n  registerNativeRun(requestLogId);\n  return { requestLogId, stepIndex };\n}\n\nexport async function afterQuery(\n  requestLogId: number,\n  stepIndex: number,\n  args: QueryInput,\n  result: QueryOutput,\n): Promise<RunLifecycleResult> {\n  if (interruptedNativeRunIds.has(requestLogId)) return {};\n\n  return trackNativeFinalizer(requestLogId, async () => {\n    try {\n      // provider가 canonical model을 돌려줘도 요청 route 자체([1m] 등)는 보존한다.\n      const requestedModelName = withProviderPrefix(\n        args.model,\n        args.model ?? result.requestedModel ?? result.model,\n      );\n      const servedModelName = withProviderPrefix(args.model, result.model);\n\n      // generate step 기록\n      await RequestLogModel.appendStep(requestLogId, {\n        step_index: stepIndex,\n        type: \"generate\",\n        model_name: servedModelName,\n        requested_model_name: requestedModelName,\n        fallback_count: result.modelFallbacks?.length ?? 0,\n        input_tokens: result.usage.input_tokens,\n        output_tokens: result.usage.output_tokens,\n        cache_read_tokens: result.usage.cache_read_input_tokens,\n        cache_creation_tokens: result.usage.cache_creation_input_tokens,\n        cache_creation_5m_tokens: result.usage.cache_creation_5m_input_tokens,\n        cache_creation_1h_tokens: result.usage.cache_creation_1h_input_tokens,\n        cost_usd: Math.round(result.costUsd * 1_000_000),\n        cost_source: result.costSource,\n        duration_ms: result.durationMs,\n        ttft_ms: result.ttftMs,\n        finish_reason: result.finishReason,\n      });\n\n      const imageParts = getImageParts(result);\n      const imageCostMicroUsd = estimateImageGenerationCostMicroUsd(\n        result,\n        args.imageGenerationOptions,\n      );\n      for (const step of buildImageGenerationToolSteps(args, imageParts, stepIndex)) {\n        await RequestLogModel.appendStep(requestLogId, step);\n      }\n\n      if (result.finishReason === \"tool-calls\") {\n        // tool-call step을 즉시 기록하고, 다음 follow-up이 같은 row에 결과를 채운다.\n        const toolCalls = result.content.filter((c) => c.type === \"tool-call\");\n        for (let i = 0; i < toolCalls.length; i++) {\n          const tc = toolCalls[i]!;\n          if (tc.type !== \"tool-call\") continue;\n          await RequestLogModel.appendStep(requestLogId, {\n            step_index: stepIndex,\n            type: \"tool_call\",\n            tool_call_index: imageParts.length + i,\n            tool_call_id: tc.toolCallId,\n            tool_name: tc.toolName,\n            tool_args: tc.input,\n          });\n        }\n\n        return { runContext: { requestLogId } };\n      }\n\n      // finishReason === \"stop\" → run 종료 (전체 step usage 합산)\n      const agg = await RequestLogModel.aggregateStepUsage(requestLogId);\n      const responseText = formatResponseForLog(result);\n      await RequestLogModel.finishRun(requestLogId, {\n        status: \"succeeded\",\n        response: responseText,\n        // structured 요청만 판정한다. deti 배치의 broken JSON 류를 목록에서 바로\n        // 구별하기 위한 기록이며, 비structured 요청은 null 로 남는다.\n        response_json_ok: args.jsonSchema ? isParseableJson(responseText) : null,\n        token_name: result.tokenName,\n        input_tokens: agg.input_tokens,\n        output_tokens: agg.output_tokens,\n        cache_read_tokens: agg.cache_read_tokens,\n        cache_creation_tokens: agg.cache_creation_tokens,\n        cache_creation_5m_tokens: agg.cache_creation_5m_tokens,\n        cache_creation_1h_tokens: agg.cache_creation_1h_tokens,\n        duration_ms: agg.duration_ms,\n        // multi-step run 부모의 모델은 최종 turn을 서빙한 모델이다.\n        requested_model_name: requestedModelName,\n        model_name: servedModelName,\n        fallback_count: agg.fallback_count,\n        cost_usd: agg.cost_usd,\n        cost_source: agg.cost_source,\n        image_cost_usd: imageCostMicroUsd,\n        image_cost_method:\n          imageCostMicroUsd !== null\n            ? imageGenerationCostMethod(args.imageGenerationOptions)\n            : null,\n        history: filterHistoryForStorage(args.history),\n      });\n\n      return {};\n    } finally {\n      releaseNativeRun(requestLogId);\n    }\n  });\n}\n\nexport async function finishRunWithError(\n  requestLogId: number,\n  errorMessage: string,\n  args?: QueryInput,\n): Promise<void> {\n  if (interruptedNativeRunIds.has(requestLogId)) return;\n  return trackNativeFinalizer(requestLogId, async () => {\n    try {\n      await finishTerminalRun(requestLogId, \"error\", errorMessage, args);\n    } finally {\n      releaseNativeRun(requestLogId);\n    }\n  });\n}\n\nexport async function finishRunAborted(requestLogId: number, args?: QueryInput): Promise<void> {\n  if (interruptedNativeRunIds.has(requestLogId)) return;\n  return trackNativeFinalizer(requestLogId, async () => {\n    try {\n      await finishTerminalRun(requestLogId, \"aborted\", \"client disconnected\", args);\n    } finally {\n      releaseNativeRun(requestLogId);\n    }\n  });\n}\n\n/** 현재 이 프로세스가 provider를 실행 중인 native run만 재시작 오류로 마감한다. */\nexport async function finishActiveNativeRunsForRestart(): Promise<void> {\n  const requestLogIds = [...activeNativeRunRefs.keys()];\n  for (const requestLogId of requestLogIds) {\n    interruptedNativeRunIds.add(requestLogId);\n    activeNativeRunRefs.delete(requestLogId);\n  }\n\n  await Promise.all(\n    requestLogIds.map(async (requestLogId) => {\n      await Promise.all(activeNativeFinalizers.get(requestLogId) ?? []);\n      await finishTerminalRun(requestLogId, \"error\", \"server restarted\");\n    }),\n  );\n}\n\n/** 프로세스 전역 registry를 격리해야 하는 단위 테스트 전용. */\nexport function resetNativeRunRegistryForTests(): void {\n  activeNativeRunRefs.clear();\n  interruptedNativeRunIds.clear();\n  activeNativeFinalizers.clear();\n}\n\nasync function finishTerminalRun(\n  requestLogId: number,\n  status: \"error\" | \"aborted\",\n  errorMessage: string,\n  args?: QueryInput,\n): Promise<void> {\n  try {\n    let aggregate: Awaited<ReturnType<typeof RequestLogModel.aggregateStepUsage>> | undefined;\n    try {\n      aggregate = await RequestLogModel.aggregateStepUsage(requestLogId);\n    } catch (e) {\n      logger.error(`aggregateStepUsage failed while finishing ${status}: ${(e as Error).message}`);\n    }\n\n    await RequestLogModel.finishRun(requestLogId, {\n      status,\n      error_message: errorMessage,\n      history: args ? filterHistoryForStorage(args.history) : undefined,\n      ...(aggregate\n        ? {\n            input_tokens: aggregate.input_tokens,\n            output_tokens: aggregate.output_tokens,\n            cache_read_tokens: aggregate.cache_read_tokens,\n            cache_creation_tokens: aggregate.cache_creation_tokens,\n            cache_creation_5m_tokens: aggregate.cache_creation_5m_tokens,\n            cache_creation_1h_tokens: aggregate.cache_creation_1h_tokens,\n            duration_ms: aggregate.duration_ms,\n            fallback_count: aggregate.fallback_count,\n            cost_usd: aggregate.cost_usd,\n            cost_source: aggregate.cost_source,\n          }\n        : {}),\n    });\n  } catch (e) {\n    logger.error(`finishTerminalRun(${status}) failed: ${(e as Error).message}`);\n  }\n}\n\nasync function cleanupStaleRuns(): Promise<void> {\n  if (staleCleanupInFlight) {\n    await staleCleanupInFlight;\n    return;\n  }\n\n  const now = Date.now();\n  if (now - lastStaleCleanupStartedAt < STALE_CLEANUP_INTERVAL_MS) return;\n  lastStaleCleanupStartedAt = now;\n\n  const cleanup = performStaleRunCleanup();\n  staleCleanupInFlight = cleanup;\n  try {\n    await cleanup;\n  } finally {\n    if (staleCleanupInFlight === cleanup) staleCleanupInFlight = undefined;\n  }\n}\n\nasync function performStaleRunCleanup(): Promise<void> {\n  try {\n    const errorMessage = \"tool-call run: no follow-up within 30 minutes\";\n    const staleIds = await RequestLogModel.expireStaleToolWaitingRuns(\n      STALE_RUN_THRESHOLD_MS,\n      errorMessage,\n    );\n    const cleanedCount = staleIds.length;\n    if (cleanedCount > 0) {\n      logger.info(`cleaned up ${cleanedCount} stale running request logs`);\n    }\n  } catch (e) {\n    logger.error(`stale cleanup failed: ${(e as Error).message}`);\n  }\n}\n"],"mappings":"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"}