@cartanova/qgrid-cli 2.4.4 → 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;
@@ -379,11 +379,13 @@ var QgridFrameClass = class extends BaseFrameClass {
 					provider: "openai",
 					fiveHour: rl?.primary ? {
 						utilization: rl.primary.usedPercent,
-						resetsAt: unixSecondsToIso(rl.primary.resetsAt)
+						resetsAt: unixSecondsToIso(rl.primary.resetsAt),
+						windowDurationMins: rl.primary.windowDurationMins
 					} : null,
 					sevenDay: rl?.secondary ? {
 						utilization: rl.secondary.usedPercent,
-						resetsAt: unixSecondsToIso(rl.secondary.resetsAt)
+						resetsAt: unixSecondsToIso(rl.secondary.resetsAt),
+						windowDurationMins: rl.secondary.windowDurationMins
 					} : null
 				};
 			} catch (e) {
@@ -617,4 +619,4 @@ function convertAnthropicUsage(raw) {
 //#endregion
 export { QgridFrame };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"qgrid.frame.js","names":[],"sources":["../../../src/application/qgrid/qgrid.frame.ts"],"sourcesContent":["import crypto from \"node:crypto\";\n\nimport { getLogger } from \"@logtape/logtape\";\nimport { type FastifyReply } from \"fastify\";\nimport { api, BadRequestException, BaseFrameClass, Sonamu, stream } from \"sonamu\";\nimport { getCacheManagerRef } from \"sonamu/cache\";\n\nimport { type LocalizedString } from \"../../i18n/sd.generated\";\nimport {\n  getAccessToken,\n  getExpiresAt,\n  getRefreshToken,\n} from \"../../utils/providers/common/credentials\";\nimport { MICRO_USD, RequestLogModel } from \"../request-log/request-log.model\";\nimport { type TokenSubsetA } from \"../sonamu.generated\";\nimport { TokenModel, type TokenUpdateFields } from \"../token/token.model\";\nimport { TokenCredentials } from \"../token/token.types\";\nimport {\n  type AnthropicUsageRaw,\n  buildAuthUrl,\n  exchangeCodeForTokens,\n  fetchUsage,\n  generatePKCE,\n  refreshAccessToken,\n} from \"./oauth\";\nimport {\n  estimateImageGenerationCostMicroUsd,\n  imageGenerationCostMethod,\n} from \"./qgrid-image-generation\";\nimport {\n  buildImageGenerationToolSteps,\n  formatResponseForLog,\n  getImageParts,\n} from \"./qgrid-response-format\";\nimport {\n  afterQuery,\n  beforeQuery,\n  finishRunAborted,\n  finishRunWithError,\n} from \"./qgrid-run-lifecycle\";\nimport { QgridDispatcher } from \"./qgrid.dispatcher\";\nimport {\n  type QueryInput,\n  type AppendStepInput,\n  type CreateRunInput,\n  type FinishRunInput,\n  type HealthResponse,\n  type OAuthStartResult,\n  type QueryOutput,\n  type QgridRunContext,\n  StreamEvents,\n  type TokenStats,\n  type UsageResponse,\n} from \"./qgrid.types\";\n\nconst pendingStreams = new Map<string, QueryInput>();\n\ntype PendingOAuth = { codeVerifier: string; name: string; redirectUri: string };\nconst OAUTH_STATE_PREFIX = \"oauth:state:\";\nconst OAUTH_STATE_TTL = \"5m\";\n\nfunction unixSecondsToIso(seconds: number | null | undefined): string | null {\n  return typeof seconds === \"number\" ? new Date(seconds * 1000).toISOString() : null;\n}\n\nasync function setOAuthState(state: string, data: PendingOAuth): Promise<void> {\n  const cache = getCacheManagerRef();\n  if (!cache) throw new Error(\"CacheManager not initialized\");\n  await cache.set({\n    key: `${OAUTH_STATE_PREFIX}${state}`,\n    value: JSON.stringify(data),\n    ttl: OAUTH_STATE_TTL,\n  });\n}\n\nasync function getOAuthState(state: string): Promise<PendingOAuth | undefined> {\n  const cache = getCacheManagerRef();\n  if (!cache) throw new Error(\"CacheManager not initialized\");\n  const raw = await cache.get<string>({ key: `${OAUTH_STATE_PREFIX}${state}` });\n  if (!raw) return undefined;\n  return JSON.parse(raw) as PendingOAuth;\n}\n\nasync function deleteOAuthState(state: string): Promise<void> {\n  const cache = getCacheManagerRef();\n  if (!cache) return;\n  await cache.delete({ key: `${OAUTH_STATE_PREFIX}${state}` });\n}\n\nfunction getOAuthRedirectUri(): string {\n  const publicBaseUrl = process.env.QGRID_PUBLIC_BASE_URL?.replace(/\\/+$/, \"\");\n  if (publicBaseUrl) return `${publicBaseUrl}/callback`;\n\n  const serverPort = process.env.PORT ?? \"44900\";\n  return `http://localhost:${serverPort}/callback`;\n}\n\nfunction rejectImageGenerationStream(args: QueryInput): void {\n  if (!args.imageGeneration) return;\n  throw new BadRequestException(\n    \"qgrid: imageGeneration is not supported with streaming; use query/generateText instead.\" as LocalizedString,\n  );\n}\n\nconst logger = getLogger([\"qgrid\"]);\nconst oauthLogger = getLogger([\"qgrid\", \"oauth\"]);\n\nclass QgridFrameClass extends BaseFrameClass {\n  constructor() {\n    super(\"Qgrid\");\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async query(args: QueryInput): Promise<QueryOutput> {\n    const effectiveLogMode = args.logMode ?? (args.isStep ? \"run\" : \"auto\");\n\n    // logMode: \"run\" → 서버가 lifecycle 관리\n    if (effectiveLogMode === \"run\") {\n      const { requestLogId, stepIndex } = await beforeQuery(args);\n      try {\n        const result = await QgridDispatcher.query(args, args.timeout);\n        const lifecycle = await afterQuery(requestLogId, stepIndex, args, result);\n        // lifecycle.runContext(requestLogId) 와 dispatcher 가 실은 threadCoord 를 병합.\n        return {\n          ...result,\n          runContext: { ...lifecycle.runContext, threadCoord: result.runContext?.threadCoord },\n        };\n      } catch (e) {\n        await finishRunWithError(requestLogId, (e as Error).message, args);\n        throw e;\n      }\n    }\n\n    // logMode: \"auto\" (기존 non-step 경로) 또는 \"none\"\n    const result = await QgridDispatcher.query(args, args.timeout);\n\n    if (effectiveLogMode === \"auto\") {\n      this.saveAutoRequestLog(args, result);\n    }\n\n    return result;\n  }\n\n  // logMode \"auto\" 단일 요청 로깅: run lifecycle(step 분해) 없이 request_log 1건만 남긴다.\n  // query와 queryStream 양쪽에서 사용.\n  private saveAutoRequestLog(args: QueryInput, result: QueryOutput): void {\n    const imageParts = getImageParts(result);\n    const imageCostMicroUsd = estimateImageGenerationCostMicroUsd(\n      result,\n      args.imageGenerationOptions,\n    );\n    const toolCallCount = result.content.filter((item) => item.type === \"tool-call\").length;\n    const responseText = formatResponseForLog(result);\n\n    RequestLogModel.save([\n      {\n        token_name: result.tokenName,\n        project_name: args.projectName?.length ? args.projectName : null,\n        model_name: result.model ?? null,\n        user_prompt: args.prompt,\n        system_prompt: args.system ?? null,\n        response: responseText,\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        duration_ms: result.durationMs,\n        ttft_ms: result.ttftMs,\n        cost_usd: result.costUsd !== null ? Math.round(result.costUsd * MICRO_USD) : null,\n        image_cost_usd: imageCostMicroUsd,\n        image_cost_method:\n          imageCostMicroUsd !== null\n            ? imageGenerationCostMethod(args.imageGenerationOptions)\n            : null,\n        effort: args.effort ?? null,\n        // malformed history가 와도 성공한 턴(특히 stream sse.end())을 깨지 않도록 방어.\n        history: ((): { type: string }[] | null => {\n          try {\n            return args.history ? JSON.parse(args.history) : null;\n          } catch {\n            return null;\n          }\n        })(),\n        status: \"succeeded\",\n        tool_call_count: toolCallCount,\n        // 이미지 turn 식별(R13): quota 소모를 이미지 워크로드에 귀속.\n        is_image_generation: args.imageGeneration ?? false,\n      },\n    ])\n      .then(async (ids) => {\n        const requestLogId = ids[0];\n        if (!requestLogId || imageParts.length === 0) return;\n        for (const step of buildImageGenerationToolSteps(args, imageParts, 0)) {\n          await RequestLogModel.appendStep(requestLogId, step);\n        }\n      })\n      .catch((e) => logger.error(`requestLog save failed: ${(e as Error).message}`));\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async prepareStream(args: QueryInput): Promise<{ streamId: string }> {\n    rejectImageGenerationStream(args);\n    const streamId = crypto.randomUUID();\n    pendingStreams.set(streamId, args);\n    setTimeout(() => pendingStreams.delete(streamId), 30_000);\n    return { streamId };\n  }\n\n  @stream({ type: \"sse\", events: StreamEvents })\n  async queryStream(streamId: string): Promise<void> {\n    const args = pendingStreams.get(streamId);\n    pendingStreams.delete(streamId);\n    if (!args) throw new Error(\"invalid or expired streamId\");\n    rejectImageGenerationStream(args);\n\n    const effectiveLogMode = args.logMode ?? (args.isStep ? \"run\" : \"auto\");\n    const shouldLog = effectiveLogMode === \"run\";\n\n    let runInfo: { requestLogId: number; stepIndex: number } | undefined;\n    if (shouldLog) {\n      try {\n        runInfo = await beforeQuery(args);\n      } catch (e) {\n        logger.error(`stream beforeQuery failed: ${(e as Error).message}`);\n      }\n    }\n\n    const ctx = Sonamu.getContext();\n    const sse = ctx.createSSE(StreamEvents);\n    let threadId: string | undefined;\n    let turnId: string | undefined;\n    let streamResult: QueryOutput | undefined;\n    let streamError: Error | undefined;\n    const abortController = new AbortController();\n\n    const interruptOpenAI = () => {\n      if (threadId && turnId) {\n        QgridDispatcher.openaiDispatcher?.interruptWorkerTurn(threadId, turnId).catch(() => {});\n      }\n    };\n\n    sse.onClose(() => {\n      abortController.abort();\n      interruptOpenAI();\n    });\n\n    try {\n      await QgridDispatcher.queryStream(\n        args,\n        {\n          onDelta: (text) => {\n            if (!sse.closed) sse.publish(\"delta\", { text });\n          },\n          onThreadId: (id) => {\n            threadId = id;\n            if (sse.closed && turnId) {\n              interruptOpenAI();\n            }\n          },\n          onTurnId: (id) => {\n            turnId = id;\n            if (sse.closed && threadId) {\n              interruptOpenAI();\n            }\n          },\n          onComplete: (result) => {\n            streamResult = result;\n          },\n          onError: (err) => {\n            streamError = err;\n          },\n        },\n        abortController.signal,\n      );\n    } catch (e) {\n      streamError = e as Error;\n    }\n\n    // dispatcher 완료 후 lifecycle 처리 (await 안전)\n    if (streamResult) {\n      // dispatcher 가 실은 thread 재사용 좌표 (auto/run 공통으로 클라에 회송해야 함).\n      const threadCoord = streamResult.runContext?.threadCoord;\n      let runContext: QgridRunContext | undefined =\n        threadCoord !== undefined ? { threadCoord } : undefined;\n      if (runInfo) {\n        try {\n          const lifecycle = await afterQuery(\n            runInfo.requestLogId,\n            runInfo.stepIndex,\n            args,\n            streamResult,\n          );\n          runContext = { ...lifecycle.runContext, threadCoord };\n        } catch (e) {\n          logger.error(`stream afterQuery failed: ${(e as Error).message}`);\n        }\n      } else if (effectiveLogMode === \"auto\") {\n        // run lifecycle을 안 타는 단일 stream 요청도 request_log 1건은 남긴다 (query와 대칭).\n        this.saveAutoRequestLog(args, streamResult);\n      }\n      if (!sse.closed) sse.publish(\"done\", { ...streamResult, runContext });\n    } else if (streamError) {\n      if (sse.closed && streamError.message === \"aborted\") {\n        if (runInfo) await finishRunAborted(runInfo.requestLogId, args);\n        await sse.end();\n        return;\n      }\n      if (runInfo) await finishRunWithError(runInfo.requestLogId, streamError.message, args);\n      if (!sse.closed) sse.publish(\"error\", { message: streamError.message });\n    } else if (sse.closed && runInfo) {\n      await finishRunAborted(runInfo.requestLogId, args);\n    }\n\n    await sse.end();\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async createRun(input: CreateRunInput): Promise<{ requestLogId: number }> {\n    const requestLogId = await RequestLogModel.createRun({\n      user_prompt: input.userPrompt,\n      model_name: input.modelName,\n      effort: input.effort,\n      project_name: input.projectName,\n      system_prompt: input.systemPrompt,\n      history: input.history ? JSON.parse(input.history) : undefined,\n    });\n    return { requestLogId };\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async appendStep(input: AppendStepInput): Promise<{ stepId: number }> {\n    const stepId = await RequestLogModel.appendStep(input.requestLogId, {\n      step_index: input.stepIndex,\n      type: input.type,\n      input_tokens: input.inputTokens,\n      output_tokens: input.outputTokens,\n      cache_read_tokens: input.cacheReadTokens,\n      cache_creation_tokens: input.cacheCreationTokens,\n      duration_ms: input.durationMs,\n      ttft_ms: input.ttftMs ?? null,\n      finish_reason: input.finishReason,\n      reasoning_text: input.reasoningText,\n      reasoning_tokens: input.reasoningTokens,\n      tool_call_index: input.toolCallIndex,\n      tool_call_id: input.toolCallId,\n      tool_name: input.toolName,\n      tool_args: input.toolArgs,\n      tool_result: input.toolResult,\n      tool_duration_ms: input.toolDurationMs,\n      error: input.error,\n    });\n    return { stepId };\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async finishRun(input: FinishRunInput): Promise<{ ok: boolean }> {\n    await RequestLogModel.finishRun(input.requestLogId, {\n      status: input.status,\n      response: input.response,\n      token_name: input.tokenName,\n      input_tokens: input.totalInputTokens,\n      output_tokens: input.totalOutputTokens,\n      cache_read_tokens: input.totalCacheReadTokens,\n      cache_creation_tokens: input.totalCacheCreationTokens,\n      duration_ms: input.totalDurationMs,\n      history: input.history ? JSON.parse(input.history) : undefined,\n      error_message: input.errorMessage,\n    });\n    return { ok: true };\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"] })\n  async stats(): Promise<TokenStats[]> {\n    return QgridDispatcher.getStats();\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"] })\n  async totalCost(tokenName?: string): Promise<{ usd: number }> {\n    return { usd: await RequestLogModel.totalCost({ token_name: tokenName }) };\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"] })\n  async projectNames(): Promise<{ names: string[] }> {\n    return { names: await RequestLogModel.distinctProjectNames() };\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async addToken(\n    provider: string,\n    credentials: TokenCredentials,\n    name: string,\n  ): Promise<{ added: boolean }> {\n    await TokenModel.save([\n      {\n        provider,\n        credentials,\n        name,\n      },\n    ]);\n    return { added: true };\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\"] })\n  async updateToken(\n    id: number,\n    name?: string,\n    quotaThreshold?: number | null,\n    weight?: number,\n  ): Promise<{ updated: boolean }> {\n    if (\n      quotaThreshold !== undefined &&\n      quotaThreshold !== null &&\n      (!Number.isInteger(quotaThreshold) || quotaThreshold < 1 || quotaThreshold > 100)\n    ) {\n      throw new BadRequestException(\n        \"quotaThreshold must be an integer between 1 and 100, or null\" as LocalizedString,\n      );\n    }\n    if (weight !== undefined && (!Number.isInteger(weight) || weight < 1 || weight > 100)) {\n      throw new BadRequestException(\n        \"weight must be an integer between 1 and 100\" as LocalizedString,\n      );\n    }\n\n    const patch: TokenUpdateFields = {};\n    if (name !== undefined) patch.name = name;\n    if (quotaThreshold !== undefined) patch.quota_threshold = quotaThreshold;\n    if (weight !== undefined) patch.weight = weight;\n    if (Object.keys(patch).length === 0) return { updated: false };\n\n    const updated = await TokenModel.updateFields(id, patch);\n    return { updated: updated > 0 };\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async removeToken(id: number): Promise<{ removed: boolean }> {\n    const entry = await TokenModel.findOne(\"A\", { id });\n    if (!entry) return { removed: false };\n    await TokenModel.del([entry.id]);\n    return { removed: true };\n  }\n\n  /**\n   * 토큰 활성화/비활성화 토글 DB의 active 필드 업데이트\n   */\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async toggleToken(id: number): Promise<{ active: boolean }> {\n    const entry = await TokenModel.findOne(\"A\", { id });\n    if (!entry) return { active: false };\n\n    const newActive = !entry.active;\n    await TokenModel.save([\n      {\n        id,\n        provider: entry.provider,\n        credentials: entry.credentials,\n        active: newActive,\n        name: entry.name,\n      },\n    ]);\n    return { active: newActive };\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async oauthStart(name: string): Promise<OAuthStartResult> {\n    const { codeVerifier, codeChallenge, state } = generatePKCE();\n\n    const redirectUri = getOAuthRedirectUri();\n    const authUrl = buildAuthUrl(codeChallenge, state, redirectUri);\n\n    await setOAuthState(state, { codeVerifier, name, redirectUri });\n\n    return { authUrl };\n  }\n\n  async handleOAuthCallback(code: string, state: string, reply: FastifyReply): Promise<void> {\n    const pending = await getOAuthState(state);\n    if (!pending) {\n      logger.warn(\"oauth callback: invalid_state\");\n      return reply.redirect(\"/?oauth=error&reason=invalid_state\");\n    }\n    await deleteOAuthState(state);\n\n    try {\n      const tokens = await exchangeCodeForTokens(\n        code,\n        pending.codeVerifier,\n        state,\n        pending.redirectUri,\n      );\n\n      if (tokens.accountUuid) {\n        const oldEntries = await TokenModel.findByAccountIdentifier(\n          \"A\",\n          \"anthropic\",\n          tokens.accountUuid,\n        );\n        if (oldEntries.length > 0) {\n          await TokenModel.del(oldEntries.map((o) => o.id));\n        }\n      }\n\n      await TokenModel.save([\n        {\n          provider: \"anthropic\",\n          credentials: {\n            accessToken: tokens.accessToken,\n            refreshToken: tokens.refreshToken,\n            expiresAt: tokens.expiresAt ?? 0,\n            accountUuid: tokens.accountUuid ?? \"\",\n          },\n          name: pending.name,\n        },\n      ]);\n\n      return reply.redirect(`/?oauth=success&name=${encodeURIComponent(pending.name)}`);\n    } catch (e) {\n      return reply.redirect(`/?oauth=error&reason=${encodeURIComponent((e as Error).message)}`);\n    }\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async oauthStartOpenAI(name: string): Promise<OAuthStartResult> {\n    if (!QgridDispatcher.openaiDispatcher) throw new Error(\"OpenAI dispatcher not initialized\");\n    const { authUrl } = await QgridDispatcher.openaiDispatcher.startBrowserLogin(name);\n\n    // fire-and-forget: codex login 완료 대기 → 토큰 저장\n    QgridDispatcher.openaiDispatcher\n      .completeBrowserLogin()\n      .then(async (creds) => {\n        if (creds.accountId) {\n          const oldEntries = await TokenModel.findByAccountIdentifier(\n            \"A\",\n            \"openai\",\n            creds.accountId,\n          );\n          if (oldEntries.length > 0) {\n            await TokenModel.del(oldEntries.map((o) => o.id));\n          }\n        }\n        await TokenModel.save([\n          {\n            provider: \"openai\",\n            credentials: {\n              accessToken: creds.accessToken,\n              refreshToken: creds.refreshToken,\n              idToken: creds.idToken,\n              accessTokenExpiresAt: Date.now() + 10 * 24 * 3600 * 1000,\n              accountId: creds.accountId,\n            },\n            name,\n          },\n        ]);\n        logger.info(`OpenAI token saved for ${name}`);\n      })\n      .catch((e) => {\n        logger.warn(`OpenAI browser login failed: ${(e as Error).message}`);\n      });\n\n    return { authUrl };\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"] })\n  async usage(tokenId?: number): Promise<UsageResponse> {\n    const { rows: allTokens } = await TokenModel.findMany(\"A\");\n    const entry = tokenId\n      ? allTokens.find((e) => e.id === tokenId)\n      : allTokens.findLast((e) => e.active && e.provider === \"anthropic\");\n\n    if (!entry) return { error: \"NOT_FOUND\" };\n\n    if (entry.provider === \"openai\") {\n      if (!entry.active) {\n        return { provider: \"openai\", fiveHour: null, sevenDay: null };\n      }\n\n      try {\n        const raw = await QgridDispatcher.openaiDispatcher?.getRateLimitsByTokenId(entry.id);\n        const rl = raw?.data.rateLimits;\n        return {\n          provider: \"openai\",\n          fiveHour: rl?.primary\n            ? {\n                utilization: rl.primary.usedPercent,\n                resetsAt: unixSecondsToIso(rl.primary.resetsAt),\n              }\n            : null,\n          sevenDay: rl?.secondary\n            ? {\n                utilization: rl.secondary.usedPercent,\n                resetsAt: unixSecondsToIso(rl.secondary.resetsAt),\n              }\n            : null,\n        };\n      } catch (e) {\n        return { error: `OpenAI usage failed: ${(e as Error).message}` };\n      }\n    }\n\n    if (entry.provider !== \"anthropic\") {\n      return { error: `usage API not supported for provider: ${entry.provider}` };\n    }\n\n    let accessToken = getAccessToken(entry.credentials);\n    const isExpired = getExpiresAt(entry.credentials) < Date.now();\n\n    if (isExpired && getRefreshToken(entry.credentials)) {\n      try {\n        accessToken = await this.refreshToken(entry);\n      } catch (e) {\n        oauthLogger.warn(`refresh failed for ${entry.name}: ${(e as Error).message}`);\n        return { error: \"re-login required\" };\n      }\n    }\n\n    const raw = await fetchUsage(accessToken);\n    if (raw.error && getRefreshToken(entry.credentials)) {\n      try {\n        accessToken = await this.refreshToken(entry);\n        const retried = await fetchUsage(accessToken);\n        if (retried.error) return { error: retried.error };\n        return convertAnthropicUsage(retried);\n      } catch (e) {\n        oauthLogger.warn(`refresh failed for ${entry.name}: ${(e as Error).message}`);\n        return { error: \"re-login required\" };\n      }\n    }\n    if (raw.error) return { error: raw.error };\n    return convertAnthropicUsage(raw);\n  }\n\n  async refreshToken(token: TokenSubsetA): Promise<string> {\n    const creds = token.credentials;\n    const rt = getRefreshToken(creds);\n    if (!rt) throw new Error(\"No refresh token\");\n    const refreshed = await refreshAccessToken(rt);\n    const updated = TokenCredentials.parse({\n      ...creds,\n      accessToken: refreshed.accessToken,\n      refreshToken: refreshed.refreshToken,\n      expiresAt: refreshed.expiresAt,\n    });\n    await TokenModel.save([\n      {\n        id: token.id,\n        provider: token.provider,\n        credentials: updated,\n        name: token.name,\n      },\n    ]);\n    return refreshed.accessToken;\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"] })\n  async health(): Promise<HealthResponse> {\n    return {\n      status: \"ok\",\n      activeTokens: QgridDispatcher.tokens.size,\n      subscriber: QgridDispatcher.subscriber?.status() ?? null,\n    };\n  }\n}\n\nexport const QgridFrame = new QgridFrameClass();\n\nfunction convertAnthropicUsage(raw: AnthropicUsageRaw): UsageResponse {\n  return {\n    provider: \"anthropic\",\n    fiveHour: raw.five_hour\n      ? { utilization: raw.five_hour.utilization, resetsAt: raw.five_hour.resets_at }\n      : null,\n    sevenDay: raw.seven_day\n      ? { utilization: raw.seven_day.utilization, resetsAt: raw.seven_day.resets_at }\n      : null,\n  };\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"qgrid.frame.js","names":[],"sources":["../../../src/application/qgrid/qgrid.frame.ts"],"sourcesContent":["import crypto from \"node:crypto\";\n\nimport { getLogger } from \"@logtape/logtape\";\nimport { type FastifyReply } from \"fastify\";\nimport { api, BadRequestException, BaseFrameClass, Sonamu, stream } from \"sonamu\";\nimport { getCacheManagerRef } from \"sonamu/cache\";\n\nimport { type LocalizedString } from \"../../i18n/sd.generated\";\nimport {\n  getAccessToken,\n  getExpiresAt,\n  getRefreshToken,\n} from \"../../utils/providers/common/credentials\";\nimport { MICRO_USD, RequestLogModel } from \"../request-log/request-log.model\";\nimport { type TokenSubsetA } from \"../sonamu.generated\";\nimport { TokenModel, type TokenUpdateFields } from \"../token/token.model\";\nimport { TokenCredentials } from \"../token/token.types\";\nimport {\n  type AnthropicUsageRaw,\n  buildAuthUrl,\n  exchangeCodeForTokens,\n  fetchUsage,\n  generatePKCE,\n  refreshAccessToken,\n} from \"./oauth\";\nimport {\n  estimateImageGenerationCostMicroUsd,\n  imageGenerationCostMethod,\n} from \"./qgrid-image-generation\";\nimport {\n  buildImageGenerationToolSteps,\n  formatResponseForLog,\n  getImageParts,\n} from \"./qgrid-response-format\";\nimport {\n  afterQuery,\n  beforeQuery,\n  finishRunAborted,\n  finishRunWithError,\n} from \"./qgrid-run-lifecycle\";\nimport { QgridDispatcher } from \"./qgrid.dispatcher\";\nimport {\n  type QueryInput,\n  type AppendStepInput,\n  type CreateRunInput,\n  type FinishRunInput,\n  type HealthResponse,\n  type OAuthStartResult,\n  type QueryOutput,\n  type QgridRunContext,\n  StreamEvents,\n  type TokenStats,\n  type UsageResponse,\n} from \"./qgrid.types\";\n\nconst pendingStreams = new Map<string, QueryInput>();\n\ntype PendingOAuth = { codeVerifier: string; name: string; redirectUri: string };\nconst OAUTH_STATE_PREFIX = \"oauth:state:\";\nconst OAUTH_STATE_TTL = \"5m\";\n\nfunction unixSecondsToIso(seconds: number | null | undefined): string | null {\n  return typeof seconds === \"number\" ? new Date(seconds * 1000).toISOString() : null;\n}\n\nasync function setOAuthState(state: string, data: PendingOAuth): Promise<void> {\n  const cache = getCacheManagerRef();\n  if (!cache) throw new Error(\"CacheManager not initialized\");\n  await cache.set({\n    key: `${OAUTH_STATE_PREFIX}${state}`,\n    value: JSON.stringify(data),\n    ttl: OAUTH_STATE_TTL,\n  });\n}\n\nasync function getOAuthState(state: string): Promise<PendingOAuth | undefined> {\n  const cache = getCacheManagerRef();\n  if (!cache) throw new Error(\"CacheManager not initialized\");\n  const raw = await cache.get<string>({ key: `${OAUTH_STATE_PREFIX}${state}` });\n  if (!raw) return undefined;\n  return JSON.parse(raw) as PendingOAuth;\n}\n\nasync function deleteOAuthState(state: string): Promise<void> {\n  const cache = getCacheManagerRef();\n  if (!cache) return;\n  await cache.delete({ key: `${OAUTH_STATE_PREFIX}${state}` });\n}\n\nfunction getOAuthRedirectUri(): string {\n  const publicBaseUrl = process.env.QGRID_PUBLIC_BASE_URL?.replace(/\\/+$/, \"\");\n  if (publicBaseUrl) return `${publicBaseUrl}/callback`;\n\n  const serverPort = process.env.PORT ?? \"44900\";\n  return `http://localhost:${serverPort}/callback`;\n}\n\nfunction rejectImageGenerationStream(args: QueryInput): void {\n  if (!args.imageGeneration) return;\n  throw new BadRequestException(\n    \"qgrid: imageGeneration is not supported with streaming; use query/generateText instead.\" as LocalizedString,\n  );\n}\n\nconst logger = getLogger([\"qgrid\"]);\nconst oauthLogger = getLogger([\"qgrid\", \"oauth\"]);\n\nclass QgridFrameClass extends BaseFrameClass {\n  constructor() {\n    super(\"Qgrid\");\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async query(args: QueryInput): Promise<QueryOutput> {\n    const effectiveLogMode = args.logMode ?? (args.isStep ? \"run\" : \"auto\");\n\n    // logMode: \"run\" → 서버가 lifecycle 관리\n    if (effectiveLogMode === \"run\") {\n      const { requestLogId, stepIndex } = await beforeQuery(args);\n      try {\n        const result = await QgridDispatcher.query(args, args.timeout);\n        const lifecycle = await afterQuery(requestLogId, stepIndex, args, result);\n        // lifecycle.runContext(requestLogId) 와 dispatcher 가 실은 threadCoord 를 병합.\n        return {\n          ...result,\n          runContext: { ...lifecycle.runContext, threadCoord: result.runContext?.threadCoord },\n        };\n      } catch (e) {\n        await finishRunWithError(requestLogId, (e as Error).message, args);\n        throw e;\n      }\n    }\n\n    // logMode: \"auto\" (기존 non-step 경로) 또는 \"none\"\n    const result = await QgridDispatcher.query(args, args.timeout);\n\n    if (effectiveLogMode === \"auto\") {\n      this.saveAutoRequestLog(args, result);\n    }\n\n    return result;\n  }\n\n  // logMode \"auto\" 단일 요청 로깅: run lifecycle(step 분해) 없이 request_log 1건만 남긴다.\n  // query와 queryStream 양쪽에서 사용.\n  private saveAutoRequestLog(args: QueryInput, result: QueryOutput): void {\n    const imageParts = getImageParts(result);\n    const imageCostMicroUsd = estimateImageGenerationCostMicroUsd(\n      result,\n      args.imageGenerationOptions,\n    );\n    const toolCallCount = result.content.filter((item) => item.type === \"tool-call\").length;\n    const responseText = formatResponseForLog(result);\n\n    RequestLogModel.save([\n      {\n        token_name: result.tokenName,\n        project_name: args.projectName?.length ? args.projectName : null,\n        model_name: result.model ?? null,\n        user_prompt: args.prompt,\n        system_prompt: args.system ?? null,\n        response: responseText,\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        duration_ms: result.durationMs,\n        ttft_ms: result.ttftMs,\n        cost_usd: result.costUsd !== null ? Math.round(result.costUsd * MICRO_USD) : null,\n        image_cost_usd: imageCostMicroUsd,\n        image_cost_method:\n          imageCostMicroUsd !== null\n            ? imageGenerationCostMethod(args.imageGenerationOptions)\n            : null,\n        effort: args.effort ?? null,\n        // malformed history가 와도 성공한 턴(특히 stream sse.end())을 깨지 않도록 방어.\n        history: ((): { type: string }[] | null => {\n          try {\n            return args.history ? JSON.parse(args.history) : null;\n          } catch {\n            return null;\n          }\n        })(),\n        status: \"succeeded\",\n        tool_call_count: toolCallCount,\n        // 이미지 turn 식별(R13): quota 소모를 이미지 워크로드에 귀속.\n        is_image_generation: args.imageGeneration ?? false,\n      },\n    ])\n      .then(async (ids) => {\n        const requestLogId = ids[0];\n        if (!requestLogId || imageParts.length === 0) return;\n        for (const step of buildImageGenerationToolSteps(args, imageParts, 0)) {\n          await RequestLogModel.appendStep(requestLogId, step);\n        }\n      })\n      .catch((e) => logger.error(`requestLog save failed: ${(e as Error).message}`));\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async prepareStream(args: QueryInput): Promise<{ streamId: string }> {\n    rejectImageGenerationStream(args);\n    const streamId = crypto.randomUUID();\n    pendingStreams.set(streamId, args);\n    setTimeout(() => pendingStreams.delete(streamId), 30_000);\n    return { streamId };\n  }\n\n  @stream({ type: \"sse\", events: StreamEvents })\n  async queryStream(streamId: string): Promise<void> {\n    const args = pendingStreams.get(streamId);\n    pendingStreams.delete(streamId);\n    if (!args) throw new Error(\"invalid or expired streamId\");\n    rejectImageGenerationStream(args);\n\n    const effectiveLogMode = args.logMode ?? (args.isStep ? \"run\" : \"auto\");\n    const shouldLog = effectiveLogMode === \"run\";\n\n    let runInfo: { requestLogId: number; stepIndex: number } | undefined;\n    if (shouldLog) {\n      try {\n        runInfo = await beforeQuery(args);\n      } catch (e) {\n        logger.error(`stream beforeQuery failed: ${(e as Error).message}`);\n      }\n    }\n\n    const ctx = Sonamu.getContext();\n    const sse = ctx.createSSE(StreamEvents);\n    let threadId: string | undefined;\n    let turnId: string | undefined;\n    let streamResult: QueryOutput | undefined;\n    let streamError: Error | undefined;\n    const abortController = new AbortController();\n\n    const interruptOpenAI = () => {\n      if (threadId && turnId) {\n        QgridDispatcher.openaiDispatcher?.interruptWorkerTurn(threadId, turnId).catch(() => {});\n      }\n    };\n\n    sse.onClose(() => {\n      abortController.abort();\n      interruptOpenAI();\n    });\n\n    try {\n      await QgridDispatcher.queryStream(\n        args,\n        {\n          onDelta: (text) => {\n            if (!sse.closed) sse.publish(\"delta\", { text });\n          },\n          onThreadId: (id) => {\n            threadId = id;\n            if (sse.closed && turnId) {\n              interruptOpenAI();\n            }\n          },\n          onTurnId: (id) => {\n            turnId = id;\n            if (sse.closed && threadId) {\n              interruptOpenAI();\n            }\n          },\n          onComplete: (result) => {\n            streamResult = result;\n          },\n          onError: (err) => {\n            streamError = err;\n          },\n        },\n        abortController.signal,\n      );\n    } catch (e) {\n      streamError = e as Error;\n    }\n\n    // dispatcher 완료 후 lifecycle 처리 (await 안전)\n    if (streamResult) {\n      // dispatcher 가 실은 thread 재사용 좌표 (auto/run 공통으로 클라에 회송해야 함).\n      const threadCoord = streamResult.runContext?.threadCoord;\n      let runContext: QgridRunContext | undefined =\n        threadCoord !== undefined ? { threadCoord } : undefined;\n      if (runInfo) {\n        try {\n          const lifecycle = await afterQuery(\n            runInfo.requestLogId,\n            runInfo.stepIndex,\n            args,\n            streamResult,\n          );\n          runContext = { ...lifecycle.runContext, threadCoord };\n        } catch (e) {\n          logger.error(`stream afterQuery failed: ${(e as Error).message}`);\n        }\n      } else if (effectiveLogMode === \"auto\") {\n        // run lifecycle을 안 타는 단일 stream 요청도 request_log 1건은 남긴다 (query와 대칭).\n        this.saveAutoRequestLog(args, streamResult);\n      }\n      if (!sse.closed) sse.publish(\"done\", { ...streamResult, runContext });\n    } else if (streamError) {\n      if (sse.closed && streamError.message === \"aborted\") {\n        if (runInfo) await finishRunAborted(runInfo.requestLogId, args);\n        await sse.end();\n        return;\n      }\n      if (runInfo) await finishRunWithError(runInfo.requestLogId, streamError.message, args);\n      if (!sse.closed) sse.publish(\"error\", { message: streamError.message });\n    } else if (sse.closed && runInfo) {\n      await finishRunAborted(runInfo.requestLogId, args);\n    }\n\n    await sse.end();\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async createRun(input: CreateRunInput): Promise<{ requestLogId: number }> {\n    const requestLogId = await RequestLogModel.createRun({\n      user_prompt: input.userPrompt,\n      model_name: input.modelName,\n      effort: input.effort,\n      project_name: input.projectName,\n      system_prompt: input.systemPrompt,\n      history: input.history ? JSON.parse(input.history) : undefined,\n    });\n    return { requestLogId };\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async appendStep(input: AppendStepInput): Promise<{ stepId: number }> {\n    const stepId = await RequestLogModel.appendStep(input.requestLogId, {\n      step_index: input.stepIndex,\n      type: input.type,\n      input_tokens: input.inputTokens,\n      output_tokens: input.outputTokens,\n      cache_read_tokens: input.cacheReadTokens,\n      cache_creation_tokens: input.cacheCreationTokens,\n      duration_ms: input.durationMs,\n      ttft_ms: input.ttftMs ?? null,\n      finish_reason: input.finishReason,\n      reasoning_text: input.reasoningText,\n      reasoning_tokens: input.reasoningTokens,\n      tool_call_index: input.toolCallIndex,\n      tool_call_id: input.toolCallId,\n      tool_name: input.toolName,\n      tool_args: input.toolArgs,\n      tool_result: input.toolResult,\n      tool_duration_ms: input.toolDurationMs,\n      error: input.error,\n    });\n    return { stepId };\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async finishRun(input: FinishRunInput): Promise<{ ok: boolean }> {\n    await RequestLogModel.finishRun(input.requestLogId, {\n      status: input.status,\n      response: input.response,\n      token_name: input.tokenName,\n      input_tokens: input.totalInputTokens,\n      output_tokens: input.totalOutputTokens,\n      cache_read_tokens: input.totalCacheReadTokens,\n      cache_creation_tokens: input.totalCacheCreationTokens,\n      duration_ms: input.totalDurationMs,\n      history: input.history ? JSON.parse(input.history) : undefined,\n      error_message: input.errorMessage,\n    });\n    return { ok: true };\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"] })\n  async stats(): Promise<TokenStats[]> {\n    return QgridDispatcher.getStats();\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"] })\n  async totalCost(tokenName?: string): Promise<{ usd: number }> {\n    return { usd: await RequestLogModel.totalCost({ token_name: tokenName }) };\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"] })\n  async projectNames(): Promise<{ names: string[] }> {\n    return { names: await RequestLogModel.distinctProjectNames() };\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async addToken(\n    provider: string,\n    credentials: TokenCredentials,\n    name: string,\n  ): Promise<{ added: boolean }> {\n    await TokenModel.save([\n      {\n        provider,\n        credentials,\n        name,\n      },\n    ]);\n    return { added: true };\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\"] })\n  async updateToken(\n    id: number,\n    name?: string,\n    quotaThreshold?: number | null,\n    weight?: number,\n  ): Promise<{ updated: boolean }> {\n    if (\n      quotaThreshold !== undefined &&\n      quotaThreshold !== null &&\n      (!Number.isInteger(quotaThreshold) || quotaThreshold < 1 || quotaThreshold > 100)\n    ) {\n      throw new BadRequestException(\n        \"quotaThreshold must be an integer between 1 and 100, or null\" as LocalizedString,\n      );\n    }\n    if (weight !== undefined && (!Number.isInteger(weight) || weight < 1 || weight > 100)) {\n      throw new BadRequestException(\n        \"weight must be an integer between 1 and 100\" as LocalizedString,\n      );\n    }\n\n    const patch: TokenUpdateFields = {};\n    if (name !== undefined) patch.name = name;\n    if (quotaThreshold !== undefined) patch.quota_threshold = quotaThreshold;\n    if (weight !== undefined) patch.weight = weight;\n    if (Object.keys(patch).length === 0) return { updated: false };\n\n    const updated = await TokenModel.updateFields(id, patch);\n    return { updated: updated > 0 };\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async removeToken(id: number): Promise<{ removed: boolean }> {\n    const entry = await TokenModel.findOne(\"A\", { id });\n    if (!entry) return { removed: false };\n    await TokenModel.del([entry.id]);\n    return { removed: true };\n  }\n\n  /**\n   * 토큰 활성화/비활성화 토글 DB의 active 필드 업데이트\n   */\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async toggleToken(id: number): Promise<{ active: boolean }> {\n    const entry = await TokenModel.findOne(\"A\", { id });\n    if (!entry) return { active: false };\n\n    const newActive = !entry.active;\n    await TokenModel.save([\n      {\n        id,\n        provider: entry.provider,\n        credentials: entry.credentials,\n        active: newActive,\n        name: entry.name,\n      },\n    ]);\n    return { active: newActive };\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async oauthStart(name: string): Promise<OAuthStartResult> {\n    const { codeVerifier, codeChallenge, state } = generatePKCE();\n\n    const redirectUri = getOAuthRedirectUri();\n    const authUrl = buildAuthUrl(codeChallenge, state, redirectUri);\n\n    await setOAuthState(state, { codeVerifier, name, redirectUri });\n\n    return { authUrl };\n  }\n\n  async handleOAuthCallback(code: string, state: string, reply: FastifyReply): Promise<void> {\n    const pending = await getOAuthState(state);\n    if (!pending) {\n      logger.warn(\"oauth callback: invalid_state\");\n      return reply.redirect(\"/?oauth=error&reason=invalid_state\");\n    }\n    await deleteOAuthState(state);\n\n    try {\n      const tokens = await exchangeCodeForTokens(\n        code,\n        pending.codeVerifier,\n        state,\n        pending.redirectUri,\n      );\n\n      if (tokens.accountUuid) {\n        const oldEntries = await TokenModel.findByAccountIdentifier(\n          \"A\",\n          \"anthropic\",\n          tokens.accountUuid,\n        );\n        if (oldEntries.length > 0) {\n          await TokenModel.del(oldEntries.map((o) => o.id));\n        }\n      }\n\n      await TokenModel.save([\n        {\n          provider: \"anthropic\",\n          credentials: {\n            accessToken: tokens.accessToken,\n            refreshToken: tokens.refreshToken,\n            expiresAt: tokens.expiresAt ?? 0,\n            accountUuid: tokens.accountUuid ?? \"\",\n          },\n          name: pending.name,\n        },\n      ]);\n\n      return reply.redirect(`/?oauth=success&name=${encodeURIComponent(pending.name)}`);\n    } catch (e) {\n      return reply.redirect(`/?oauth=error&reason=${encodeURIComponent((e as Error).message)}`);\n    }\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async oauthStartOpenAI(name: string): Promise<OAuthStartResult> {\n    if (!QgridDispatcher.openaiDispatcher) throw new Error(\"OpenAI dispatcher not initialized\");\n    const { authUrl } = await QgridDispatcher.openaiDispatcher.startBrowserLogin(name);\n\n    // fire-and-forget: codex login 완료 대기 → 토큰 저장\n    QgridDispatcher.openaiDispatcher\n      .completeBrowserLogin()\n      .then(async (creds) => {\n        if (creds.accountId) {\n          const oldEntries = await TokenModel.findByAccountIdentifier(\n            \"A\",\n            \"openai\",\n            creds.accountId,\n          );\n          if (oldEntries.length > 0) {\n            await TokenModel.del(oldEntries.map((o) => o.id));\n          }\n        }\n        await TokenModel.save([\n          {\n            provider: \"openai\",\n            credentials: {\n              accessToken: creds.accessToken,\n              refreshToken: creds.refreshToken,\n              idToken: creds.idToken,\n              accessTokenExpiresAt: Date.now() + 10 * 24 * 3600 * 1000,\n              accountId: creds.accountId,\n            },\n            name,\n          },\n        ]);\n        logger.info(`OpenAI token saved for ${name}`);\n      })\n      .catch((e) => {\n        logger.warn(`OpenAI browser login failed: ${(e as Error).message}`);\n      });\n\n    return { authUrl };\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"] })\n  async usage(tokenId?: number): Promise<UsageResponse> {\n    const { rows: allTokens } = await TokenModel.findMany(\"A\");\n    const entry = tokenId\n      ? allTokens.find((e) => e.id === tokenId)\n      : allTokens.findLast((e) => e.active && e.provider === \"anthropic\");\n\n    if (!entry) return { error: \"NOT_FOUND\" };\n\n    if (entry.provider === \"openai\") {\n      if (!entry.active) {\n        return { provider: \"openai\", fiveHour: null, sevenDay: null };\n      }\n\n      try {\n        const raw = await QgridDispatcher.openaiDispatcher?.getRateLimitsByTokenId(entry.id);\n        const rl = raw?.data.rateLimits;\n        return {\n          provider: \"openai\",\n          fiveHour: rl?.primary\n            ? {\n                utilization: rl.primary.usedPercent,\n                resetsAt: unixSecondsToIso(rl.primary.resetsAt),\n                windowDurationMins: rl.primary.windowDurationMins,\n              }\n            : null,\n          sevenDay: rl?.secondary\n            ? {\n                utilization: rl.secondary.usedPercent,\n                resetsAt: unixSecondsToIso(rl.secondary.resetsAt),\n                windowDurationMins: rl.secondary.windowDurationMins,\n              }\n            : null,\n        };\n      } catch (e) {\n        return { error: `OpenAI usage failed: ${(e as Error).message}` };\n      }\n    }\n\n    if (entry.provider !== \"anthropic\") {\n      return { error: `usage API not supported for provider: ${entry.provider}` };\n    }\n\n    let accessToken = getAccessToken(entry.credentials);\n    const isExpired = getExpiresAt(entry.credentials) < Date.now();\n\n    if (isExpired && getRefreshToken(entry.credentials)) {\n      try {\n        accessToken = await this.refreshToken(entry);\n      } catch (e) {\n        oauthLogger.warn(`refresh failed for ${entry.name}: ${(e as Error).message}`);\n        return { error: \"re-login required\" };\n      }\n    }\n\n    const raw = await fetchUsage(accessToken);\n    if (raw.error && getRefreshToken(entry.credentials)) {\n      try {\n        accessToken = await this.refreshToken(entry);\n        const retried = await fetchUsage(accessToken);\n        if (retried.error) return { error: retried.error };\n        return convertAnthropicUsage(retried);\n      } catch (e) {\n        oauthLogger.warn(`refresh failed for ${entry.name}: ${(e as Error).message}`);\n        return { error: \"re-login required\" };\n      }\n    }\n    if (raw.error) return { error: raw.error };\n    return convertAnthropicUsage(raw);\n  }\n\n  async refreshToken(token: TokenSubsetA): Promise<string> {\n    const creds = token.credentials;\n    const rt = getRefreshToken(creds);\n    if (!rt) throw new Error(\"No refresh token\");\n    const refreshed = await refreshAccessToken(rt);\n    const updated = TokenCredentials.parse({\n      ...creds,\n      accessToken: refreshed.accessToken,\n      refreshToken: refreshed.refreshToken,\n      expiresAt: refreshed.expiresAt,\n    });\n    await TokenModel.save([\n      {\n        id: token.id,\n        provider: token.provider,\n        credentials: updated,\n        name: token.name,\n      },\n    ]);\n    return refreshed.accessToken;\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"] })\n  async health(): Promise<HealthResponse> {\n    return {\n      status: \"ok\",\n      activeTokens: QgridDispatcher.tokens.size,\n      subscriber: QgridDispatcher.subscriber?.status() ?? null,\n    };\n  }\n}\n\nexport const QgridFrame = new QgridFrameClass();\n\nfunction convertAnthropicUsage(raw: AnthropicUsageRaw): UsageResponse {\n  return {\n    provider: \"anthropic\",\n    fiveHour: raw.five_hour\n      ? { utilization: raw.five_hour.utilization, resetsAt: raw.five_hour.resets_at }\n      : null,\n    sevenDay: raw.seven_day\n      ? { utilization: raw.seven_day.utilization, resetsAt: raw.seven_day.resets_at }\n      : null,\n  };\n}\n"],"mappings":"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"}