@cartanova/qgrid-cli 1.8.0 → 2.0.0

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

@@ -1,43 +1,201 @@
 import "../../_virtual/_rolldown/runtime.js";
 import { buildAuthUrl, exchangeCodeForTokens, fetchUsage, generatePKCE, refreshAccessToken } from "./oauth.js";
-import { QgridDispatcher } from "./qgrid.dispatcher.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 { 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 { TokenCredentials } from "../token/token.types.js";
+import crypto from "node:crypto";
 import { getLogger } from "@logtape/logtape";
-import { BaseFrameClass, api } from "sonamu";
+import { BaseFrameClass, Sonamu, api, stream } from "sonamu";
+import { getCacheManagerRef } from "sonamu/cache";
 //#region src/application/qgrid/qgrid.frame.ts
-const pendingOAuth = /* @__PURE__ */ new Map();
+var _ref;
+const pendingStreams = /* @__PURE__ */ new Map();
+const OAUTH_STATE_PREFIX = "oauth:state:";
+const OAUTH_STATE_TTL = "5m";
+async function setOAuthState(state, data) {
+	const cache = getCacheManagerRef();
+	if (!cache) throw new Error("CacheManager not initialized");
+	await cache.set({
+		key: `${OAUTH_STATE_PREFIX}${state}`,
+		value: JSON.stringify(data),
+		ttl: OAUTH_STATE_TTL
+	});
+}
+async function getOAuthState(state) {
+	const cache = getCacheManagerRef();
+	if (!cache) throw new Error("CacheManager not initialized");
+	const raw = await cache.get({ key: `${OAUTH_STATE_PREFIX}${state}` });
+	if (!raw) return void 0;
+	return JSON.parse(raw);
+}
+async function deleteOAuthState(state) {
+	const cache = getCacheManagerRef();
+	if (!cache) return;
+	await cache.delete({ key: `${OAUTH_STATE_PREFIX}${state}` });
+}
 const logger = getLogger(["qgrid"]);
 const oauthLogger = getLogger(["qgrid", "oauth"]);
 var QgridFrameClass = class extends BaseFrameClass {
 	constructor() {
 		super("Qgrid");
 	}
-	async query(prompt, system, timeout, model, projectName, jsonSchema) {
-		const result = await QgridDispatcher.query({
-			system,
-			prompt,
-			model,
-			jsonSchema
-		}, timeout);
-		RequestLogModel.save([{
-			token_name: result.tokenName,
-			project_name: projectName && projectName.length > 0 ? projectName : null,
-			model_name: result.model ?? null,
-			user_prompt: prompt,
-			system_prompt: system ?? null,
-			response: result.text,
-			input_tokens: result.usage.input_tokens,
-			output_tokens: result.usage.output_tokens,
-			cache_read_tokens: result.usage.cache_read_input_tokens,
-			cache_creation_tokens: result.usage.cache_creation_input_tokens,
-			duration_ms: result.durationMs,
-			cost_usd: result.costUsd !== null ? Math.round(result.costUsd * MICRO_USD) : null
-		}]).catch((e) => logger.error(`requestLog save failed: ${e.message}`));
+	async query(args) {
+		const effectiveLogMode = args.logMode ?? (args.isStep ? "run" : "auto");
+		if (effectiveLogMode === "run") {
+			const { requestLogId, stepIndex } = await beforeQuery(args);
+			try {
+				const result = await QgridDispatcher.query(args, args.timeout);
+				const lifecycle = await afterQuery(requestLogId, stepIndex, args, result);
+				return {
+					...result,
+					runContext: lifecycle.runContext
+				};
+			} catch (e) {
+				await finishRunWithError(requestLogId, e.message, args);
+				throw e;
+			}
+		}
+		const result = await QgridDispatcher.query(args, args.timeout);
+		if (effectiveLogMode === "auto") {
+			const toolCallCount = result.content.filter((item) => item.type === "tool-call").length;
+			const responseText = result.content.filter((item) => item.type === "text").map((item) => item.text).join("\n");
+			RequestLogModel.save([{
+				token_name: result.tokenName,
+				project_name: args.projectName?.length ? args.projectName : null,
+				model_name: result.model ?? null,
+				user_prompt: args.prompt,
+				system_prompt: args.system ?? null,
+				response: responseText,
+				input_tokens: result.usage.input_tokens,
+				output_tokens: result.usage.output_tokens,
+				cache_read_tokens: result.usage.cache_read_input_tokens,
+				cache_creation_tokens: result.usage.cache_creation_input_tokens,
+				duration_ms: result.durationMs,
+				cost_usd: result.costUsd !== null ? Math.round(result.costUsd * MICRO_USD) : null,
+				effort: args.effort ?? null,
+				history: args.history ? JSON.parse(args.history) : null,
+				status: "succeeded",
+				tool_call_count: toolCallCount
+			}]).catch((e) => logger.error(`requestLog save failed: ${e.message}`));
+		}
 		return result;
 	}
+	async prepareStream(args) {
+		const streamId = crypto.randomUUID();
+		pendingStreams.set(streamId, args);
+		setTimeout(() => pendingStreams.delete(streamId), 3e4);
+		return { streamId };
+	}
+	async queryStream(streamId) {
+		const args = pendingStreams.get(streamId);
+		pendingStreams.delete(streamId);
+		if (!args) throw new Error("invalid or expired streamId");
+		const shouldLog = (args.logMode ?? (args.isStep ? "run" : "auto")) === "run";
+		let runInfo;
+		if (shouldLog) try {
+			runInfo = await beforeQuery(args);
+		} catch (e) {
+			logger.error(`stream beforeQuery failed: ${e.message}`);
+		}
+		const sse = Sonamu.getContext().createSSE(StreamEvents);
+		let threadId;
+		let turnId;
+		let streamResult;
+		let streamError;
+		sse.onClose(() => {
+			if (threadId && turnId) QgridDispatcher.openaiDispatcher?.interruptWorkerTurn(threadId, turnId).catch(() => {});
+		});
+		try {
+			await QgridDispatcher.queryStream(args, {
+				onDelta: (text) => {
+					if (!sse.closed) sse.publish("delta", { text });
+				},
+				onThreadId: (id) => {
+					threadId = id;
+					if (sse.closed && turnId) QgridDispatcher.openaiDispatcher?.interruptWorkerTurn(threadId, turnId).catch(() => {});
+				},
+				onTurnId: (id) => {
+					turnId = id;
+					if (sse.closed && threadId) QgridDispatcher.openaiDispatcher?.interruptWorkerTurn(threadId, turnId).catch(() => {});
+				},
+				onComplete: (result) => {
+					streamResult = result;
+				},
+				onError: (err) => {
+					streamError = err;
+				}
+			});
+		} catch (e) {
+			streamError = e;
+		}
+		if (streamResult) {
+			let runContext;
+			if (runInfo) try {
+				runContext = (await afterQuery(runInfo.requestLogId, runInfo.stepIndex, args, streamResult)).runContext;
+			} catch (e) {
+				logger.error(`stream afterQuery failed: ${e.message}`);
+			}
+			if (!sse.closed) sse.publish("done", {
+				...streamResult,
+				runContext
+			});
+		} else if (streamError) {
+			if (runInfo) await finishRunWithError(runInfo.requestLogId, streamError.message, args);
+			if (!sse.closed) sse.publish("error", { message: streamError.message });
+		} else if (sse.closed && runInfo) await finishRunAborted(runInfo.requestLogId, args);
+		await sse.end();
+	}
+	async createRun(input) {
+		return { requestLogId: await RequestLogModel.createRun({
+			user_prompt: input.userPrompt,
+			model_name: input.modelName,
+			effort: input.effort,
+			project_name: input.projectName,
+			system_prompt: input.systemPrompt
+		}) };
+	}
+	async appendStep(input) {
+		return { stepId: await RequestLogModel.appendStep(input.requestLogId, {
+			step_index: input.stepIndex,
+			type: input.type,
+			input_tokens: input.inputTokens,
+			output_tokens: input.outputTokens,
+			cache_read_tokens: input.cacheReadTokens,
+			cache_creation_tokens: input.cacheCreationTokens,
+			duration_ms: input.durationMs,
+			finish_reason: input.finishReason,
+			reasoning_text: input.reasoningText,
+			reasoning_tokens: input.reasoningTokens,
+			tool_call_index: input.toolCallIndex,
+			tool_call_id: input.toolCallId,
+			tool_name: input.toolName,
+			tool_args: input.toolArgs,
+			tool_result: input.toolResult,
+			tool_duration_ms: input.toolDurationMs,
+			error: input.error
+		}) };
+	}
+	async finishRun(input) {
+		await RequestLogModel.finishRun(input.requestLogId, {
+			status: input.status,
+			response: input.response,
+			token_name: input.tokenName,
+			input_tokens: input.totalInputTokens,
+			output_tokens: input.totalOutputTokens,
+			cache_read_tokens: input.totalCacheReadTokens,
+			cache_creation_tokens: input.totalCacheCreationTokens,
+			duration_ms: input.totalDurationMs,
+			history: input.history ? JSON.parse(input.history) : void 0,
+			error_message: input.errorMessage
+		});
+		return { ok: true };
+	}
 	async stats() {
 		return QgridDispatcher.getStats();
 	}
@@ -47,29 +205,27 @@ var QgridFrameClass = class extends BaseFrameClass {
 	async projectNames() {
 		return { names: await RequestLogModel.distinctProjectNames() };
 	}
-	async addToken(token, name, refreshToken) {
+	async addToken(provider, credentials, name) {
 		await TokenModel.save([{
-			token,
-			name,
-			...refreshToken && refreshToken.length > 0 ? { refresh_token: refreshToken } : {}
+			provider,
+			credentials,
+			name
 		}]);
 		return { added: true };
 	}
-	async updateToken(token, name, newToken, refreshToken) {
-		const entry = await TokenModel.findByToken("A", token);
+	async updateToken(id, name) {
+		const entry = await TokenModel.findOne("A", { id });
 		if (!entry) return { updated: false };
-		const hasNewToken = newToken !== void 0 && newToken.length > 0;
-		const hasRefreshToken = refreshToken !== void 0 && refreshToken.length > 0;
 		await TokenModel.save([{
 			id: entry.id,
-			token: hasNewToken ? newToken : entry.token,
-			name: name !== void 0 ? name : entry.name,
-			...hasRefreshToken ? { refresh_token: refreshToken } : {}
+			provider: entry.provider,
+			credentials: entry.credentials,
+			name: name !== void 0 ? name : entry.name
 		}]);
 		return { updated: true };
 	}
-	async removeToken(token) {
-		const entry = await TokenModel.findByToken("A", token);
+	async removeToken(id) {
+		const entry = await TokenModel.findOne("A", { id });
 		if (!entry) return { removed: false };
 		await TokenModel.del([entry.id]);
 		return { removed: true };
@@ -83,7 +239,8 @@ var QgridFrameClass = class extends BaseFrameClass {
 		const newActive = !entry.active;
 		await TokenModel.save([{
 			id,
-			token: entry.token,
+			provider: entry.provider,
+			credentials: entry.credentials,
 			active: newActive,
 			name: entry.name
 		}]);
@@ -93,66 +250,123 @@ var QgridFrameClass = class extends BaseFrameClass {
 		const { codeVerifier, codeChallenge, state } = generatePKCE();
 		const redirectUri = `http://localhost:${process.env.PORT ?? "44900"}/callback`;
 		const authUrl = buildAuthUrl(codeChallenge, state, redirectUri);
-		pendingOAuth.set(state, {
+		await setOAuthState(state, {
 			codeVerifier,
 			name,
 			redirectUri
 		});
-		setTimeout(() => pendingOAuth.delete(state), 3e5);
 		return { authUrl };
 	}
 	async handleOAuthCallback(code, state, reply) {
-		const pending = pendingOAuth.get(state);
-		if (!pending) return reply.redirect("/?oauth=error&reason=invalid_state");
-		pendingOAuth.delete(state);
+		const pending = await getOAuthState(state);
+		if (!pending) {
+			logger.warn("oauth callback: invalid_state");
+			return reply.redirect("/?oauth=error&reason=invalid_state");
+		}
+		await deleteOAuthState(state);
 		try {
 			const tokens = await exchangeCodeForTokens(code, pending.codeVerifier, state, pending.redirectUri);
 			if (tokens.accountUuid) {
-				const oldEntries = await TokenModel.findByAccountUuid("A", tokens.accountUuid);
+				const oldEntries = await TokenModel.findByAccountIdentifier("A", "anthropic", tokens.accountUuid);
 				if (oldEntries.length > 0) await TokenModel.del(oldEntries.map((o) => o.id));
 			}
 			await TokenModel.save([{
-				token: tokens.accessToken,
-				name: pending.name,
-				refresh_token: tokens.refreshToken,
-				expires_at: tokens.expiresAt ? BigInt(tokens.expiresAt) : null,
-				account_uuid: tokens.accountUuid
+				provider: "anthropic",
+				credentials: {
+					accessToken: tokens.accessToken,
+					refreshToken: tokens.refreshToken,
+					expiresAt: tokens.expiresAt ?? 0,
+					accountUuid: tokens.accountUuid ?? ""
+				},
+				name: pending.name
 			}]);
 			return reply.redirect(`/?oauth=success&name=${encodeURIComponent(pending.name)}`);
 		} catch (e) {
 			return reply.redirect(`/?oauth=error&reason=${encodeURIComponent(e.message)}`);
 		}
 	}
-	async usage(tokenName) {
+	async oauthStartOpenAI(name) {
+		if (!QgridDispatcher.openaiDispatcher) throw new Error("OpenAI dispatcher not initialized");
+		const { authUrl } = await QgridDispatcher.openaiDispatcher.startBrowserLogin(name);
+		QgridDispatcher.openaiDispatcher.completeBrowserLogin().then(async (creds) => {
+			if (creds.accountId) {
+				const oldEntries = await TokenModel.findByAccountIdentifier("A", "openai", creds.accountId);
+				if (oldEntries.length > 0) await TokenModel.del(oldEntries.map((o) => o.id));
+			}
+			await TokenModel.save([{
+				provider: "openai",
+				credentials: {
+					accessToken: creds.accessToken,
+					refreshToken: creds.refreshToken,
+					idToken: creds.idToken,
+					accessTokenExpiresAt: Date.now() + 240 * 3600 * 1e3,
+					accountId: creds.accountId
+				},
+				name
+			}]);
+			logger.info(`OpenAI token saved for ${name}`);
+		}).catch((e) => {
+			logger.warn(`OpenAI browser login failed: ${e.message}`);
+		});
+		return { authUrl };
+	}
+	async usage(tokenId) {
 		const { rows: allTokens } = await TokenModel.findMany("A");
-		const entry = tokenName ? allTokens.find((e) => e.name === tokenName) : allTokens.findLast((e) => e.active);
+		const entry = tokenId ? allTokens.find((e) => e.id === tokenId) : allTokens.findLast((e) => e.active && e.provider === "anthropic");
 		if (!entry) return { error: "NOT_FOUND" };
-		let accessToken = entry.token;
-		if (entry.expires_at && Number(entry.expires_at) < Date.now() && entry.refresh_token) try {
+		if (entry.provider === "openai") try {
+			const rl = (await QgridDispatcher.openaiDispatcher?.getRateLimits(entry.name))?.rateLimits;
+			return {
+				provider: "openai",
+				fiveHour: rl?.primary ? {
+					utilization: rl.primary.usedPercent,
+					resetsAt: (/* @__PURE__ */ new Date(rl.primary.resetsAt * 1e3)).toISOString()
+				} : null,
+				sevenDay: rl?.secondary ? {
+					utilization: rl.secondary.usedPercent,
+					resetsAt: (/* @__PURE__ */ new Date(rl.secondary.resetsAt * 1e3)).toISOString()
+				} : null
+			};
+		} catch (e) {
+			return { error: `OpenAI usage failed: ${e.message}` };
+		}
+		if (entry.provider !== "anthropic") return { error: `usage API not supported for provider: ${entry.provider}` };
+		let accessToken = getAccessToken(entry.credentials);
+		if (getExpiresAt(entry.credentials) < Date.now() && getRefreshToken(entry.credentials)) try {
 			accessToken = await this.refreshToken(entry);
 		} catch (e) {
 			oauthLogger.warn(`refresh failed for ${entry.name}: ${e.message}`);
 			return { error: "re-login required" };
 		}
-		const result = await fetchUsage(accessToken);
-		if (result.error && entry.refresh_token) try {
+		const raw = await fetchUsage(accessToken);
+		if (raw.error && getRefreshToken(entry.credentials)) try {
 			accessToken = await this.refreshToken(entry);
-			return await fetchUsage(accessToken);
+			const retried = await fetchUsage(accessToken);
+			if (retried.error) return { error: retried.error };
+			return convertAnthropicUsage(retried);
 		} catch (e) {
 			oauthLogger.warn(`refresh failed for ${entry.name}: ${e.message}`);
 			return { error: "re-login required" };
 		}
-		return result;
+		if (raw.error) return { error: raw.error };
+		return convertAnthropicUsage(raw);
 	}
 	async refreshToken(token) {
-		if (!token.refresh_token) throw new Error("No refresh token");
-		const refreshed = await refreshAccessToken(token.refresh_token);
+		const creds = token.credentials;
+		const rt = getRefreshToken(creds);
+		if (!rt) throw new Error("No refresh token");
+		const refreshed = await refreshAccessToken(rt);
+		const updated = TokenCredentials.parse({
+			...creds,
+			accessToken: refreshed.accessToken,
+			refreshToken: refreshed.refreshToken,
+			expiresAt: refreshed.expiresAt
+		});
 		await TokenModel.save([{
 			id: token.id,
-			token: refreshed.accessToken,
-			refresh_token: refreshed.refreshToken,
-			expires_at: BigInt(refreshed.expiresAt),
-			name: token.name ?? ""
+			provider: token.provider,
+			credentials: updated,
+			name: token.name
 		}]);
 		return refreshed.accessToken;
 	}
@@ -170,16 +384,54 @@ __decorate([
 		clients: ["axios", "tanstack-mutation"]
 	}),
 	__decorateMetadata("design:type", Function),
-	__decorateMetadata("design:paramtypes", [
-		String,
-		String,
-		Number,
-		String,
-		String,
-		String
-	]),
+	__decorateMetadata("design:paramtypes", [Object]),
 	__decorateMetadata("design:returntype", Promise)
 ], QgridFrameClass.prototype, "query", null);
+__decorate([
+	api({
+		httpMethod: "POST",
+		clients: ["axios", "tanstack-mutation"]
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [Object]),
+	__decorateMetadata("design:returntype", Promise)
+], QgridFrameClass.prototype, "prepareStream", null);
+__decorate([
+	stream({
+		type: "sse",
+		events: StreamEvents
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [String]),
+	__decorateMetadata("design:returntype", Promise)
+], QgridFrameClass.prototype, "queryStream", null);
+__decorate([
+	api({
+		httpMethod: "POST",
+		clients: ["axios", "tanstack-mutation"]
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [Object]),
+	__decorateMetadata("design:returntype", Promise)
+], QgridFrameClass.prototype, "createRun", null);
+__decorate([
+	api({
+		httpMethod: "POST",
+		clients: ["axios", "tanstack-mutation"]
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [Object]),
+	__decorateMetadata("design:returntype", Promise)
+], QgridFrameClass.prototype, "appendStep", null);
+__decorate([
+	api({
+		httpMethod: "POST",
+		clients: ["axios", "tanstack-mutation"]
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [Object]),
+	__decorateMetadata("design:returntype", Promise)
+], QgridFrameClass.prototype, "finishRun", null);
 __decorate([
 	api({
 		httpMethod: "GET",
@@ -215,7 +467,7 @@ __decorate([
 	__decorateMetadata("design:type", Function),
 	__decorateMetadata("design:paramtypes", [
 		String,
-		String,
+		typeof (_ref = typeof TokenCredentials !== "undefined" && TokenCredentials) === "function" ? _ref : Object,
 		String
 	]),
 	__decorateMetadata("design:returntype", Promise)
@@ -226,12 +478,7 @@ __decorate([
 		clients: ["axios", "tanstack-mutation"]
 	}),
 	__decorateMetadata("design:type", Function),
-	__decorateMetadata("design:paramtypes", [
-		String,
-		String,
-		String,
-		String
-	]),
+	__decorateMetadata("design:paramtypes", [Number, String]),
 	__decorateMetadata("design:returntype", Promise)
 ], QgridFrameClass.prototype, "updateToken", null);
 __decorate([
@@ -240,7 +487,7 @@ __decorate([
 		clients: ["axios", "tanstack-mutation"]
 	}),
 	__decorateMetadata("design:type", Function),
-	__decorateMetadata("design:paramtypes", [String]),
+	__decorateMetadata("design:paramtypes", [Number]),
 	__decorateMetadata("design:returntype", Promise)
 ], QgridFrameClass.prototype, "removeToken", null);
 __decorate([
@@ -261,13 +508,22 @@ __decorate([
 	__decorateMetadata("design:paramtypes", [String]),
 	__decorateMetadata("design:returntype", Promise)
 ], QgridFrameClass.prototype, "oauthStart", null);
+__decorate([
+	api({
+		httpMethod: "POST",
+		clients: ["axios", "tanstack-mutation"]
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [String]),
+	__decorateMetadata("design:returntype", Promise)
+], QgridFrameClass.prototype, "oauthStartOpenAI", null);
 __decorate([
 	api({
 		httpMethod: "GET",
 		clients: ["axios", "tanstack-query"]
 	}),
 	__decorateMetadata("design:type", Function),
-	__decorateMetadata("design:paramtypes", [String]),
+	__decorateMetadata("design:paramtypes", [Number]),
 	__decorateMetadata("design:returntype", Promise)
 ], QgridFrameClass.prototype, "usage", null);
 __decorate([
@@ -280,7 +536,20 @@ __decorate([
 	__decorateMetadata("design:returntype", Promise)
 ], QgridFrameClass.prototype, "health", null);
 const QgridFrame = new QgridFrameClass();
+function convertAnthropicUsage(raw) {
+	return {
+		provider: "anthropic",
+		fiveHour: raw.five_hour ? {
+			utilization: raw.five_hour.utilization,
+			resetsAt: raw.five_hour.resets_at
+		} : null,
+		sevenDay: raw.seven_day ? {
+			utilization: raw.seven_day.utilization,
+			resetsAt: raw.seven_day.resets_at
+		} : null
+	};
+}
 //#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 { getLogger } from \"@logtape/logtape\";\nimport { type FastifyReply } from \"fastify\";\nimport { api, BaseFrameClass } from \"sonamu\";\n\nimport { MICRO_USD, RequestLogModel } from \"../request-log/request-log.model\";\nimport { TokenModel } from \"../token/token.model\";\nimport { type RefreshTokenParams } from \"../token/token.types\";\nimport {\n  buildAuthUrl,\n  exchangeCodeForTokens,\n  fetchUsage,\n  generatePKCE,\n  refreshAccessToken,\n} from \"./oauth\";\nimport { QgridDispatcher } from \"./qgrid.dispatcher\";\nimport {\n  type CliResult,\n  type HealthResponse,\n  type OAuthStartResult,\n  type TokenStats,\n  type UsageResponse,\n} from \"./qgrid.types\";\n\nconst pendingOAuth = new Map<string, { codeVerifier: string; name: string; redirectUri: string }>();\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(\n    prompt: string,\n    system?: string,\n    timeout?: number,\n    model?: string,\n    projectName?: string,\n    jsonSchema?: string,\n  ): Promise<CliResult> {\n    const result = await QgridDispatcher.query({ system, prompt, model, jsonSchema }, timeout);\n\n    RequestLogModel.save([\n      {\n        token_name: result.tokenName,\n        project_name: projectName && projectName.length > 0 ? projectName : null,\n        model_name: result.model ?? null,\n        user_prompt: prompt,\n        system_prompt: system ?? null,\n        response: result.text,\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        cost_usd: result.costUsd !== null ? Math.round(result.costUsd * MICRO_USD) : null,\n      },\n    ]).catch((e) => logger.error(`requestLog save failed: ${(e as Error).message}`));\n\n    return result;\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(token: string, name: string, refreshToken?: string): Promise<{ added: boolean }> {\n    await TokenModel.save([\n      {\n        token,\n        name,\n        ...(refreshToken && refreshToken.length > 0 ? { refresh_token: refreshToken } : {}),\n      },\n    ]);\n    return { added: true };\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async updateToken(\n    token: string,\n    name?: string,\n    newToken?: string,\n    refreshToken?: string,\n  ): Promise<{ updated: boolean }> {\n    const entry = await TokenModel.findByToken(\"A\", token);\n    if (!entry) return { updated: false };\n\n    const hasNewToken = newToken !== undefined && newToken.length > 0;\n    const hasRefreshToken = refreshToken !== undefined && refreshToken.length > 0;\n    await TokenModel.save([\n      {\n        id: entry.id,\n        token: hasNewToken ? newToken : entry.token,\n        name: name !== undefined ? name : entry.name,\n        ...(hasRefreshToken ? { refresh_token: refreshToken } : {}),\n      },\n    ]);\n    return { updated: true };\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async removeToken(token: string): Promise<{ removed: boolean }> {\n    const entry = await TokenModel.findByToken(\"A\", token);\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([{ id, token: entry.token, active: newActive, name: entry.name }]);\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 serverPort = process.env.PORT ?? \"44900\";\n    const redirectUri = `http://localhost:${serverPort}/callback`;\n    const authUrl = buildAuthUrl(codeChallenge, state, redirectUri);\n\n    pendingOAuth.set(state, { codeVerifier, name, redirectUri });\n    setTimeout(() => pendingOAuth.delete(state), 300_000);\n\n    return { authUrl };\n  }\n\n  async handleOAuthCallback(code: string, state: string, reply: FastifyReply): Promise<void> {\n    const pending = pendingOAuth.get(state);\n    if (!pending) {\n      return reply.redirect(\"/?oauth=error&reason=invalid_state\");\n    }\n    pendingOAuth.delete(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.findByAccountUuid(\"A\", tokens.accountUuid);\n        if (oldEntries.length > 0) {\n          await TokenModel.del(oldEntries.map((o) => o.id));\n        }\n      }\n\n      await TokenModel.save([\n        {\n          token: tokens.accessToken,\n          name: pending.name,\n          refresh_token: tokens.refreshToken,\n          expires_at: tokens.expiresAt ? BigInt(tokens.expiresAt) : null,\n          account_uuid: tokens.accountUuid,\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: \"GET\", clients: [\"axios\", \"tanstack-query\"] })\n  async usage(tokenName?: string): Promise<UsageResponse> {\n    const { rows: allTokens } = await TokenModel.findMany(\"A\");\n    const entry = tokenName\n      ? allTokens.find((e) => e.name === tokenName)\n      : allTokens.findLast((e) => e.active);\n\n    if (!entry) return { error: \"NOT_FOUND\" };\n\n    let accessToken = entry.token;\n    const isExpired = entry.expires_at && Number(entry.expires_at) < Date.now();\n\n    if (isExpired && entry.refresh_token) {\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 result = await fetchUsage(accessToken);\n\n    if (result.error && entry.refresh_token) {\n      try {\n        accessToken = await this.refreshToken(entry);\n        return await fetchUsage(accessToken);\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    return result;\n  }\n\n  async refreshToken(token: RefreshTokenParams): Promise<string> {\n    if (!token.refresh_token) throw new Error(\"No refresh token\");\n    const refreshed = await refreshAccessToken(token.refresh_token);\n    await TokenModel.save([\n      {\n        id: token.id,\n        token: refreshed.accessToken,\n        refresh_token: refreshed.refreshToken,\n        expires_at: BigInt(refreshed.expiresAt),\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"],"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, BaseFrameClass, Sonamu, stream } from \"sonamu\";\nimport { getCacheManagerRef } from \"sonamu/cache\";\n\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 } 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  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  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\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\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        return { ...result, runContext: lifecycle.runContext };\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      const toolCallCount = result.content.filter((item) => item.type === \"tool-call\").length;\n      const responseText = result.content\n        .filter((item) => item.type === \"text\")\n        .map((item) => item.text)\n        .join(\"\\n\");\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          cost_usd: result.costUsd !== null ? Math.round(result.costUsd * MICRO_USD) : null,\n          effort: args.effort ?? null,\n          history: args.history ? JSON.parse(args.history) : null,\n          status: \"succeeded\",\n          tool_call_count: toolCallCount,\n        },\n      ]).catch((e) => logger.error(`requestLog save failed: ${(e as Error).message}`));\n    }\n\n    return result;\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async prepareStream(args: QueryInput): Promise<{ streamId: string }> {\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\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\n    sse.onClose(() => {\n      if (threadId && turnId) {\n        QgridDispatcher.openaiDispatcher?.interruptWorkerTurn(threadId, turnId).catch(() => {});\n      }\n    });\n\n    try {\n      await QgridDispatcher.queryStream(args, {\n        onDelta: (text) => {\n          if (!sse.closed) sse.publish(\"delta\", { text });\n        },\n        onThreadId: (id) => {\n          threadId = id;\n          if (sse.closed && turnId) {\n            QgridDispatcher.openaiDispatcher?.interruptWorkerTurn(threadId, turnId).catch(() => {});\n          }\n        },\n        onTurnId: (id) => {\n          turnId = id;\n          if (sse.closed && threadId) {\n            QgridDispatcher.openaiDispatcher?.interruptWorkerTurn(threadId, turnId).catch(() => {});\n          }\n        },\n        onComplete: (result) => {\n          streamResult = result;\n        },\n        onError: (err) => {\n          streamError = err;\n        },\n      });\n    } catch (e) {\n      streamError = e as Error;\n    }\n\n    // dispatcher 완료 후 lifecycle 처리 (await 안전)\n    if (streamResult) {\n      let runContext: { requestLogId: number } | 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;\n        } catch (e) {\n          logger.error(`stream afterQuery failed: ${(e as Error).message}`);\n        }\n      }\n      if (!sse.closed) sse.publish(\"done\", { ...streamResult, runContext });\n    } else if (streamError) {\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    });\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      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\", \"tanstack-mutation\"] })\n  async updateToken(id: number, name?: string): Promise<{ updated: boolean }> {\n    const entry = await TokenModel.findOne(\"A\", { id });\n    if (!entry) return { updated: false };\n\n    await TokenModel.save([\n      {\n        id: entry.id,\n        provider: entry.provider,\n        credentials: entry.credentials,\n        name: name !== undefined ? name : entry.name,\n      },\n    ]);\n    return { updated: true };\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 serverPort = process.env.PORT ?? \"44900\";\n    const redirectUri = `http://localhost:${serverPort}/callback`;\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      try {\n        const raw = (await QgridDispatcher.openaiDispatcher?.getRateLimits(entry.name)) as {\n          rateLimits?: {\n            primary?: { usedPercent: number; windowDurationMins: number; resetsAt: number };\n            secondary?: { usedPercent: number; windowDurationMins: number; resetsAt: number };\n          };\n        };\n        const rl = raw?.rateLimits;\n        return {\n          provider: \"openai\",\n          fiveHour: rl?.primary\n            ? {\n                utilization: rl.primary.usedPercent,\n                resetsAt: new Date(rl.primary.resetsAt * 1000).toISOString(),\n              }\n            : null,\n          sevenDay: rl?.secondary\n            ? {\n                utilization: rl.secondary.usedPercent,\n                resetsAt: new Date(rl.secondary.resetsAt * 1000).toISOString(),\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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"}