@cartanova/qgrid-cli 2.4.5 → 2.4.6

package/bundle/dist/application/monit/log-buffer.js

@@ -0,0 +1,76 @@
+import "../../_virtual/_rolldown/runtime.js";
+//#region src/application/monit/log-buffer.ts
+const DEFAULT_CAPACITY = 2e3;
+const DEFAULT_MAX_TEXT_LENGTH = 4e3;
+function flattenMessage(message) {
+	return message.map((part, index) => index % 2 === 0 ? String(part ?? "") : renderValue(part)).join("");
+}
+function renderValue(value) {
+	if (typeof value === "string") return value;
+	if (value instanceof Error) return value.message;
+	try {
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+var MonitLogBuffer = class {
+	processStartedAt = Date.now();
+	entries = [];
+	nextSeq = 1;
+	constructor(capacity = DEFAULT_CAPACITY, maxTextLength = DEFAULT_MAX_TEXT_LENGTH) {
+		this.capacity = capacity;
+		this.maxTextLength = maxTextLength;
+	}
+	push(record) {
+		try {
+			let text = flattenMessage(record.message);
+			if (text.length > this.maxTextLength) text = `${text.slice(0, this.maxTextLength)}…`;
+			this.entries.push({
+				seq: this.nextSeq++,
+				timestamp: record.timestamp,
+				level: record.level,
+				category: [...record.category],
+				text
+			});
+			if (this.entries.length > this.capacity) this.entries.splice(0, this.entries.length - this.capacity);
+		} catch {}
+	}
+	get oldestSeq() {
+		return this.entries[0]?.seq ?? this.nextSeq;
+	}
+	get latestSeq() {
+		return this.nextSeq - 1;
+	}
+	after(cursor, limit) {
+		if (cursor === void 0) {
+			const entries = this.entries.slice(-limit);
+			return {
+				entries,
+				nextCursor: entries.at(-1)?.seq ?? this.latestSeq,
+				dropped: 0
+			};
+		}
+		if (cursor > this.latestSeq) return {
+			entries: [],
+			nextCursor: this.latestSeq,
+			dropped: 0
+		};
+		const dropped = Math.max(this.oldestSeq - cursor - 1, 0);
+		const startIndex = this.entries.findIndex((entry) => entry.seq > cursor);
+		const entries = startIndex === -1 ? [] : this.entries.slice(startIndex, startIndex + limit);
+		return {
+			entries,
+			nextCursor: entries.at(-1)?.seq ?? cursor + dropped,
+			dropped
+		};
+	}
+};
+const monitLogBuffer = new MonitLogBuffer();
+const monitLogSink = (record) => {
+	monitLogBuffer.push(record);
+};
+//#endregion
+export { MonitLogBuffer, monitLogBuffer, monitLogSink };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,86 @@
+import "../../_virtual/_rolldown/runtime.js";
+import { monitLogBuffer } from "./log-buffer.js";
+import { __decorateMetadata } from "../../_virtual/_@oxc-project_runtime@0.122.0/helpers/decorateMetadata.js";
+import { __decorate } from "../../_virtual/_@oxc-project_runtime@0.122.0/helpers/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
+/**
+* Monit — 대시보드 Monit 탭용 프로세스 로그 관측 API.
+*
+* 읽기 전용. ring buffer 를 얇게 직접 읽으며(범용 쿼리 기계 없이),
+* request log 를 남기지 않는다. 접근 경계는 다른 대시보드 API 와 동일하다.
+*/
+const RESPONSE_ENTRY_LIMIT = 1e3;
+var MonitFrameClass = class extends BaseFrameClass {
+	constructor() {
+		super("Monit");
+	}
+	async monitLogs(cursor) {
+		return {
+			processStartedAt: monitLogBuffer.processStartedAt,
+			...monitLogBuffer.after(cursor, RESPONSE_ENTRY_LIMIT),
+			vitals: currentVitals()
+		};
+	}
+	async monitInfo() {
+		const pool = resolveOpenAIWorkerPoolConfig();
+		const host = process.env.HOST ?? "localhost";
+		const port = process.env.PORT ?? "44900";
+		const conn = activeDbConnection();
+		return {
+			serverUrl: `http://${host}:${port}`,
+			dbHost: conn.host ?? "localhost",
+			dbName: conn.database ?? "qgrid",
+			openai: {
+				minWorkersPerToken: pool.minWorkersPerToken,
+				maxWorkersPerToken: pool.maxWorkersPerToken,
+				autoscale: pool.autoscale
+			}
+		};
+	}
+};
+__decorate([
+	api({
+		httpMethod: "GET",
+		clients: ["axios", "tanstack-query"]
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [Number]),
+	__decorateMetadata("design:returntype", Promise)
+], MonitFrameClass.prototype, "monitLogs", null);
+__decorate([
+	api({
+		httpMethod: "GET",
+		clients: ["axios", "tanstack-query"]
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", []),
+	__decorateMetadata("design:returntype", Promise)
+], MonitFrameClass.prototype, "monitInfo", null);
+function currentVitals() {
+	return {
+		openaiWorkerCount: QgridDispatcher.openaiDispatcher?.workerCount ?? 0,
+		openaiReadyWorkerCount: QgridDispatcher.openaiDispatcher?.readyWorkerCount ?? 0,
+		openaiQueueLength: QgridDispatcher.openaiDispatcher?.queueLength ?? 0,
+		openaiWorkersByToken: QgridDispatcher.openaiDispatcher?.workerCountsByToken ?? [],
+		anthropicTokenCount: QgridDispatcher.anthropicDispatcher?.tokenCount ?? 0,
+		anthropicTokenNames: QgridDispatcher.anthropicDispatcher?.tokenNames ?? []
+	};
+}
+function activeDbConnection() {
+	try {
+		const connection = DB.getDBConfig("w").connection;
+		if (typeof connection === "object" && connection !== null) return connection;
+	} catch {}
+	return {
+		host: process.env.QGRID_DB_HOST,
+		database: process.env.QGRID_DB_NAME
+	};
+}
+const MonitFrame = new MonitFrameClass();
+//#endregion
+export { MonitFrame };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,42 @@
+import "../../_virtual/_rolldown/runtime.js";
+import { z } from "zod";
+//#region src/application/monit/monit.types.ts
+const MonitLogEntry = z.object({
+	seq: z.number(),
+	timestamp: z.number(),
+	level: z.string(),
+	category: z.array(z.string()),
+	text: z.string()
+});
+const MonitVitals = z.object({
+	openaiWorkerCount: z.number(),
+	openaiReadyWorkerCount: z.number(),
+	openaiQueueLength: z.number(),
+	openaiWorkersByToken: z.array(z.object({
+		name: z.string(),
+		count: z.number()
+	})),
+	anthropicTokenCount: z.number(),
+	anthropicTokenNames: z.array(z.string())
+});
+const MonitLogChunk = z.object({
+	processStartedAt: z.number(),
+	entries: z.array(MonitLogEntry),
+	nextCursor: z.number(),
+	dropped: z.number(),
+	vitals: MonitVitals
+});
+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()
+	})
+});
+//#endregion
+export { MonitLogChunk, MonitLogEntry, MonitServerInfo, MonitVitals };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

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

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

@@ -1,9 +1,9 @@
 import "../../_virtual/_rolldown/runtime.js";
-import { decideConvRouting, issueConvContext } from "./conv-routing.js";
-import { calculateCostUsd } from "../../utils/providers/common/model-cost.js";
+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 { strictify } from "../../utils/providers/common/strictifier.js";
-import { ProcessError, QuotaError, maskToken } from "./qgrid.types.js";
+import { decideConvRouting, issueConvContext } from "./conv-routing.js";
 import { applyToolCallEmulation, buildToolCallSchema } from "./tool-emulation.js";
 //#region src/application/qgrid/qgrid.dispatcher.ts
 var QgridDispatcherClass = class {

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

@@ -1,19 +1,19 @@
 import "../../_virtual/_rolldown/runtime.js";
-import { buildAuthUrl, exchangeCodeForTokens, fetchUsage, generatePKCE, refreshAccessToken } from "./oauth.js";
-import { estimateImageGenerationCostMicroUsd, imageGenerationCostMethod } from "./qgrid-image-generation.js";
-import { buildImageGenerationToolSteps, formatResponseForLog, getImageParts } from "./qgrid-response-format.js";
+import { StreamEvents } from "./qgrid.types.js";
 import { __decorateMetadata } from "../../_virtual/_@oxc-project_runtime@0.122.0/helpers/decorateMetadata.js";
 import { __decorate } from "../../_virtual/_@oxc-project_runtime@0.122.0/helpers/decorate.js";
-import { MICRO_USD, RequestLogModel } from "../request-log/request-log.model.js";
-import { afterQuery, beforeQuery, finishRunAborted, finishRunWithError } from "./qgrid-run-lifecycle.js";
+import { TokenModel } from "../token/token.model.js";
+import { estimateImageGenerationCostMicroUsd, imageGenerationCostMethod } from "./qgrid-image-generation.js";
 import { getAccessToken, getExpiresAt, getRefreshToken } from "../../utils/providers/common/credentials.js";
-import { StreamEvents } from "./qgrid.types.js";
 import { QgridDispatcher } from "./qgrid.dispatcher.js";
-import { TokenModel } from "../token/token.model.js";
+import { buildAuthUrl, exchangeCodeForTokens, fetchUsage, generatePKCE, refreshAccessToken } from "./oauth.js";
+import { buildImageGenerationToolSteps, formatResponseForLog, getImageParts } from "./qgrid-response-format.js";
+import { MICRO_USD, RequestLogModel } from "../request-log/request-log.model.js";
+import { afterQuery, beforeQuery, finishRunAborted, finishRunWithError } from "./qgrid-run-lifecycle.js";
 import { TokenCredentials } from "../token/token.types.js";
-import crypto from "node:crypto";
-import { getLogger } from "@logtape/logtape";
 import { BadRequestException, BaseFrameClass, Sonamu, api, stream } from "sonamu";
+import { getLogger } from "@logtape/logtape";
+import crypto from "node:crypto";
 import { getCacheManagerRef } from "sonamu/cache";
 //#region src/application/qgrid/qgrid.frame.ts
 var _ref;

package/bundle/dist/application/queries.generated.js

@@ -32,7 +32,12 @@ let QgridService;
 	_QgridService.usage = (tokenId) => createSSRQuery("QgridFrame", "usage", [tokenId], ["Qgrid", "usage"]);
 	_QgridService.health = () => createSSRQuery("QgridFrame", "health", [], ["Qgrid", "health"]);
 })(QgridService || (QgridService = {}));
+let MonitService;
+(function(_MonitService) {
+	_MonitService.monitLogs = (cursor) => createSSRQuery("MonitFrame", "monitLogs", [cursor], ["Monit", "monitLogs"]);
+	_MonitService.monitInfo = () => createSSRQuery("MonitFrame", "monitInfo", [], ["Monit", "monitInfo"]);
+})(MonitService || (MonitService = {}));
 //#endregion
-export { QgridService, RequestLogService, RequestLogStepService, TokenService };
+export { MonitService, QgridService, RequestLogService, RequestLogStepService, TokenService };
 
-//# 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/request-log/request-log.model.js

@@ -1,9 +1,9 @@
 import "../../_virtual/_rolldown/runtime.js";
 import { SD } from "../../i18n/sd.generated.js";
-import { calculateCostUsd } from "../../utils/providers/common/model-cost.js";
 import { requestLogLoaderQueries, requestLogSubsetQueries } from "../sonamu.generated.sso.js";
 import { __decorateMetadata } from "../../_virtual/_@oxc-project_runtime@0.122.0/helpers/decorateMetadata.js";
 import { __decorate } from "../../_virtual/_@oxc-project_runtime@0.122.0/helpers/decorate.js";
+import { calculateCostUsd } from "../../utils/providers/common/model-cost.js";
 import { BadRequestException, BaseModelClass, NotFoundException, api, asArray, exhaustive } from "sonamu";
 //#region src/application/request-log/request-log.model.ts
 const MICRO_USD = 1e6;

package/bundle/dist/sonamu.config.js

@@ -1,12 +1,13 @@
 import "./_virtual/_rolldown/runtime.js";
+import { monitLogSink } from "./application/monit/log-buffer.js";
+import { OpenAIDispatcher } from "./utils/providers/openai/openai-dispatcher.js";
 import { QgridDispatcher } from "./application/qgrid/qgrid.dispatcher.js";
 import { QgridFrame } from "./application/qgrid/qgrid.frame.js";
 import { TokenSubscriber } from "./application/qgrid/token-subscriber.js";
 import { ensureTokensTrigger } from "./application/qgrid/token-trigger-setup.js";
 import { AnthropicDispatcher } from "./utils/providers/anthropic/anthropic-dispatcher.js";
-import { OpenAIDispatcher } from "./utils/providers/openai/openai-dispatcher.js";
-import { getConsoleSink, getLogger } from "@logtape/logtape";
 import { CachePresets, defineConfig } from "sonamu";
+import { getConsoleSink, getLogger } from "@logtape/logtape";
 import { drivers, store } from "sonamu/cache";
 import path from "path";
 import { getPrettyFormatter } from "@logtape/pretty";
@@ -58,20 +59,23 @@ var sonamu_config_default = defineConfig({
 		devRunner: { enabled: true }
 	},
 	logging: {
-		sinks: { console: getConsoleSink({ formatter: getPrettyFormatter({
-			timestamp: "time",
-			categoryWidth: 20,
-			categoryTruncate: "middle"
-		}) }) },
+		sinks: {
+			console: getConsoleSink({ formatter: getPrettyFormatter({
+				timestamp: "time",
+				categoryWidth: 20,
+				categoryTruncate: "middle"
+			}) }),
+			monit: monitLogSink
+		},
 		loggers: [
 			{
 				category: ["qgrid"],
-				sinks: ["console"],
+				sinks: ["console", "monit"],
 				lowestLevel: "info"
 			},
 			{
 				category: ["sonamu"],
-				sinks: ["console"],
+				sinks: ["console", "monit"],
 				lowestLevel: "warning"
 			},
 			{
@@ -195,4 +199,4 @@ var sonamu_config_default = defineConfig({
 //#endregion
 export { sonamu_config_default as default };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sonamu.config.js","names":["cacheDrivers"],"sources":["../src/sonamu.config.ts"],"sourcesContent":["import path from \"path\";\n\nimport { getConsoleSink } from \"@logtape/logtape\";\nimport { getLogger } from \"@logtape/logtape\";\nimport { getPrettyFormatter } from \"@logtape/pretty\";\nimport dotenv from \"dotenv\";\nimport { CachePresets, defineConfig } from \"sonamu\";\nimport { drivers as cacheDrivers, store } from \"sonamu/cache\";\n\nimport { QgridDispatcher } from \"./application/qgrid/qgrid.dispatcher\";\nimport { QgridFrame } from \"./application/qgrid/qgrid.frame\";\nimport { TokenSubscriber } from \"./application/qgrid/token-subscriber\";\nimport { ensureTokensTrigger } from \"./application/qgrid/token-trigger-setup\";\nimport { AnthropicDispatcher } from \"./utils/providers/anthropic/anthropic-dispatcher\";\nimport { OpenAIDispatcher } from \"./utils/providers/openai/openai-dispatcher\";\n\ndotenv.config({ path: path.join(import.meta.dirname, \"../.env\") });\n\nconst host = process.env.HOST ?? \"localhost\";\nconst port = Number(process.env.PORT ?? 44900);\n\nconst connConfig = {\n  host: process.env.QGRID_DB_HOST ?? \"localhost\",\n  port: Number(process.env.QGRID_DB_PORT ?? 5432),\n  user: process.env.QGRID_DB_USER ?? \"postgres\",\n  password: process.env.QGRID_DB_PASSWORD ?? \"postgres\",\n  database: process.env.QGRID_DB_NAME ?? \"qgrid\",\n};\n\nexport default defineConfig({\n  projectName: process.env.PROJECT_NAME ?? \"Qgrid\",\n  database: {\n    name: \"qgrid\",\n    defaultOptions: {\n      connection: {\n        ...connConfig,\n        keepAlive: true,\n        keepAliveInitialDelayMillis: 10000,\n      },\n    },\n    environments: {\n      fixture: {\n        connection: {\n          ...connConfig,\n          database: process.env.QGRID_DB_NAME,\n        },\n      },\n      test: {\n        connection: {\n          ...connConfig,\n          database: process.env.QGRID_DB_NAME,\n        },\n      },\n    },\n  },\n  api: {\n    dir: \"api\",\n    timezone: \"Asia/Seoul\",\n    route: {\n      prefix: \"/api\",\n    },\n  },\n  i18n: {\n    defaultLocale: \"ko\",\n    supportedLocales: [\"ko\", \"en\"],\n  },\n  sync: {\n    targets: [\"web\"],\n  },\n  test: {\n    parallel: true,\n    maxWorkers: 4,\n    devRunner: { enabled: true },\n  },\n  logging: {\n    sinks: {\n      console: getConsoleSink({\n        formatter: getPrettyFormatter({\n          timestamp: \"time\",\n          categoryWidth: 20,\n          categoryTruncate: \"middle\",\n        }),\n      }),\n    },\n    loggers: [\n      // qgrid 로그 (요청 분배, oauth/usage API)\n      { category: [\"qgrid\"], sinks: [\"console\"], lowestLevel: \"info\" },\n      // sonamu 로그는 warning 이상만\n      { category: [\"sonamu\"], sinks: [\"console\"], lowestLevel: \"warning\" },\n      // fastify 로그 차단\n      { category: [\"fastify\"], sinks: [], lowestLevel: \"fatal\" },\n    ],\n  },\n  server: {\n    listen: { port, host },\n    fastify: {\n      bodyLimit: 10 * 1024 * 1024,\n    },\n    plugins: {\n      formbody: true,\n      qs: true,\n      sse: true,\n      multipart: { limits: { fileSize: 1024 * 1024 * 30 } },\n      static: {\n        root: path.join(import.meta.dirname, \"/../\", \"public\"),\n        prefix: \"/api/public\",\n      },\n      custom: (server) => {\n        // OAuth 콜백 — Anthropic이 /callback으로 리다이렉트\n        server.get(\"/callback\", async (request, reply) => {\n          const { code, state } = request.query as { code?: string; state?: string };\n          if (!code || !state) {\n            return reply.redirect(\"/?oauth=error&reason=missing_params\");\n          }\n          try {\n            return QgridFrame.handleOAuthCallback(code, state, reply);\n          } catch (e) {\n            return reply.redirect(\n              `/?oauth=error&reason=${encodeURIComponent((e as Error).message)}`,\n            );\n          }\n        });\n\n        // OpenAI OAuth 는 codex app-server 가 자체 callback 서버를 올림\n        // handleOpenAICallback 불필요 — oauthCompleteOpenAI API 로 완료 확인\n      },\n    },\n    apiConfig: {\n      contextProvider: (defaultContext, request) => {\n        return {\n          ...defaultContext,\n          ip: request.ip,\n          body: request.body,\n        };\n      },\n      guardHandler: () => {},\n      cacheControlHandler: (req) => {\n        switch (req.type) {\n          case \"assets\":\n            // Hash 포함된 파일: 영구 캐시\n            if (req.path.match(/-[a-f0-9]+\\./)) {\n              return CachePresets.immutable;\n            }\n            return CachePresets.longLived;\n\n          case \"api\":\n            // GET 요청만 캐싱 고려\n            if (req.method === \"GET\") {\n              // 특정 경로는 짧은 캐시\n              if (req.path.startsWith(\"/api/static-data\")) {\n                return CachePresets.shortLived;\n              }\n              if (req.path.startsWith(\"/api/terms\")) {\n                return CachePresets.mediumLived;\n              }\n            }\n            // 기본: 캐시 없음\n            return CachePresets.noCache;\n\n          case \"ssr\":\n            // SSR 페이지: 10초 캐시\n            return CachePresets.ssr;\n\n          case \"csr\":\n            // CSR fallback (index.html): 1분 캐시\n            return CachePresets.shortLived;\n        }\n        return CachePresets.noCache;\n      },\n    },\n    cache: {\n      default: \"main\",\n      stores: {\n        main: store().useL1Layer(cacheDrivers.memory({ maxSize: \"50mb\" })),\n      },\n      ttl: \"5m\",\n      prefix: \"\",\n    },\n    lifecycle: {\n      onStart: async () => {\n        const log = getLogger([\"qgrid\", \"startup\"]);\n\n        let triggerReady = true;\n        try {\n          await ensureTokensTrigger(connConfig);\n        } catch (e) {\n          triggerReady = false;\n          log.warn(`trigger setup failed: ${(e as Error).message}`);\n        }\n\n        const subscriber = new TokenSubscriber(connConfig, QgridDispatcher);\n        QgridDispatcher.subscriber = subscriber;\n\n        const started = await subscriber.start();\n\n        try {\n          const openaiDispatcher = new OpenAIDispatcher();\n          await openaiDispatcher.start();\n          QgridDispatcher.openaiDispatcher = openaiDispatcher;\n        } catch (e) {\n          log.warn(`openai dispatcher failed: ${(e as Error).message}`);\n        }\n\n        try {\n          const anthropicDispatcher = new AnthropicDispatcher();\n          await anthropicDispatcher.start();\n          QgridDispatcher.anthropicDispatcher = anthropicDispatcher;\n        } catch (e) {\n          log.warn(`anthropic dispatcher failed: ${(e as Error).message}`);\n        }\n\n        const anthropicCount = QgridDispatcher.anthropicDispatcher?.tokenCount ?? 0;\n        const openaiReady = QgridDispatcher.openaiDispatcher?.readyWorkerCount ?? 0;\n        const openaiTotal = QgridDispatcher.openaiDispatcher?.workerCount ?? 0;\n\n        log.info(`listening on http://${host}:${port}`);\n        log.info(`anthropic: ${anthropicCount} tokens ready`);\n        log.info(`openai: ${openaiReady}/${openaiTotal} tokens ready`);\n        log.info(\n          `subscriber: ${started ? \"LISTEN active\" : \"degraded\"}${triggerReady ? \"\" : \", trigger failed\"}`,\n        );\n      },\n      onShutdown: async () => {\n        const log = getLogger([\"qgrid\", \"startup\"]);\n        if (QgridDispatcher.openaiDispatcher) {\n          await QgridDispatcher.openaiDispatcher.stop();\n        }\n        if (QgridDispatcher.anthropicDispatcher) {\n          await QgridDispatcher.anthropicDispatcher.stop();\n        }\n        if (QgridDispatcher.subscriber) {\n          await QgridDispatcher.subscriber.stop();\n        }\n        log.info(\"graceful shutdown\");\n      },\n      onError: (error, _request, reply) => {\n        getLogger([\"qgrid\"]).error(`${error}`);\n        reply.status(500).send({\n          name: error.name,\n          message: error.message,\n        });\n      },\n    },\n  },\n});\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"sonamu.config.js","names":["cacheDrivers"],"sources":["../src/sonamu.config.ts"],"sourcesContent":["import path from \"path\";\n\nimport { getConsoleSink } from \"@logtape/logtape\";\nimport { getLogger } from \"@logtape/logtape\";\nimport { getPrettyFormatter } from \"@logtape/pretty\";\nimport dotenv from \"dotenv\";\nimport { CachePresets, defineConfig } from \"sonamu\";\nimport { drivers as cacheDrivers, store } from \"sonamu/cache\";\n\nimport { monitLogSink } from \"./application/monit/log-buffer\";\nimport { QgridDispatcher } from \"./application/qgrid/qgrid.dispatcher\";\nimport { QgridFrame } from \"./application/qgrid/qgrid.frame\";\nimport { TokenSubscriber } from \"./application/qgrid/token-subscriber\";\nimport { ensureTokensTrigger } from \"./application/qgrid/token-trigger-setup\";\nimport { AnthropicDispatcher } from \"./utils/providers/anthropic/anthropic-dispatcher\";\nimport { OpenAIDispatcher } from \"./utils/providers/openai/openai-dispatcher\";\n\ndotenv.config({ path: path.join(import.meta.dirname, \"../.env\") });\n\nconst host = process.env.HOST ?? \"localhost\";\nconst port = Number(process.env.PORT ?? 44900);\n\nconst connConfig = {\n  host: process.env.QGRID_DB_HOST ?? \"localhost\",\n  port: Number(process.env.QGRID_DB_PORT ?? 5432),\n  user: process.env.QGRID_DB_USER ?? \"postgres\",\n  password: process.env.QGRID_DB_PASSWORD ?? \"postgres\",\n  database: process.env.QGRID_DB_NAME ?? \"qgrid\",\n};\n\nexport default defineConfig({\n  projectName: process.env.PROJECT_NAME ?? \"Qgrid\",\n  database: {\n    name: \"qgrid\",\n    defaultOptions: {\n      connection: {\n        ...connConfig,\n        keepAlive: true,\n        keepAliveInitialDelayMillis: 10000,\n      },\n    },\n    environments: {\n      fixture: {\n        connection: {\n          ...connConfig,\n          database: process.env.QGRID_DB_NAME,\n        },\n      },\n      test: {\n        connection: {\n          ...connConfig,\n          database: process.env.QGRID_DB_NAME,\n        },\n      },\n    },\n  },\n  api: {\n    dir: \"api\",\n    timezone: \"Asia/Seoul\",\n    route: {\n      prefix: \"/api\",\n    },\n  },\n  i18n: {\n    defaultLocale: \"ko\",\n    supportedLocales: [\"ko\", \"en\"],\n  },\n  sync: {\n    targets: [\"web\"],\n  },\n  test: {\n    parallel: true,\n    maxWorkers: 4,\n    devRunner: { enabled: true },\n  },\n  logging: {\n    sinks: {\n      console: getConsoleSink({\n        formatter: getPrettyFormatter({\n          timestamp: \"time\",\n          categoryWidth: 20,\n          categoryTruncate: \"middle\",\n        }),\n      }),\n      // Monit 탭용 in-memory ring buffer. 포맷은 sink 별 — 콘솔 출력은 그대로다.\n      monit: monitLogSink,\n    },\n    loggers: [\n      // qgrid 로그 (요청 분배, oauth/usage API)\n      { category: [\"qgrid\"], sinks: [\"console\", \"monit\"], lowestLevel: \"info\" },\n      // sonamu 로그는 warning 이상만\n      { category: [\"sonamu\"], sinks: [\"console\", \"monit\"], lowestLevel: \"warning\" },\n      // fastify 로그 차단\n      { category: [\"fastify\"], sinks: [], lowestLevel: \"fatal\" },\n    ],\n  },\n  server: {\n    listen: { port, host },\n    fastify: {\n      bodyLimit: 10 * 1024 * 1024,\n    },\n    plugins: {\n      formbody: true,\n      qs: true,\n      sse: true,\n      multipart: { limits: { fileSize: 1024 * 1024 * 30 } },\n      static: {\n        root: path.join(import.meta.dirname, \"/../\", \"public\"),\n        prefix: \"/api/public\",\n      },\n      custom: (server) => {\n        // OAuth 콜백 — Anthropic이 /callback으로 리다이렉트\n        server.get(\"/callback\", async (request, reply) => {\n          const { code, state } = request.query as { code?: string; state?: string };\n          if (!code || !state) {\n            return reply.redirect(\"/?oauth=error&reason=missing_params\");\n          }\n          try {\n            return QgridFrame.handleOAuthCallback(code, state, reply);\n          } catch (e) {\n            return reply.redirect(\n              `/?oauth=error&reason=${encodeURIComponent((e as Error).message)}`,\n            );\n          }\n        });\n\n        // OpenAI OAuth 는 codex app-server 가 자체 callback 서버를 올림\n        // handleOpenAICallback 불필요 — oauthCompleteOpenAI API 로 완료 확인\n      },\n    },\n    apiConfig: {\n      contextProvider: (defaultContext, request) => {\n        return {\n          ...defaultContext,\n          ip: request.ip,\n          body: request.body,\n        };\n      },\n      guardHandler: () => {},\n      cacheControlHandler: (req) => {\n        switch (req.type) {\n          case \"assets\":\n            // Hash 포함된 파일: 영구 캐시\n            if (req.path.match(/-[a-f0-9]+\\./)) {\n              return CachePresets.immutable;\n            }\n            return CachePresets.longLived;\n\n          case \"api\":\n            // GET 요청만 캐싱 고려\n            if (req.method === \"GET\") {\n              // 특정 경로는 짧은 캐시\n              if (req.path.startsWith(\"/api/static-data\")) {\n                return CachePresets.shortLived;\n              }\n              if (req.path.startsWith(\"/api/terms\")) {\n                return CachePresets.mediumLived;\n              }\n            }\n            // 기본: 캐시 없음\n            return CachePresets.noCache;\n\n          case \"ssr\":\n            // SSR 페이지: 10초 캐시\n            return CachePresets.ssr;\n\n          case \"csr\":\n            // CSR fallback (index.html): 1분 캐시\n            return CachePresets.shortLived;\n        }\n        return CachePresets.noCache;\n      },\n    },\n    cache: {\n      default: \"main\",\n      stores: {\n        main: store().useL1Layer(cacheDrivers.memory({ maxSize: \"50mb\" })),\n      },\n      ttl: \"5m\",\n      prefix: \"\",\n    },\n    lifecycle: {\n      onStart: async () => {\n        const log = getLogger([\"qgrid\", \"startup\"]);\n\n        let triggerReady = true;\n        try {\n          await ensureTokensTrigger(connConfig);\n        } catch (e) {\n          triggerReady = false;\n          log.warn(`trigger setup failed: ${(e as Error).message}`);\n        }\n\n        const subscriber = new TokenSubscriber(connConfig, QgridDispatcher);\n        QgridDispatcher.subscriber = subscriber;\n\n        const started = await subscriber.start();\n\n        try {\n          const openaiDispatcher = new OpenAIDispatcher();\n          await openaiDispatcher.start();\n          QgridDispatcher.openaiDispatcher = openaiDispatcher;\n        } catch (e) {\n          log.warn(`openai dispatcher failed: ${(e as Error).message}`);\n        }\n\n        try {\n          const anthropicDispatcher = new AnthropicDispatcher();\n          await anthropicDispatcher.start();\n          QgridDispatcher.anthropicDispatcher = anthropicDispatcher;\n        } catch (e) {\n          log.warn(`anthropic dispatcher failed: ${(e as Error).message}`);\n        }\n\n        const anthropicCount = QgridDispatcher.anthropicDispatcher?.tokenCount ?? 0;\n        const openaiReady = QgridDispatcher.openaiDispatcher?.readyWorkerCount ?? 0;\n        const openaiTotal = QgridDispatcher.openaiDispatcher?.workerCount ?? 0;\n\n        log.info(`listening on http://${host}:${port}`);\n        log.info(`anthropic: ${anthropicCount} tokens ready`);\n        log.info(`openai: ${openaiReady}/${openaiTotal} tokens ready`);\n        log.info(\n          `subscriber: ${started ? \"LISTEN active\" : \"degraded\"}${triggerReady ? \"\" : \", trigger failed\"}`,\n        );\n      },\n      onShutdown: async () => {\n        const log = getLogger([\"qgrid\", \"startup\"]);\n        if (QgridDispatcher.openaiDispatcher) {\n          await QgridDispatcher.openaiDispatcher.stop();\n        }\n        if (QgridDispatcher.anthropicDispatcher) {\n          await QgridDispatcher.anthropicDispatcher.stop();\n        }\n        if (QgridDispatcher.subscriber) {\n          await QgridDispatcher.subscriber.stop();\n        }\n        log.info(\"graceful shutdown\");\n      },\n      onError: (error, _request, reply) => {\n        getLogger([\"qgrid\"]).error(`${error}`);\n        reply.status(500).send({\n          name: error.name,\n          message: error.message,\n        });\n      },\n    },\n  },\n});\n"],"mappings":"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"}

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

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