@cartanova/qgrid-cli 2.10.9 → 2.11.0

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

@@ -1,30 +1,58 @@
+import { SD } from "../../i18n/sd.generated.js";
 import { getAccessToken, getExpiresAt, getRefreshToken } from "../../utils/providers/common/credentials.js";
+import { GROK_IMAGE_DEFAULT_MODEL, GROK_STT_DEFAULT_MODEL, GROK_VIDEO_DEFAULT_MODEL } from "../../utils/providers/grok/grok-constants.js";
+import { grokImageCost, grokReportedCost } from "../../utils/providers/common/model-cost.js";
+import { isProviderId } from "../../utils/providers/common/provider-types.js";
 import { CallerSchemaValidationError } from "../../utils/providers/common/schema-validation.js";
-import { StreamEvents } from "./qgrid.types.js";
+import { GenerateImagesInput, REQUEST_BODY_LIMIT_BYTES, SpeakInput, StreamEvents, TranscribeInput, VideoStartInput, VideoStatusInput } from "./qgrid.types.js";
 import __decorateMetadata from "../../_virtual/_@oxc-project_runtime@0.140.0/helpers/esm/decorateMetadata.js";
 import __decorate from "../../_virtual/_@oxc-project_runtime@0.140.0/helpers/esm/decorate.js";
 import { TokenModel } from "../token/token.model.js";
 import { deactivateAuthDeadToken, notifyTokenAdded } from "./token-death.js";
+import { GrokCredentials, TokenCredentials } from "../token/token.types.js";
 import { ToolSchemaCompositionError } from "./tool-emulation-schema.js";
 import { QgridDispatcher, buildAndValidateStrictOutputSchema, completedDriverFromImageFailure } from "./qgrid.dispatcher.js";
 import { MICRO_USD, RequestLogModel } from "../request-log/request-log.model.js";
 import { CONSOLE_CALLBACK_URL, RefreshFailedError, buildAuthUrl, exchangeCodeForTokens, fetchUsage, generatePKCE, refreshAccessToken } from "./oauth.js";
 import { CODEX_IMAGE_GENERATION_MODEL } from "./qgrid-image-generation.js";
 import { afterQuery, beforeQuery, finishRunAborted, finishRunWithError } from "./qgrid-run-lifecycle.js";
+import { GrokCredentials as GrokCredentials$1 } from "../../utils/providers/grok/grok-types.js";
+import { GrokOAuthError, completeGrokOAuth, pollGrokDeviceCode, startGrokDeviceCode, startGrokOAuth } from "../../utils/providers/grok/grok-oauth.js";
+import { GrokCapabilityUnavailableError, GrokCapacityError, GrokInvalidRequestError, GrokNoWorkersError, GrokOnDemandExcludedError, GrokRateLimitedError, GrokZdrVideoUnavailableError } from "../../utils/providers/grok/grok-dispatcher.js";
+import "../../utils/providers/grok/index.js";
+import { GrokContentPolicyError, decodeGrokImages, summarizeGrokVideoStatus } from "../../utils/providers/grok/grok-media-client.js";
+import "../../utils/providers/grok/grok-voice-client.js";
 import { OPENAI_CALLBACK_PORTS, openAICallbackRedirectUri, startOpenAICallbackRelay } from "../../utils/providers/openai/openai-callback-relay.js";
 import { buildOpenAIAuthUrl, exchangeOpenAICode, generateOpenAIPKCE } from "../../utils/providers/openai/openai-oauth.js";
-import { TokenCredentials } from "../token/token.types.js";
-import { BadRequestException, BaseFrameClass, Sonamu, api, stream } from "sonamu";
+import { z } from "zod";
+import { BadRequestException, BaseFrameClass, InternalServerErrorException, NotFoundException, ServiceUnavailableException, SoException, 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
 const pendingStreams = /* @__PURE__ */ new Map();
+const PendingOAuth = z.object({
+	codeVerifier: z.string(),
+	name: z.string(),
+	redirectUri: z.string(),
+	provider: z.enum([
+		"anthropic",
+		"openai",
+		"grok"
+	])
+});
 const OAUTH_STATE_PREFIX = "oauth:state:";
 const OAUTH_STATE_TTL = "5m";
 const OAUTH_STATE_TTL_MS = 5 * 6e4;
+const GROK_LATEST_STATE_KEY = "oauth:grok:latest";
+const GROK_DEVICE_PREFIX = "oauth:grok:device:";
+const PendingGrokDevice = z.object({
+	name: z.string(),
+	interval: z.number(),
+	expiresAtMs: z.number()
+});
 function unixSecondsToIso(seconds) {
-	return typeof seconds === "number" ? (/* @__PURE__ */ new Date(seconds * 1e3)).toISOString() : null;
+	return seconds === null || seconds === void 0 ? null : (/* @__PURE__ */ new Date(seconds * 1e3)).toISOString();
 }
 async function setOAuthState(state, data) {
 	const cache = getCacheManagerRef();
@@ -40,18 +68,74 @@ async function getOAuthState(state) {
 	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);
+	return PendingOAuth.safeParse(JSON.parse(raw)).data;
 }
 async function deleteOAuthState(state) {
 	const cache = getCacheManagerRef();
 	if (!cache) return;
 	await cache.delete({ key: `${OAUTH_STATE_PREFIX}${state}` });
 }
+async function setGrokLatestState(state) {
+	const cache = getCacheManagerRef();
+	if (!cache) throw new Error("CacheManager not initialized");
+	await cache.set({
+		key: GROK_LATEST_STATE_KEY,
+		value: state,
+		ttl: OAUTH_STATE_TTL
+	});
+}
+async function getGrokLatestState() {
+	const cache = getCacheManagerRef();
+	if (!cache) throw new Error("CacheManager not initialized");
+	return await cache.get({ key: GROK_LATEST_STATE_KEY }) ?? void 0;
+}
+async function setGrokDeviceState(deviceCode, data) {
+	const cache = getCacheManagerRef();
+	if (!cache) throw new Error("CacheManager not initialized");
+	const ttlSec = Math.max(1, Math.ceil((data.expiresAtMs - Date.now()) / 1e3));
+	await cache.set({
+		key: `${GROK_DEVICE_PREFIX}${deviceCode}`,
+		value: JSON.stringify(data),
+		ttl: `${ttlSec}s`
+	});
+}
+async function getGrokDeviceState(deviceCode) {
+	const cache = getCacheManagerRef();
+	if (!cache) throw new Error("CacheManager not initialized");
+	const raw = await cache.get({ key: `${GROK_DEVICE_PREFIX}${deviceCode}` });
+	if (!raw) return void 0;
+	const data = PendingGrokDevice.safeParse(JSON.parse(raw)).data;
+	return data && data.expiresAtMs > Date.now() ? data : void 0;
+}
+async function deleteGrokDeviceState(deviceCode) {
+	const cache = getCacheManagerRef();
+	if (!cache) return;
+	await cache.delete({ key: `${GROK_DEVICE_PREFIX}${deviceCode}` });
+}
+function grokOAuthBadRequest(cause) {
+	if (cause instanceof GrokOAuthError) throw new BadRequestException(SD("qgrid.grokLoginFailed")(cause.message));
+	throw cause;
+}
+function grokTokenSnapshot(tokenId) {
+	return QgridDispatcher.grokDispatcher?.tokenStates?.().find((state) => state.id === tokenId);
+}
+/** Stores refreshed Grok credentials; the token subscriber pushes the row to the dispatcher. */
+async function persistGrokCredentials(tokenId, next) {
+	const credentials = GrokCredentials$1.parse(next);
+	const row = await TokenModel.findById("A", tokenId);
+	await TokenModel.save([{
+		id: row.id,
+		provider: row.provider,
+		credentials,
+		name: row.name,
+		reauth_required: false
+	}]);
+}
 const trustedLoopbackBase = () => `http://localhost:${process.env.PORT ?? "44900"}`;
 function isRemoteOAuthRequest() {
 	try {
 		const { headers } = Sonamu.getContext();
-		const origin = typeof headers.origin === "string" ? headers.origin : void 0;
+		const origin = headers.origin;
 		const forwarded = headers["x-forwarded-host"];
 		const rawHost = Array.isArray(forwarded) ? forwarded[0] : forwarded ?? headers.host;
 		const host = origin ? new URL(origin).hostname : new URL(`http://${rawHost ?? "localhost"}`).hostname;
@@ -95,22 +179,22 @@ function parsePastedOAuthResult(input) {
 }
 function rejectImageGenerationStream(args) {
 	if (!args.imageGeneration && args.model !== `openai/gpt-image-2`) return;
-	throw new BadRequestException("qgrid: imageGeneration is not supported with streaming; use query or generateImage with qgrid.image() instead.");
+	throw new BadRequestException(SD("error.detail")("qgrid: imageGeneration is not supported with streaming; use query or generateImage with qgrid.image() instead."));
 }
 function rejectInvalidImageQuery(args) {
 	const standalone = args.model === `openai/${CODEX_IMAGE_GENERATION_MODEL}`;
 	if (!standalone && args.imageGeneration !== "auto") return;
-	if (standalone && args.imageGeneration !== true) throw new BadRequestException("qgrid: the image model requires imageGeneration: true; use qgrid.image() with generateImage.");
-	if (args.tools?.length || args.jsonSchema !== void 0) throw new BadRequestException("qgrid: automatic and standalone image generation do not support caller tools or structured output.");
-	if (args.imageGenerationOptions?.outputFormat && args.imageGenerationOptions.outputFormat !== "png") throw new BadRequestException("qgrid: automatic and standalone image generation only support PNG output.");
+	if (standalone && args.imageGeneration !== true) throw new BadRequestException(SD("error.detail")("qgrid: the image model requires imageGeneration: true; use qgrid.image() with generateImage."));
+	if (args.tools?.length || args.jsonSchema !== void 0) throw new BadRequestException(SD("error.detail")("qgrid: automatic and standalone image generation do not support caller tools or structured output."));
+	if (args.imageGenerationOptions?.outputFormat && args.imageGenerationOptions.outputFormat !== "png") throw new BadRequestException(SD("error.detail")("qgrid: automatic and standalone image generation only support PNG output."));
 }
 function rejectInvalidCallerSchemas(args) {
 	if (args.jsonSchema === void 0 && !args.tools?.length) return;
 	try {
 		buildAndValidateStrictOutputSchema(args);
 	} catch (error) {
-		if (error instanceof CallerSchemaValidationError || error instanceof ToolSchemaCompositionError) throw new BadRequestException(error.message);
-		if (error instanceof Error) throw new BadRequestException(`qgrid: caller schema cannot be normalized: ${error.message}`);
+		if (error instanceof CallerSchemaValidationError || error instanceof ToolSchemaCompositionError) throw new BadRequestException(SD("error.detail")(error.message));
+		if (error instanceof Error) throw new BadRequestException(SD("error.detail")(`qgrid: caller schema cannot be normalized: ${error.message}`));
 		throw error;
 	}
 }
@@ -118,10 +202,10 @@ async function resolveTokenName(args) {
 	if (!args.tokenName) return args;
 	const tokenProvider = args.tokenName.split("/", 1)[0];
 	const modelProvider = args.model?.split("/", 1)[0];
-	if (tokenProvider !== "anthropic" && tokenProvider !== "openai") throw new BadRequestException(`Invalid token name: ${args.tokenName}`);
-	if (modelProvider !== tokenProvider) throw new BadRequestException("Token provider does not match model provider");
+	if (!isProviderId(tokenProvider)) throw new BadRequestException(SD("error.detail")(`Invalid token name: ${args.tokenName}`));
+	if (modelProvider !== tokenProvider) throw new BadRequestException(SD("error.detail")("Token provider does not match model provider"));
 	const token = await TokenModel.findActiveByProviderAndName("A", tokenProvider, args.tokenName);
-	if (!token) throw new BadRequestException(`Active token not found: ${args.tokenName}`);
+	if (!token) throw new BadRequestException(SD("error.detail")(`Active token not found: ${args.tokenName}`));
 	return {
 		...args,
 		preferredTokenId: token.id,
@@ -155,6 +239,294 @@ function createHttpDisconnectHandle() {
 const logger = getLogger(["qgrid"]);
 const oauthLogger = getLogger(["qgrid", "oauth"]);
 const inflightAnthropicRefresh = /* @__PURE__ */ new Map();
+const mediaLogger = getLogger(["qgrid", "media"]);
+const MEDIA_TOOL_NAMES = {
+	image: "image_generation",
+	video: "video_generation",
+	stt: "transcription",
+	tts: "speech"
+};
+function grokNotReady() {
+	return QgridDispatcher.startupState.grok === "failed" ? new InternalServerErrorException(SD("qgrid.dispatcherFailed")("Grok")) : new ServiceUnavailableException(SD("qgrid.dispatcherStarting")("Grok"));
+}
+function grokMedia() {
+	const dispatcher = QgridDispatcher.grokDispatcher;
+	const generateImages = dispatcher?.generateImages;
+	const editImages = dispatcher?.editImages;
+	const startVideo = dispatcher?.startVideo;
+	const getVideo = dispatcher?.getVideo;
+	if (!dispatcher || !generateImages || !editImages || !startVideo || !getVideo) throw grokNotReady();
+	return {
+		generateImages: generateImages.bind(dispatcher),
+		editImages: editImages.bind(dispatcher),
+		startVideo: startVideo.bind(dispatcher),
+		getVideo: getVideo.bind(dispatcher)
+	};
+}
+function grokVoice() {
+	const dispatcher = QgridDispatcher.grokDispatcher;
+	const transcribe = dispatcher?.transcribe;
+	const speak = dispatcher?.speak;
+	if (!dispatcher || !transcribe || !speak) throw grokNotReady();
+	return {
+		transcribe: transcribe.bind(dispatcher),
+		speak: speak.bind(dispatcher)
+	};
+}
+var TooManyRequestsException = class extends SoException {
+	constructor(message) {
+		super(429, message);
+	}
+};
+/**
+* Every Grok token is cooling down. A 429 rather than a 503: the server error handler pins 503's
+* Retry-After to its startup interval, while this delay comes from the upstream cooldown.
+*/
+function grokRateLimited(error) {
+	let reply;
+	try {
+		const ctx = Sonamu.getContext();
+		if (ctx.transport === "http") reply = ctx.reply;
+	} catch {}
+	if (reply && !reply.raw.headersSent) reply.header("Retry-After", String(error.retryAfterSec));
+	return new TooManyRequestsException(SD("qgrid.grokRateLimited")(error.retryAfterSec));
+}
+/**
+* Caller-fault Grok errors become 400/429/503 at the chat and media boundaries; upstream and
+* provider failures propagate unchanged (500 by the server error handler). "No eligible token for
+* this request class" (no workers, in-flight cap, on-demand D6, ZDR video) is a 503, not a server
+* fault; every token cooling down is a 429 with the soonest retry delay.
+*/
+function throwGrokCallerError(cause) {
+	if (cause instanceof GrokInvalidRequestError) throw new BadRequestException(SD("qgrid.grokInvalidRequest")(cause.message));
+	if (cause instanceof GrokContentPolicyError) throw new BadRequestException(SD("qgrid.grokContentPolicy")(cause.message));
+	if (cause instanceof GrokCapabilityUnavailableError) throw new ServiceUnavailableException(SD("qgrid.grokCapabilityUnavailable")(cause.message));
+	if (cause instanceof GrokOnDemandExcludedError) throw new ServiceUnavailableException(SD("qgrid.grokOnDemandExcluded")(cause.tokenNames.join(", ")));
+	if (cause instanceof GrokZdrVideoUnavailableError) throw new ServiceUnavailableException(SD("qgrid.grokZdrVideoUnavailable")(cause.tokenNames.join(", ")));
+	if (cause instanceof GrokCapacityError) throw new ServiceUnavailableException(SD("qgrid.grokCapacity"));
+	if (cause instanceof GrokRateLimitedError) throw grokRateLimited(cause);
+	if (cause instanceof GrokNoWorkersError) throw new ServiceUnavailableException(SD("qgrid.grokNoWorkers")(cause.message));
+	throw cause;
+}
+var PayloadTooLargeException = class extends SoException {
+	constructor(message) {
+		super(413, message);
+	}
+};
+const MiB = 1024 * 1024;
+/**
+* Fastify rejects a body over `bodyLimit` before routing with FST_ERR_CTP_BODY_TOO_LARGE, which is
+* not a Sonamu exception and would otherwise answer 500. The server error handler applies this
+* first so the caller gets a Sonamu 413.
+*/
+function mapRequestBodyTooLarge(error) {
+	if ("code" in error && error.code === "FST_ERR_CTP_BODY_TOO_LARGE") return new PayloadTooLargeException(SD("qgrid.requestBodyTooLarge")(REQUEST_BODY_LIMIT_BYTES / MiB));
+	return error;
+}
+function parseMediaInput(schema, value) {
+	const parsed = schema.safeParse(value);
+	if (!parsed.success) {
+		const detail = parsed.error.issues.map((issue) => `${issue.path.join(".") || "input"}: ${issue.message}`).join("; ");
+		throw new BadRequestException(SD("qgrid.invalidInput")(detail));
+	}
+	return parsed.data;
+}
+async function resolveGrokTokenSelection(tokenName) {
+	if (!tokenName) return {};
+	if (!tokenName.startsWith("grok/")) throw new BadRequestException(SD("error.detail")("Token provider does not match model provider"));
+	const token = await TokenModel.findActiveByProviderAndName("A", "grok", tokenName);
+	if (!token) throw new BadRequestException(SD("error.detail")(`Active token not found: ${tokenName}`));
+	return {
+		preferredTokenId: token.id,
+		requirePreferredToken: true
+	};
+}
+function routeModelId(model, fallback) {
+	const id = model ? model.slice(5) : fallback;
+	return {
+		id,
+		route: `grok/${id}`
+	};
+}
+/** Adds the provider thread coordinate to the lifecycle run context without dropping either. */
+function mergeRunContext(lifecycle, threadCoord) {
+	if (!lifecycle && !threadCoord) return void 0;
+	const runContext = { ...lifecycle };
+	if (threadCoord) runContext.threadCoord = threadCoord;
+	return runContext;
+}
+function microUsd(usd) {
+	return usd === void 0 ? void 0 : Math.round(usd * MICRO_USD);
+}
+/** Reference-image log metadata. Data URLs keep their bytes only when `withData` (images). */
+function describeImageRefs(refs, withData) {
+	return refs.map((ref) => {
+		const match = /^data:([^;,]+);base64,(.*)$/.exec(ref);
+		if (!match) return { url: ref };
+		const [, mediaType = "", data = ""] = match;
+		const byteSize = Buffer.byteLength(data, "base64");
+		return withData ? {
+			mediaType,
+			data,
+			byteSize
+		} : {
+			mediaType,
+			byteSize
+		};
+	});
+}
+function imageTagForLog(b64, mimeType, alt) {
+	return `<img src="data:${mimeType};base64,${b64}" alt="${(alt ?? "generated image").replace(/[&"<>]/g, (ch) => `&#${ch.charCodeAt(0)};`)}" />`;
+}
+async function startMediaRun(loggerEnabled, start) {
+	if (loggerEnabled === false) return void 0;
+	return RequestLogModel.createRun({
+		user_prompt: start.prompt,
+		requested_model_name: start.model,
+		project_name: start.projectName,
+		is_image_generation: start.kind === "image"
+	});
+}
+function mediaToolSteps(kind, steps, durationMs) {
+	return steps.map((step, index) => {
+		const fields = {
+			step_index: 0,
+			type: "tool_call",
+			tool_call_index: index,
+			tool_call_id: step.toolCallId,
+			tool_name: MEDIA_TOOL_NAMES[kind],
+			tool_args: JSON.stringify(step.args)
+		};
+		if (step.result !== void 0) fields.tool_result = step.result;
+		fields.tool_duration_ms = durationMs;
+		return fields;
+	});
+}
+function mediaCostFields(kind, model, cost) {
+	if (kind === "image") return {
+		cost_usd: 0,
+		cost_source: cost?.costSource ?? null,
+		is_image_generation: true,
+		image_cost_usd: microUsd(cost?.costUsd) ?? null,
+		image_cost_method: cost ? `${cost.costSource === "provider" ? "reported" : "catalog"}:${model}:ticks=${cost.ticks}` : null
+	};
+	return {
+		cost_usd: microUsd(cost?.costUsd) ?? null,
+		cost_source: cost?.costSource ?? null
+	};
+}
+function mediaFinishFields(success) {
+	return {
+		status: "succeeded",
+		response: success.response,
+		token_name: success.tokenName,
+		requested_model_name: success.model,
+		model_name: success.model,
+		input_tokens: 0,
+		output_tokens: 0,
+		cache_read_tokens: 0,
+		cache_creation_tokens: 0,
+		duration_ms: success.durationMs,
+		...mediaCostFields(success.kind, success.model, success.cost)
+	};
+}
+async function finishMediaRun(requestLogId, success) {
+	if (requestLogId === void 0) return;
+	try {
+		for (const step of mediaToolSteps(success.kind, success.steps, success.durationMs)) await RequestLogModel.appendStep(requestLogId, step);
+		await RequestLogModel.finishRun(requestLogId, mediaFinishFields(success));
+	} catch (e) {
+		mediaLogger.error(`${success.kind} request log failed: ${e instanceof Error ? e.message : String(e)}`);
+	}
+}
+async function failMediaRun(requestLogId, cause, aborted) {
+	if (requestLogId === void 0) return;
+	try {
+		await RequestLogModel.finishRun(requestLogId, {
+			status: aborted ? "aborted" : "error",
+			error_message: aborted ? "client disconnected" : cause instanceof Error ? cause.message : String(cause)
+		});
+	} catch (e) {
+		mediaLogger.error(`media request log failed: ${e instanceof Error ? e.message : String(e)}`);
+	}
+}
+/**
+* One provider call against an open media run. A failure closes the run as error (or aborted on
+* client disconnect) and surfaces as the caller-facing Grok error; success leaves the run open.
+*/
+async function dispatchMediaCall(requestLogId, call) {
+	const disconnect = createHttpDisconnectHandle();
+	let result;
+	try {
+		result = await call(disconnect.signal);
+	} catch (e) {
+		await failMediaRun(requestLogId, e, disconnect.signal.aborted);
+		throwGrokCallerError(e);
+	} finally {
+		disconnect.dispose();
+	}
+	return result;
+}
+/**
+* A one-shot media endpoint: open the run, make the provider call, then log the result. `dispatch`
+* returns the endpoint output and what the run records about it.
+*/
+async function runMediaEndpoint(start, dispatch) {
+	const requestLogId = await startMediaRun(start.logger, start);
+	const startedAt = Date.now();
+	const { output, log } = await dispatchMediaCall(requestLogId, (signal) => dispatch(signal, requestLogId));
+	await finishMediaRun(requestLogId, {
+		...log,
+		kind: start.kind,
+		model: start.model,
+		durationMs: Date.now() - startedAt
+	});
+	return output;
+}
+const VIDEO_JOB_TTL_MS = 1440 * 6e4;
+const VIDEO_JOB_MAX = 1e4;
+const videoJobs = /* @__PURE__ */ new Map();
+function pruneVideoJobs(now) {
+	for (const [handle, job] of videoJobs) {
+		if (now - job.createdAt < VIDEO_JOB_TTL_MS && videoJobs.size <= VIDEO_JOB_MAX) break;
+		videoJobs.delete(handle);
+	}
+}
+function videoToolCallId(job) {
+	return `video_generation:${job.requestId}`;
+}
+async function finishVideoRun(job, final, cost) {
+	if (job.requestLogId === void 0) return;
+	try {
+		await RequestLogModel.continueToolRun(job.requestLogId, [{
+			toolCallId: videoToolCallId(job),
+			output: JSON.stringify({
+				status: final.status,
+				url: final.url,
+				durationSec: final.durationSec,
+				costInUsdTicks: final.costInUsdTicks,
+				error: final.error
+			}),
+			isError: final.status === "failed"
+		}]);
+		const fields = mediaFinishFields({
+			kind: "video",
+			model: job.model,
+			tokenName: job.tokenName,
+			durationMs: Date.now() - job.createdAt,
+			response: final.url ?? "",
+			cost
+		});
+		await RequestLogModel.finishRun(job.requestLogId, final.status === "done" ? fields : {
+			...fields,
+			status: "error",
+			error_message: final.error ?? "video generation failed"
+		});
+	} catch (e) {
+		mediaLogger.error(`video request log failed: ${e instanceof Error ? e.message : String(e)}`);
+	}
+}
+const GROK_TTS_LOG_MODEL = "grok/tts";
 var QgridFrameClass = class extends BaseFrameClass {
 	constructor() {
 		super("Qgrid");
@@ -165,7 +537,11 @@ var QgridFrameClass = class extends BaseFrameClass {
 		const resolvedArgs = await resolveTokenName(args);
 		const disconnect = createHttpDisconnectHandle();
 		try {
-			if (resolvedArgs.logger === false) return await QgridDispatcher.query(resolvedArgs, disconnect.signal);
+			if (resolvedArgs.logger === false) try {
+				return await QgridDispatcher.query(resolvedArgs, disconnect.signal);
+			} catch (e) {
+				throwGrokCallerError(e);
+			}
 			const { requestLogId, stepIndex } = await beforeQuery(resolvedArgs);
 			let result;
 			try {
@@ -177,26 +553,23 @@ var QgridFrameClass = class extends BaseFrameClass {
 					result: completedDriver
 				}] : [];
 				if (disconnect.signal.aborted) await finishRunAborted(requestLogId, resolvedArgs, ...completedStep);
-				else await finishRunWithError(requestLogId, e.message, resolvedArgs, ...completedStep);
-				throw e;
+				else await finishRunWithError(requestLogId, e instanceof Error ? e.message : String(e), resolvedArgs, ...completedStep);
+				throwGrokCallerError(e);
 			}
 			try {
 				const lifecycle = await afterQuery(requestLogId, stepIndex, resolvedArgs, result);
 				if (disconnect.signal.aborted) await finishRunAborted(requestLogId, resolvedArgs);
 				const threadCoord = result.runContext?.threadCoord;
-				const runContext = lifecycle.runContext || threadCoord ? {
-					...lifecycle.runContext,
-					...threadCoord ? { threadCoord } : {}
-				} : void 0;
+				const runContext = mergeRunContext(lifecycle.runContext, threadCoord);
 				return {
 					...result,
 					requestLogId,
 					runContext
 				};
 			} catch (e) {
-				logger.error(`query afterQuery failed: ${e.message}`);
+				logger.error(`query afterQuery failed: ${e instanceof Error ? e.message : String(e)}`);
 				if (disconnect.signal.aborted) await finishRunAborted(requestLogId, resolvedArgs);
-				else await finishRunWithError(requestLogId, e.message, resolvedArgs);
+				else await finishRunWithError(requestLogId, e instanceof Error ? e.message : String(e), resolvedArgs);
 				return {
 					...result,
 					requestLogId
@@ -249,7 +622,7 @@ var QgridFrameClass = class extends BaseFrameClass {
 				}
 			}, abortController.signal);
 		} catch (e) {
-			streamError = e;
+			streamError = e instanceof Error ? e : new Error(String(e));
 		}
 		if (clientClosed && !streamResult) {
 			if (runInfo) await finishRunAborted(runInfo.requestLogId, args);
@@ -258,32 +631,29 @@ var QgridFrameClass = class extends BaseFrameClass {
 		}
 		if (streamResult) {
 			const threadCoord = streamResult.runContext?.threadCoord;
-			let runContext = threadCoord !== void 0 ? { threadCoord } : void 0;
+			let runContext = threadCoord === void 0 ? void 0 : { threadCoord };
 			if (runInfo) try {
-				const lifecycle = await afterQuery(runInfo.requestLogId, runInfo.stepIndex, args, streamResult);
-				runContext = lifecycle.runContext || threadCoord ? {
-					...lifecycle.runContext,
-					...threadCoord ? { threadCoord } : {}
-				} : void 0;
+				runContext = mergeRunContext((await afterQuery(runInfo.requestLogId, runInfo.stepIndex, args, streamResult)).runContext, threadCoord);
 				if (clientClosed) {
 					await finishRunAborted(runInfo.requestLogId, args);
 					await sse.end();
 					return;
 				}
 			} catch (e) {
-				logger.error(`stream afterQuery failed: ${e.message}`);
-				await finishRunWithError(runInfo.requestLogId, e.message, args);
+				logger.error(`stream afterQuery failed: ${e instanceof Error ? e.message : String(e)}`);
+				await finishRunWithError(runInfo.requestLogId, e instanceof Error ? e.message : String(e), args);
 				if (clientClosed) {
 					await finishRunAborted(runInfo.requestLogId, args);
 					await sse.end();
 					return;
 				}
 			}
-			if (!clientClosed && !sse.closed) sse.publish("done", {
-				...streamResult,
-				...runInfo ? { requestLogId: runInfo.requestLogId } : {},
-				runContext
-			});
+			if (!clientClosed && !sse.closed) {
+				const done = { ...streamResult };
+				if (runInfo) done.requestLogId = runInfo.requestLogId;
+				done.runContext = runContext;
+				sse.publish("done", done);
+			}
 		} else if (streamError) {
 			if (runInfo) await finishRunWithError(runInfo.requestLogId, streamError.message, args);
 			if (!clientClosed && !sse.closed) sse.publish("error", { message: streamError.message });
@@ -375,8 +745,8 @@ var QgridFrameClass = class extends BaseFrameClass {
 		return { added: true };
 	}
 	async updateToken(id, name, quotaThreshold, weight, keepaliveEnabled) {
-		if (quotaThreshold !== void 0 && quotaThreshold !== null && (!Number.isInteger(quotaThreshold) || quotaThreshold < 1 || quotaThreshold > 100)) throw new BadRequestException("quotaThreshold must be an integer between 1 and 100, or null");
-		if (weight !== void 0 && (!Number.isInteger(weight) || weight < 1 || weight > 100)) throw new BadRequestException("weight must be an integer between 1 and 100");
+		if (quotaThreshold !== void 0 && quotaThreshold !== null && (!Number.isInteger(quotaThreshold) || quotaThreshold < 1 || quotaThreshold > 100)) throw new BadRequestException(SD("error.detail")("quotaThreshold must be an integer between 1 and 100, or null"));
+		if (weight !== void 0 && (!Number.isInteger(weight) || weight < 1 || weight > 100)) throw new BadRequestException(SD("error.detail")("weight must be an integer between 1 and 100"));
 		const patch = {};
 		if (name !== void 0) patch.name = name;
 		if (quotaThreshold !== void 0) patch.quota_threshold = quotaThreshold;
@@ -397,7 +767,7 @@ var QgridFrameClass = class extends BaseFrameClass {
 	async toggleToken(id) {
 		const result = await TokenModel.toggleActive(id);
 		if (!result) return { active: false };
-		if (result.reauthRequired) throw new BadRequestException("Re-login required");
+		if (result.reauthRequired) throw new BadRequestException(SD("error.detail")("Re-login required"));
 		return { active: result.active };
 	}
 	async oauthStart(name) {
@@ -417,12 +787,25 @@ var QgridFrameClass = class extends BaseFrameClass {
 	}
 	async oauthComplete(pastedCode) {
 		const result = parsePastedOAuthResult(pastedCode);
-		if (!result) throw new BadRequestException("expected the callback URL or code shown after login, in code#state form");
+		if (!result) {
+			const grokState = await getGrokLatestState();
+			const grokPending = grokState ? await getOAuthState(grokState) : void 0;
+			if (grokState && grokPending?.provider === "grok" && pastedCode.trim()) {
+				await deleteOAuthState(grokState);
+				await this.completeGrokLogin(pastedCode, grokState, grokPending);
+				return {
+					added: true,
+					name: grokPending.name
+				};
+			}
+			throw new BadRequestException(SD("error.detail")("expected the callback URL or code shown after login, in code#state form"));
+		}
 		const { code, state } = result;
 		const pending = await getOAuthState(state);
-		if (!pending) throw new BadRequestException("login session not found or expired — start the login again");
+		if (!pending) throw new BadRequestException(SD("error.detail")("login session not found or expired — start the login again"));
 		await deleteOAuthState(state);
 		if (pending.provider === "openai") await this.completeOpenAILogin(code, pending);
+		else if (pending.provider === "grok") await this.completeGrokLogin(pastedCode, state, pending);
 		else await this.completeAnthropicLogin(code, state, pending);
 		return {
 			added: true,
@@ -453,6 +836,31 @@ var QgridFrameClass = class extends BaseFrameClass {
 		logger.info(`OpenAI token saved for ${pending.name}`);
 		notifyTokenAdded(pending.name, "openai");
 	}
+	async completeGrokLogin(codeOrUrl, state, pending) {
+		let credentials;
+		try {
+			credentials = await completeGrokOAuth({
+				codeOrUrl,
+				verifier: pending.codeVerifier,
+				redirectUri: pending.redirectUri,
+				state
+			});
+		} catch (error) {
+			grokOAuthBadRequest(error);
+		}
+		await this.saveGrokToken(credentials, pending.name);
+	}
+	async saveGrokToken(candidate, name) {
+		const parsed = GrokCredentials$1.safeParse(candidate);
+		if (!parsed.success) throw new BadRequestException(SD("qgrid.grokNotOAuthToken"));
+		await TokenModel.replaceByAccount("grok", parsed.data.userId, {
+			provider: "grok",
+			credentials: parsed.data,
+			name
+		});
+		logger.info(`Grok token saved for ${name}`);
+		notifyTokenAdded(name, "grok");
+	}
 	async handleOAuthCallback(code, state, reply) {
 		const pending = await getOAuthState(state);
 		if (!pending) {
@@ -462,6 +870,7 @@ var QgridFrameClass = class extends BaseFrameClass {
 		await deleteOAuthState(state);
 		try {
 			if (pending.provider === "openai") await this.completeOpenAILogin(code, pending);
+			else if (pending.provider === "grok") await this.completeGrokLogin(code, state, pending);
 			else await this.completeAnthropicLogin(code, state, pending);
 			return reply.redirect(`/?oauth=success&name=${encodeURIComponent(pending.name)}`);
 		} catch {
@@ -480,7 +889,7 @@ var QgridFrameClass = class extends BaseFrameClass {
 		else try {
 			redirectUri = await startOpenAICallbackRelay(trustedLoopbackBase(), OAUTH_STATE_TTL_MS);
 		} catch {
-			throw new BadRequestException(`OpenAI login needs local port ${OPENAI_CALLBACK_PORTS.join(" or ")} — close any running \`codex login\` and retry`);
+			throw new BadRequestException(SD("error.detail")(`OpenAI login needs local port ${OPENAI_CALLBACK_PORTS.join(" or ")} — close any running \`codex login\` and retry`));
 		}
 		const authUrl = buildOpenAIAuthUrl(codeChallenge, state, redirectUri);
 		await setOAuthState(state, {
@@ -494,6 +903,381 @@ var QgridFrameClass = class extends BaseFrameClass {
 			mode
 		};
 	}
+	async oauthStartGrok(name) {
+		const state = crypto.randomBytes(32).toString("base64url");
+		let started;
+		try {
+			started = await startGrokOAuth({ state });
+		} catch (error) {
+			grokOAuthBadRequest(error);
+		}
+		await setOAuthState(state, {
+			codeVerifier: started.verifier,
+			name,
+			redirectUri: started.redirectUri,
+			provider: "grok"
+		});
+		await setGrokLatestState(state);
+		return {
+			authUrl: started.authorizeUrl,
+			mode: "code"
+		};
+	}
+	async oauthStartGrokDevice(name) {
+		let device;
+		try {
+			device = await startGrokDeviceCode();
+		} catch (error) {
+			grokOAuthBadRequest(error);
+		}
+		await setGrokDeviceState(device.deviceCode, {
+			name,
+			interval: device.interval,
+			expiresAtMs: Date.now() + device.expiresIn * 1e3
+		});
+		return device;
+	}
+	async oauthPollGrokDevice(deviceCode) {
+		const pending = await getGrokDeviceState(deviceCode);
+		if (!pending) throw new BadRequestException(SD("error.detail")("login session not found or expired — start the login again"));
+		let result;
+		try {
+			result = await pollGrokDeviceCode({
+				deviceCode,
+				interval: pending.interval
+			});
+		} catch (error) {
+			if (error instanceof GrokOAuthError && !error.options.retryable) await deleteGrokDeviceState(deviceCode);
+			grokOAuthBadRequest(error);
+		}
+		if (result.status === "pending") {
+			const slowDown = result.interval > pending.interval;
+			if (slowDown) await setGrokDeviceState(deviceCode, {
+				...pending,
+				interval: result.interval
+			});
+			return {
+				status: slowDown ? "slow_down" : "pending",
+				intervalSec: result.interval
+			};
+		}
+		await deleteGrokDeviceState(deviceCode);
+		await this.saveGrokToken(result.credentials, pending.name);
+		return {
+			status: "added",
+			name: pending.name
+		};
+	}
+	async generateImages(params) {
+		const input = parseMediaInput(GenerateImagesInput, params);
+		const media = grokMedia();
+		const selection = await resolveGrokTokenSelection(input.tokenName);
+		const { id, route } = routeModelId(input.model, GROK_IMAGE_DEFAULT_MODEL);
+		const refs = input.referenceImages ?? [];
+		return runMediaEndpoint({
+			kind: "image",
+			model: route,
+			prompt: input.prompt,
+			projectName: input.projectName,
+			logger: input.logger
+		}, async (signal, requestLogId) => {
+			const request = {
+				model: id,
+				prompt: input.prompt,
+				n: input.n,
+				aspectRatio: input.aspectRatio,
+				resolution: input.resolution,
+				quality: input.quality,
+				outputFormat: input.outputFormat,
+				signal,
+				...selection
+			};
+			const dispatched = refs.length ? await media.editImages({
+				...request,
+				images: refs
+			}) : await media.generateImages(request);
+			const decoded = decodeGrokImages(dispatched.result);
+			const cost = grokImageCost(id, decoded.images.length, decoded.costInUsdTicks);
+			const output = {
+				model: route,
+				tokenName: dispatched.tokenName,
+				images: decoded.images.map((image) => {
+					const generated = {
+						b64: Buffer.from(image.bytes).toString("base64"),
+						mimeType: image.mediaType
+					};
+					if (image.revisedPrompt) generated.revisedPrompt = image.revisedPrompt;
+					return generated;
+				}),
+				usage: { imageCount: decoded.images.length }
+			};
+			if (decoded.costInUsdTicks !== void 0) output.usage.costInUsdTicks = decoded.costInUsdTicks;
+			if (cost) {
+				output.costUsd = cost.costUsd;
+				output.costSource = cost.costSource;
+			}
+			if (requestLogId !== void 0) output.requestLogId = requestLogId;
+			return {
+				output,
+				log: {
+					tokenName: output.tokenName,
+					cost,
+					response: output.images.map((image) => imageTagForLog(image.b64, image.mimeType, image.revisedPrompt)).join("\n"),
+					steps: output.images.map((image, index) => {
+						const args = {
+							kind: "image",
+							prompt: input.prompt,
+							model: route,
+							requestedOptions: {
+								n: input.n,
+								aspectRatio: input.aspectRatio,
+								resolution: input.resolution,
+								quality: input.quality,
+								outputFormat: input.outputFormat
+							},
+							imageCount: output.usage.imageCount
+						};
+						if (cost) {
+							args.costSource = cost.costSource;
+							args.costInUsdTicks = cost.ticks;
+						}
+						if (index === 0 && refs.length) args.inputImages = describeImageRefs(refs, true);
+						return {
+							toolCallId: `image_generation:0:${index}`,
+							args,
+							result: imageTagForLog(image.b64, image.mimeType, image.revisedPrompt)
+						};
+					})
+				}
+			};
+		});
+	}
+	async videoStart(params) {
+		const input = parseMediaInput(VideoStartInput, params);
+		const media = grokMedia();
+		const selection = await resolveGrokTokenSelection(input.tokenName);
+		const { id, route } = routeModelId(input.model, GROK_VIDEO_DEFAULT_MODEL);
+		const requestLogId = await startMediaRun(input.logger, {
+			kind: "video",
+			model: route,
+			prompt: input.prompt,
+			projectName: input.projectName
+		});
+		const startedAt = Date.now();
+		const started = await dispatchMediaCall(requestLogId, (signal) => media.startVideo({
+			model: id,
+			prompt: input.prompt,
+			duration: input.duration,
+			aspectRatio: input.aspectRatio,
+			resolution: input.resolution,
+			image: input.image,
+			lastFrame: input.lastFrame,
+			referenceImages: input.referenceImages,
+			mode: input.mode,
+			signal,
+			...selection
+		}));
+		const now = Date.now();
+		pruneVideoJobs(now);
+		const jobHandle = crypto.randomBytes(16).toString("base64url");
+		const job = {
+			tokenId: started.tokenId,
+			tokenName: started.tokenName,
+			requestId: started.result.request_id,
+			owner: input.projectName ?? null,
+			model: route,
+			createdAt: now
+		};
+		if (requestLogId !== void 0) job.requestLogId = requestLogId;
+		videoJobs.set(jobHandle, job);
+		if (requestLogId !== void 0) {
+			const refs = [
+				...input.image ? [input.image] : [],
+				...input.lastFrame ? [input.lastFrame] : [],
+				...input.referenceImages ?? []
+			];
+			const args = {
+				kind: "video",
+				prompt: input.prompt,
+				model: route,
+				requestedOptions: {
+					duration: input.duration,
+					aspectRatio: input.aspectRatio,
+					resolution: input.resolution,
+					mode: input.mode
+				}
+			};
+			if (refs.length) args.inputImages = describeImageRefs(refs, false);
+			const [step] = mediaToolSteps("video", [{
+				toolCallId: videoToolCallId(job),
+				args
+			}], now - startedAt);
+			try {
+				await RequestLogModel.appendStep(requestLogId, step);
+			} catch (e) {
+				mediaLogger.error(`video request log failed: ${e instanceof Error ? e.message : String(e)}`);
+			}
+		}
+		const output = {
+			jobHandle,
+			model: route
+		};
+		if (requestLogId !== void 0) output.requestLogId = requestLogId;
+		return output;
+	}
+	async videoStatus(params) {
+		const input = parseMediaInput(VideoStatusInput, params);
+		pruneVideoJobs(Date.now());
+		const job = videoJobs.get(input.jobHandle);
+		if (!job || job.owner !== (input.projectName ?? null)) throw new NotFoundException(SD("qgrid.videoJobNotFound"));
+		if (job.final) return job.final;
+		const media = grokMedia();
+		const disconnect = createHttpDisconnectHandle();
+		let summary;
+		let durationSec;
+		try {
+			const polled = await media.getVideo(job.tokenId, job.requestId, disconnect.signal);
+			summary = summarizeGrokVideoStatus(polled.result);
+			durationSec = polled.result.video?.duration ?? void 0;
+		} catch (e) {
+			if (!(e instanceof GrokContentPolicyError)) throwGrokCallerError(e);
+			summary = {
+				status: "failed",
+				mimeType: "video/mp4",
+				error: e.message
+			};
+		} finally {
+			disconnect.dispose();
+		}
+		if (job.final) return job.final;
+		const status = {
+			status: summary.status,
+			mimeType: "video/mp4"
+		};
+		if (job.requestLogId !== void 0) status.requestLogId = job.requestLogId;
+		if (summary.status === "pending") return status;
+		const cost = grokReportedCost(summary.usageTicks);
+		const final = status;
+		if (summary.url) final.url = summary.url;
+		if (durationSec !== void 0) final.durationSec = durationSec;
+		if (cost) {
+			final.costInUsdTicks = cost.ticks;
+			final.costUsd = cost.costUsd;
+		}
+		if (summary.error) final.error = summary.error;
+		job.final = final;
+		await finishVideoRun(job, final, cost);
+		return final;
+	}
+	async transcribe(params) {
+		const input = parseMediaInput(TranscribeInput, params);
+		const voice = grokVoice();
+		const selection = await resolveGrokTokenSelection(input.tokenName);
+		const { id, route } = routeModelId(input.model, GROK_STT_DEFAULT_MODEL);
+		const audio = new Uint8Array(Buffer.from(input.audio, "base64"));
+		return runMediaEndpoint({
+			kind: "stt",
+			model: route,
+			prompt: `[audio ${input.mediaType} ${audio.byteLength} bytes]`,
+			projectName: input.projectName,
+			logger: input.logger
+		}, async (signal, requestLogId) => {
+			const dispatched = await voice.transcribe({
+				audio,
+				mediaType: input.mediaType,
+				model: id,
+				language: input.language,
+				signal,
+				...selection
+			});
+			const { text, language, duration } = dispatched.result;
+			const output = {
+				text,
+				model: route,
+				tokenName: dispatched.tokenName
+			};
+			if (language) output.language = language;
+			if (duration !== void 0) output.durationSec = duration;
+			if (requestLogId !== void 0) output.requestLogId = requestLogId;
+			return {
+				output,
+				log: {
+					tokenName: output.tokenName,
+					response: output.text,
+					steps: [{
+						toolCallId: "transcription:0",
+						args: {
+							kind: "stt",
+							model: route,
+							mediaType: input.mediaType,
+							audioBytes: audio.byteLength,
+							language: input.language,
+							durationSec: output.durationSec
+						},
+						result: JSON.stringify({
+							text: output.text,
+							language: output.language,
+							durationSec: output.durationSec
+						})
+					}]
+				}
+			};
+		});
+	}
+	async speak(params) {
+		const input = parseMediaInput(SpeakInput, params);
+		const voice = grokVoice();
+		const selection = await resolveGrokTokenSelection(input.tokenName);
+		const route = input.model ?? GROK_TTS_LOG_MODEL;
+		const request = {
+			text: input.text,
+			voice: input.voice ?? "ara",
+			language: input.language ?? "en",
+			format: input.format ?? "mp3"
+		};
+		return runMediaEndpoint({
+			kind: "tts",
+			model: route,
+			prompt: input.text,
+			projectName: input.projectName,
+			logger: input.logger
+		}, async (signal, requestLogId) => {
+			const dispatched = await voice.speak({
+				...request,
+				signal,
+				...selection
+			});
+			const audioBytes = dispatched.result.audio.byteLength;
+			const output = {
+				audio: Buffer.from(dispatched.result.audio).toString("base64"),
+				mimeType: dispatched.result.mediaType,
+				tokenName: dispatched.tokenName
+			};
+			if (requestLogId !== void 0) output.requestLogId = requestLogId;
+			return {
+				output,
+				log: {
+					tokenName: output.tokenName,
+					response: `[audio ${output.mimeType} ${audioBytes} bytes]`,
+					steps: [{
+						toolCallId: "speech:0",
+						args: {
+							kind: "tts",
+							model: route,
+							voice: request.voice,
+							language: request.language,
+							format: request.format,
+							characters: input.text.length
+						},
+						result: JSON.stringify({
+							mimeType: output.mimeType,
+							audioBytes
+						})
+					}]
+				}
+			};
+		});
+	}
 	async usage(tokenId) {
 		const { rows: allTokens } = await TokenModel.findMany("A");
 		const entry = tokenId ? allTokens.find((e) => e.id === tokenId) : allTokens.findLast((e) => e.active && e.provider === "anthropic");
@@ -521,15 +1305,33 @@ var QgridFrameClass = class extends BaseFrameClass {
 					} : null
 				};
 			} catch (e) {
-				return { error: `OpenAI usage failed: ${e.message}` };
+				return { error: `OpenAI usage failed: ${e instanceof Error ? e.message : String(e)}` };
 			}
 		}
+		if (entry.provider === "grok") {
+			const snapshot = entry.active ? grokTokenSnapshot(entry.id) : void 0;
+			const billing = snapshot?.lastBilling;
+			const storedTier = GrokCredentials.safeParse(entry.credentials).data?.subscriptionTier;
+			return {
+				provider: "grok",
+				fiveHour: null,
+				sevenDay: billing ? {
+					utilization: billing.utilizationPct,
+					resetsAt: billing.periodEnd
+				} : null,
+				periodType: billing?.periodType ?? null,
+				tier: snapshot?.lastTier ?? storedTier ?? null,
+				onDemandExcluded: snapshot?.onDemandExcluded ?? false,
+				zdrVideoExcluded: snapshot?.zdrVideoExcluded ?? false,
+				keepaliveApplicable: false
+			};
+		}
 		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}`);
+			oauthLogger.warn(`refresh failed for ${entry.name}: ${e instanceof Error ? e.message : String(e)}`);
 			return { error: "Token refresh failed; usage is unavailable" };
 		}
 		const raw = await fetchUsage(accessToken);
@@ -539,13 +1341,14 @@ var QgridFrameClass = class extends BaseFrameClass {
 			if (retried.error) return { error: retried.error };
 			return convertAnthropicUsage(retried);
 		} catch (e) {
-			oauthLogger.warn(`refresh failed for ${entry.name}: ${e.message}`);
+			oauthLogger.warn(`refresh failed for ${entry.name}: ${e instanceof Error ? e.message : String(e)}`);
 			return { error: "Token refresh failed; usage is unavailable" };
 		}
 		if (raw.error) return { error: raw.error };
 		return convertAnthropicUsage(raw);
 	}
 	async refreshToken(token) {
+		if (token.provider === "grok") return this.refreshGrokToken(token);
 		const inflight = inflightAnthropicRefresh.get(token.id);
 		if (inflight) return inflight;
 		const promise = this.doRefreshToken(token);
@@ -556,6 +1359,12 @@ var QgridFrameClass = class extends BaseFrameClass {
 			inflightAnthropicRefresh.delete(token.id);
 		}
 	}
+	grokRefresher = null;
+	async refreshGrokToken(token) {
+		if (!this.grokRefresher) throw new Error("Grok refresher not initialized");
+		const current = GrokCredentials$1.parse(token.credentials);
+		return (await this.grokRefresher.refresh(token.id, current, (creds) => persistGrokCredentials(token.id, creds))).accessToken;
+	}
 	async doRefreshToken(token) {
 		const creds = token.credentials;
 		const rt = getRefreshToken(creds);
@@ -756,6 +1565,78 @@ __decorate([
 	__decorateMetadata("design:paramtypes", [String]),
 	__decorateMetadata("design:returntype", Promise)
 ], QgridFrameClass.prototype, "oauthStartOpenAI", null);
+__decorate([
+	api({
+		httpMethod: "POST",
+		clients: ["axios", "tanstack-mutation"]
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [String]),
+	__decorateMetadata("design:returntype", Promise)
+], QgridFrameClass.prototype, "oauthStartGrok", null);
+__decorate([
+	api({
+		httpMethod: "POST",
+		clients: ["axios", "tanstack-mutation"]
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [String]),
+	__decorateMetadata("design:returntype", Promise)
+], QgridFrameClass.prototype, "oauthStartGrokDevice", null);
+__decorate([
+	api({
+		httpMethod: "POST",
+		clients: ["axios", "tanstack-mutation"]
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [String]),
+	__decorateMetadata("design:returntype", Promise)
+], QgridFrameClass.prototype, "oauthPollGrokDevice", null);
+__decorate([
+	api({
+		httpMethod: "POST",
+		clients: ["axios", "tanstack-mutation"]
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [typeof GenerateImagesInput === "undefined" ? Object : GenerateImagesInput]),
+	__decorateMetadata("design:returntype", Promise)
+], QgridFrameClass.prototype, "generateImages", null);
+__decorate([
+	api({
+		httpMethod: "POST",
+		clients: ["axios", "tanstack-mutation"]
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [typeof VideoStartInput === "undefined" ? Object : VideoStartInput]),
+	__decorateMetadata("design:returntype", Promise)
+], QgridFrameClass.prototype, "videoStart", null);
+__decorate([
+	api({
+		httpMethod: "POST",
+		clients: ["axios", "tanstack-mutation"]
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [typeof VideoStatusInput === "undefined" ? Object : VideoStatusInput]),
+	__decorateMetadata("design:returntype", Promise)
+], QgridFrameClass.prototype, "videoStatus", null);
+__decorate([
+	api({
+		httpMethod: "POST",
+		clients: ["axios", "tanstack-mutation"]
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [typeof TranscribeInput === "undefined" ? Object : TranscribeInput]),
+	__decorateMetadata("design:returntype", Promise)
+], QgridFrameClass.prototype, "transcribe", null);
+__decorate([
+	api({
+		httpMethod: "POST",
+		clients: ["axios", "tanstack-mutation"]
+	}),
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [typeof SpeakInput === "undefined" ? Object : SpeakInput]),
+	__decorateMetadata("design:returntype", Promise)
+], QgridFrameClass.prototype, "speak", null);
 __decorate([
 	api({
 		httpMethod: "GET",
@@ -789,6 +1670,6 @@ function convertAnthropicUsage(raw) {
 	};
 }
 //#endregion
-export { QgridFrame };
+export { QgridFrame, mapRequestBodyTooLarge, persistGrokCredentials };
 
-//# 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, type FastifyRequest } 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 { CallerSchemaValidationError } from \"../../utils/providers/common/schema-validation\";\nimport {\n  OPENAI_CALLBACK_PORTS,\n  openAICallbackRedirectUri,\n  startOpenAICallbackRelay,\n} from \"../../utils/providers/openai/openai-callback-relay\";\nimport {\n  buildOpenAIAuthUrl,\n  exchangeOpenAICode,\n  generateOpenAIPKCE,\n} from \"../../utils/providers/openai/openai-oauth\";\nimport { MICRO_USD, RequestLogModel } from \"../request-log/request-log.model\";\nimport { type RequestLogListParams } from \"../request-log/request-log.types\";\nimport { type TokenSubsetA } from \"../sonamu.generated\";\nimport { TokenModel, type TokenUpdateFields } from \"../token/token.model\";\nimport { TokenCredentials } from \"../token/token.types\";\nimport {\n  CONSOLE_CALLBACK_URL,\n  type AnthropicUsageRaw,\n  buildAuthUrl,\n  exchangeCodeForTokens,\n  fetchUsage,\n  generatePKCE,\n  refreshAccessToken,\n  RefreshFailedError,\n} from \"./oauth\";\nimport { CODEX_IMAGE_GENERATION_MODEL } from \"./qgrid-image-generation\";\nimport {\n  afterQuery,\n  beforeQuery,\n  finishRunAborted,\n  finishRunWithError,\n} from \"./qgrid-run-lifecycle\";\nimport {\n  buildAndValidateStrictOutputSchema,\n  completedDriverFromImageFailure,\n  type InternalQueryInput,\n  QgridDispatcher,\n} 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\";\nimport { deactivateAuthDeadToken, notifyTokenAdded } from \"./token-death\";\nimport { ToolSchemaCompositionError } from \"./tool-emulation-schema\";\n\nconst pendingStreams = new Map<string, QueryInput>();\n\ntype PendingOAuth = {\n  codeVerifier: string;\n  name: string;\n  redirectUri: string;\n  provider: \"anthropic\" | \"openai\";\n};\nconst OAUTH_STATE_PREFIX = \"oauth:state:\";\nconst OAUTH_STATE_TTL = \"5m\";\nconst OAUTH_STATE_TTL_MS = 5 * 60_000;\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\nconst trustedLoopbackBase = () => `http://localhost:${process.env.PORT ?? \"44900\"}`;\n\nfunction isRemoteOAuthRequest(): boolean {\n  try {\n    const { headers } = Sonamu.getContext();\n    const origin = typeof headers.origin === \"string\" ? headers.origin : undefined;\n    const forwarded = headers[\"x-forwarded-host\"];\n    const rawHost = Array.isArray(forwarded) ? forwarded[0] : (forwarded ?? headers.host);\n    const host = origin\n      ? new URL(origin).hostname\n      : new URL(`http://${rawHost ?? \"localhost\"}`).hostname;\n    return !new Set([\"localhost\", \"127.0.0.1\", \"::1\", \"[::1]\"]).has(host);\n  } catch {}\n  return false;\n}\n\n// Anthropic's remote/manual flow uses its fixed console callback. Headers may select between two\n// allowlisted URIs, but never contribute authority or path bytes to either URI.\nfunction resolveOAuthRedirect(): { redirectUri: string; mode: \"redirect\" | \"code\" } {\n  if (isRemoteOAuthRequest()) {\n    return { redirectUri: CONSOLE_CALLBACK_URL, mode: \"code\" };\n  }\n  return { redirectUri: `${trustedLoopbackBase()}/callback`, mode: \"redirect\" };\n}\n\nfunction parsePastedOAuthResult(input: string): { code: string; state: string } | null {\n  const trimmed = input.trim();\n  try {\n    const callback = new URL(trimmed);\n    const code = callback.searchParams.get(\"code\")?.trim() ?? \"\";\n    const state = callback.searchParams.get(\"state\")?.trim() ?? \"\";\n    if (code && state) return { code, state };\n  } catch {}\n\n  const separatorAt = trimmed.indexOf(\"#\");\n  const code = separatorAt > 0 ? trimmed.slice(0, separatorAt).trim() : \"\";\n  const state = separatorAt > 0 ? trimmed.slice(separatorAt + 1).trim() : \"\";\n  return code && state ? { code, state } : null;\n}\n\nfunction rejectImageGenerationStream(args: QueryInput): void {\n  if (!args.imageGeneration && args.model !== `openai/${CODEX_IMAGE_GENERATION_MODEL}`) return;\n  throw new BadRequestException(\n    \"qgrid: imageGeneration is not supported with streaming; use query or generateImage with qgrid.image() instead.\" as LocalizedString,\n  );\n}\n\nfunction rejectInvalidImageQuery(args: QueryInput): void {\n  const standalone = args.model === `openai/${CODEX_IMAGE_GENERATION_MODEL}`;\n  if (!standalone && args.imageGeneration !== \"auto\") return;\n  if (standalone && args.imageGeneration !== true) {\n    throw new BadRequestException(\n      \"qgrid: the image model requires imageGeneration: true; use qgrid.image() with generateImage.\" as LocalizedString,\n    );\n  }\n  if (args.tools?.length || args.jsonSchema !== undefined) {\n    throw new BadRequestException(\n      \"qgrid: automatic and standalone image generation do not support caller tools or structured output.\" as LocalizedString,\n    );\n  }\n  if (\n    args.imageGenerationOptions?.outputFormat &&\n    args.imageGenerationOptions.outputFormat !== \"png\"\n  ) {\n    throw new BadRequestException(\n      \"qgrid: automatic and standalone image generation only support PNG output.\" as LocalizedString,\n    );\n  }\n}\n\n// anthropic 은 --json-schema 를 쓰지 않으므로(SON-532) strict 변환·argv 제한 없이 원형의\n// 구문·복잡도만 검증된다 — provider 분기는 buildAndValidateStrictOutputSchema 가 소유한다.\nfunction rejectInvalidCallerSchemas(args: QueryInput): void {\n  if (args.jsonSchema === undefined && !args.tools?.length) return;\n\n  try {\n    buildAndValidateStrictOutputSchema(args);\n  } catch (error) {\n    if (\n      error instanceof CallerSchemaValidationError ||\n      error instanceof ToolSchemaCompositionError\n    ) {\n      throw new BadRequestException(error.message as LocalizedString);\n    }\n    // 잘못된 keyword 형태(anyOf 를 객체로 보내는 등)는 파이프라인에서 untyped 오류로 나오므로,\n    // 타입 좁히기 대신 Error 전체를 caller-fault 400 으로 매핑한다(계약 테스트로 고정됨).\n    if (error instanceof Error) {\n      throw new BadRequestException(\n        `qgrid: caller schema cannot be normalized: ${error.message}` as LocalizedString,\n      );\n    }\n    throw error;\n  }\n}\n\nasync function resolveTokenName(args: QueryInput): Promise<InternalQueryInput> {\n  if (!args.tokenName) return args;\n\n  const tokenProvider = args.tokenName.split(\"/\", 1)[0];\n  const modelProvider = args.model?.split(\"/\", 1)[0];\n  if (tokenProvider !== \"anthropic\" && tokenProvider !== \"openai\") {\n    throw new BadRequestException(`Invalid token name: ${args.tokenName}` as LocalizedString);\n  }\n  if (modelProvider !== tokenProvider) {\n    throw new BadRequestException(\n      \"Token provider does not match model provider\" as LocalizedString,\n    );\n  }\n\n  const token = await TokenModel.findActiveByProviderAndName(\"A\", tokenProvider, args.tokenName);\n  if (!token) {\n    throw new BadRequestException(`Active token not found: ${args.tokenName}` as LocalizedString);\n  }\n  return { ...args, preferredTokenId: token.id, requirePreferredToken: true };\n}\n\nfunction createHttpDisconnectHandle(): {\n  signal: AbortSignal;\n  dispose: () => void;\n} {\n  const abortController = new AbortController();\n  let requestRaw: FastifyRequest[\"raw\"] | undefined;\n  let responseRaw: FastifyReply[\"raw\"] | undefined;\n\n  try {\n    const ctx = Sonamu.getContext();\n    requestRaw = ctx.request?.raw;\n    if (ctx.transport === \"http\") responseRaw = ctx.reply.raw;\n  } catch {\n    // Direct frame calls (for example unit tests) do not have an HTTP context.\n  }\n\n  const abort = () => abortController.abort();\n  const abortOnIncompleteResponseClose = () => {\n    if (!responseRaw?.writableEnded) abort();\n  };\n\n  requestRaw?.once(\"aborted\", abort);\n  responseRaw?.once(\"close\", abortOnIncompleteResponseClose);\n\n  if (requestRaw?.aborted || (responseRaw?.destroyed && !responseRaw.writableEnded)) {\n    abort();\n  }\n\n  return {\n    signal: abortController.signal,\n    dispose: () => {\n      requestRaw?.removeListener(\"aborted\", abort);\n      responseRaw?.removeListener(\"close\", abortOnIncompleteResponseClose);\n    },\n  };\n}\n\nconst logger = getLogger([\"qgrid\"]);\nconst oauthLogger = getLogger([\"qgrid\", \"oauth\"]);\n\n// per-token refresh dedup — 회전 겹침으로 인한 사망 오판을 막는다.\nconst inflightAnthropicRefresh = new Map<number, Promise<string>>();\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    rejectInvalidImageQuery(args);\n    rejectInvalidCallerSchemas(args);\n    const resolvedArgs = await resolveTokenName(args);\n    const disconnect = createHttpDisconnectHandle();\n    try {\n      if (resolvedArgs.logger === false) {\n        return await QgridDispatcher.query(resolvedArgs, disconnect.signal);\n      }\n\n      const { requestLogId, stepIndex } = await beforeQuery(resolvedArgs);\n      let result: QueryOutput;\n      try {\n        result = await QgridDispatcher.query(resolvedArgs, disconnect.signal);\n      } catch (e) {\n        const completedDriver = completedDriverFromImageFailure(e, resolvedArgs.serviceTier);\n        const completedStep = completedDriver\n          ? ([{ stepIndex, result: completedDriver }] as const)\n          : ([] as const);\n        if (disconnect.signal.aborted) {\n          await finishRunAborted(requestLogId, resolvedArgs, ...completedStep);\n        } else {\n          await finishRunWithError(\n            requestLogId,\n            (e as Error).message,\n            resolvedArgs,\n            ...completedStep,\n          );\n        }\n        throw e;\n      }\n\n      try {\n        const lifecycle = await afterQuery(requestLogId, stepIndex, resolvedArgs, result);\n        if (disconnect.signal.aborted) {\n          await finishRunAborted(requestLogId, resolvedArgs);\n        }\n        // tool-call requestLogId와 provider threadCoord는 서로 독립적으로 유지한다.\n        const threadCoord = result.runContext?.threadCoord;\n        const runContext =\n          lifecycle.runContext || threadCoord\n            ? { ...lifecycle.runContext, ...(threadCoord ? { threadCoord } : {}) }\n            : undefined;\n        return { ...result, requestLogId, runContext };\n      } catch (e) {\n        logger.error(`query afterQuery failed: ${(e as Error).message}`);\n        if (disconnect.signal.aborted) {\n          await finishRunAborted(requestLogId, resolvedArgs);\n        } else {\n          await finishRunWithError(requestLogId, (e as Error).message, resolvedArgs);\n        }\n        // provider 응답은 성공했으므로 로깅 장애가 생성 결과를 덮어쓰지 않는다.\n        return { ...result, requestLogId };\n      }\n    } finally {\n      disconnect.dispose();\n    }\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async prepareStream(args: QueryInput): Promise<{ streamId: string }> {\n    rejectImageGenerationStream(args);\n    rejectInvalidCallerSchemas(args);\n    const resolvedArgs = await resolveTokenName(args);\n    const streamId = crypto.randomUUID();\n    pendingStreams.set(streamId, resolvedArgs);\n    const expiry = setTimeout(() => pendingStreams.delete(streamId), 30_000);\n    expiry.unref?.();\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 ctx = Sonamu.getContext();\n    const sse = ctx.createSSE(StreamEvents);\n    let streamResult: QueryOutput | undefined;\n    let streamError: Error | undefined;\n    let clientClosed = false;\n    const abortController = new AbortController();\n\n    sse.onClose(() => {\n      clientClosed = true;\n      abortController.abort();\n    });\n\n    let runInfo: { requestLogId: number; stepIndex: number } | undefined;\n    if (args.logger !== false) {\n      // provider 실행 전 running row 생성에 실패하면 logged 요청으로 진행하지 않는다.\n      runInfo = await beforeQuery(args);\n    }\n\n    // beforeQuery DB 작업 중 close를 놓치지 않고 provider 실행 전에 마감한다.\n    if (clientClosed || sse.closed) {\n      if (runInfo) await finishRunAborted(runInfo.requestLogId, args);\n      await sse.end();\n      return;\n    }\n\n    try {\n      await QgridDispatcher.queryStream(\n        args,\n        {\n          onDelta: (text) => {\n            if (!clientClosed && !sse.closed) sse.publish(\"delta\", { text });\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    // provider 결과가 없는 close는 즉시 aborted로 마감한다.\n    if (clientClosed && !streamResult) {\n      if (runInfo) await finishRunAborted(runInfo.requestLogId, args);\n      await sse.end();\n      return;\n    }\n\n    // dispatcher 완료 후 lifecycle 처리 (await 안전)\n    if (streamResult) {\n      // dispatcher 가 실은 thread 재사용 좌표는 logger 설정과 무관하게 회송한다.\n      const threadCoord = streamResult.runContext?.threadCoord;\n      let runContext: QgridRunContext | undefined =\n        threadCoord !== undefined ? { threadCoord } : undefined;\n      if (runInfo) {\n        try {\n          // close 후 도착한 결과도 step/usage는 남기되, 아래에서 최종 status를 aborted로 덮어쓴다.\n          const lifecycle = await afterQuery(\n            runInfo.requestLogId,\n            runInfo.stepIndex,\n            args,\n            streamResult,\n          );\n          runContext =\n            lifecycle.runContext || threadCoord\n              ? { ...lifecycle.runContext, ...(threadCoord ? { threadCoord } : {}) }\n              : undefined;\n\n          // afterQuery가 진행되는 사이 client가 닫힌 경우 완료 상태를 aborted로 되돌린다.\n          if (clientClosed) {\n            await finishRunAborted(runInfo.requestLogId, args);\n            await sse.end();\n            return;\n          }\n        } catch (e) {\n          logger.error(`stream afterQuery failed: ${(e as Error).message}`);\n          await finishRunWithError(runInfo.requestLogId, (e as Error).message, args);\n\n          if (clientClosed) {\n            await finishRunAborted(runInfo.requestLogId, args);\n            await sse.end();\n            return;\n          }\n        }\n      }\n      if (!clientClosed && !sse.closed) {\n        sse.publish(\"done\", {\n          ...streamResult,\n          ...(runInfo ? { requestLogId: runInfo.requestLogId } : {}),\n          runContext,\n        });\n      }\n    } else if (streamError) {\n      if (runInfo) await finishRunWithError(runInfo.requestLogId, streamError.message, args);\n      if (!clientClosed && !sse.closed) sse.publish(\"error\", { message: streamError.message });\n    } else if ((clientClosed || 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      requested_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      is_structured: input.isStructured,\n      json_schema: input.jsonSchema,\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      model_name: input.modelName,\n      requested_model_name: input.requestedModelName,\n      fallback_count: input.fallbackCount,\n      input_tokens: input.inputTokens,\n      output_tokens: input.outputTokens,\n      cache_read_tokens: input.cacheReadTokens,\n      cache_creation_tokens: input.cacheCreationTokens,\n      cache_creation_5m_tokens: input.cacheCreation5mTokens,\n      cache_creation_1h_tokens: input.cacheCreation1hTokens,\n      cost_usd: input.costUsd === undefined ? undefined : Math.round(input.costUsd * MICRO_USD),\n      cost_source: input.costSource,\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      model_name: input.modelName,\n      requested_model_name: input.requestedModelName,\n      fallback_count: input.fallbackCount,\n      input_tokens: input.totalInputTokens,\n      output_tokens: input.totalOutputTokens,\n      cache_read_tokens: input.totalCacheReadTokens,\n      cache_creation_tokens: input.totalCacheCreationTokens,\n      cache_creation_5m_tokens: input.totalCacheCreation5mTokens,\n      cache_creation_1h_tokens: input.totalCacheCreation1hTokens,\n      cost_usd: input.costUsd === undefined ? undefined : Math.round(input.costUsd * MICRO_USD),\n      cost_source: input.costSource,\n      duration_ms: input.totalDurationMs,\n      history: input.history ? JSON.parse(input.history) : undefined,\n      error_message: input.errorMessage,\n      response_json_ok: input.responseJsonOk,\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  // 화면의 목록 필터를 그대로 받아 같은 조건의 합계를 돌려준다 — 목록과 비용이\n  // 서로 다른 모수를 보면 사용자에게는 숫자가 어긋난 것으로 읽힌다.\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"] })\n  async totalCost(\n    params?: RequestLogListParams,\n  ): Promise<{ usd: number; unknownImageCostCount: number }> {\n    return RequestLogModel.totalCost(params);\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: \"GET\", clients: [\"axios\", \"tanstack-query\"] })\n  async modelNames(): Promise<{ names: string[] }> {\n    return { names: await RequestLogModel.distinctModelNames() };\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    keepaliveEnabled?: boolean,\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 (keepaliveEnabled !== undefined) patch.keepalive_enabled = keepaliveEnabled;\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 result = await TokenModel.toggleActive(id);\n    if (!result) return { active: false };\n    if (result.reauthRequired) {\n      throw new BadRequestException(\"Re-login required\" as LocalizedString);\n    }\n    return { active: result.active };\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, mode } = resolveOAuthRedirect();\n    const authUrl = buildAuthUrl(codeChallenge, state, redirectUri);\n\n    await setOAuthState(state, { codeVerifier, name, redirectUri, provider: \"anthropic\" });\n\n    return { authUrl, mode };\n  }\n\n  // 원격 접속의 수동 완료: Anthropic `code#state` 또는 OpenAI callback URL을 받아 교환한다.\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async oauthComplete(pastedCode: string): Promise<{ added: boolean; name: string }> {\n    const result = parsePastedOAuthResult(pastedCode);\n    if (!result) {\n      throw new BadRequestException(\n        \"expected the callback URL or code shown after login, in code#state form\" as LocalizedString,\n      );\n    }\n    const { code, state } = result;\n\n    const pending = await getOAuthState(state);\n    if (!pending) {\n      throw new BadRequestException(\n        \"login session not found or expired — start the login again\" as LocalizedString,\n      );\n    }\n    await deleteOAuthState(state);\n\n    if (pending.provider === \"openai\") {\n      await this.completeOpenAILogin(code, pending);\n    } else {\n      await this.completeAnthropicLogin(code, state, pending);\n    }\n\n    return { added: true, name: pending.name };\n  }\n\n  // 교환 + 계정 중복 제거 + 저장 — redirect 콜백과 코드 붙여넣기 플로우가 공유한다.\n  async completeAnthropicLogin(code: string, state: string, pending: PendingOAuth): Promise<void> {\n    const tokens = await exchangeCodeForTokens(\n      code,\n      pending.codeVerifier,\n      state,\n      pending.redirectUri,\n    );\n\n    await TokenModel.replaceByAccount(\"anthropic\", tokens.accountUuid, {\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    notifyTokenAdded(pending.name, \"anthropic\");\n  }\n\n  async completeOpenAILogin(code: string, pending: PendingOAuth): Promise<void> {\n    const creds = await exchangeOpenAICode(code, pending.codeVerifier, pending.redirectUri);\n    await TokenModel.replaceByAccount(\"openai\", creds.accountId, {\n      provider: \"openai\",\n      credentials: creds,\n      name: pending.name,\n    });\n    logger.info(`OpenAI token saved for ${pending.name}`);\n    notifyTokenAdded(pending.name, \"openai\");\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      if (pending.provider === \"openai\") {\n        await this.completeOpenAILogin(code, pending);\n      } else {\n        await this.completeAnthropicLogin(code, state, pending);\n      }\n      return reply.redirect(`/?oauth=success&name=${encodeURIComponent(pending.name)}`);\n    } catch {\n      logger.warn(\"oauth callback failed\", {\n        provider: pending.provider,\n        reason: \"exchange_failed\",\n      });\n      return reply.redirect(\"/?oauth=error&reason=exchange_failed\");\n    }\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async oauthStartOpenAI(name: string): Promise<OAuthStartResult> {\n    const { codeVerifier, codeChallenge, state } = generateOpenAIPKCE();\n    const mode = isRemoteOAuthRequest() ? \"code\" : \"redirect\";\n    let redirectUri: string;\n    if (mode === \"code\") {\n      // OpenAI accepts only the Codex CLI's registered loopback URI. On a remote dashboard the\n      // browser cannot reach the server's loopback, so the user pastes the resulting callback URL.\n      redirectUri = openAICallbackRedirectUri(OPENAI_CALLBACK_PORTS[0]);\n    } else {\n      try {\n        redirectUri = await startOpenAICallbackRelay(trustedLoopbackBase(), OAUTH_STATE_TTL_MS);\n      } catch {\n        throw new BadRequestException(\n          `OpenAI login needs local port ${OPENAI_CALLBACK_PORTS.join(\" or \")} — close any running \\`codex login\\` and retry` as LocalizedString,\n        );\n      }\n    }\n    const authUrl = buildOpenAIAuthUrl(codeChallenge, state, redirectUri);\n    await setOAuthState(state, { codeVerifier, name, redirectUri, provider: \"openai\" });\n    return { authUrl, mode };\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    if (entry.reauth_required) return { error: \"re-login required\" };\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: \"Token refresh failed; usage is unavailable\" };\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: \"Token refresh failed; usage is unavailable\" };\n      }\n    }\n    if (raw.error) return { error: raw.error };\n    return convertAnthropicUsage(raw);\n  }\n\n  // 동시 refresh 가 회전을 겹치면 뒤늦은 호출이 이미 폐기된 refresh token 을 쓰게 되어\n  // 멀쩡한 토큰이 사망으로 오판된다. openai-refresh.ts 와 같은 per-token dedup 을 둔다.\n  async refreshToken(token: TokenSubsetA): Promise<string> {\n    const inflight = inflightAnthropicRefresh.get(token.id);\n    if (inflight) return inflight;\n\n    const promise = this.doRefreshToken(token);\n    inflightAnthropicRefresh.set(token.id, promise);\n    try {\n      return await promise;\n    } finally {\n      inflightAnthropicRefresh.delete(token.id);\n    }\n  }\n\n  async doRefreshToken(token: TokenSubsetA): Promise<string> {\n    const creds = token.credentials;\n    const rt = getRefreshToken(creds);\n    if (!rt) throw new Error(\"No refresh token\");\n\n    let refreshed;\n    try {\n      refreshed = await refreshAccessToken(rt);\n    } catch (e) {\n      if (e instanceof RefreshFailedError && e.isAuthDead()) {\n        await deactivateAuthDeadToken(token, `anthropic:${e.status}`);\n      }\n      throw e;\n    }\n\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        reauth_required: false,\n      },\n    ]);\n    return refreshed.accessToken;\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"] })\n  async health(): Promise<HealthResponse> {\n    const providers = { ...QgridDispatcher.startupState };\n    return {\n      status: \"ok\",\n      activeTokens: QgridDispatcher.tokens.size,\n      subscriber: QgridDispatcher.subscriber?.status() ?? null,\n      // provider 별 라우팅이라 하나만 준비돼도 그 provider 요청은 처리된다.\n      ready: Object.values(providers).includes(\"ready\"),\n      providers,\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":["StrictGrokCredentials","StoredGrokCredentials"],"sources":["../../../src/application/qgrid/qgrid.frame.ts"],"sourcesContent":["import crypto from \"node:crypto\";\n\nimport { getLogger } from \"@logtape/logtape\";\nimport { type FastifyReply, type FastifyRequest } from \"fastify\";\nimport {\n  api,\n  BadRequestException,\n  BaseFrameClass,\n  InternalServerErrorException,\n  NotFoundException,\n  ServiceUnavailableException,\n  SoException,\n  Sonamu,\n  stream,\n} from \"sonamu\";\nimport { getCacheManagerRef } from \"sonamu/cache\";\nimport { z } from \"zod\";\n\nimport { type LocalizedString, SD } from \"../../i18n/sd.generated\";\nimport {\n  getAccessToken,\n  getExpiresAt,\n  getRefreshToken,\n} from \"../../utils/providers/common/credentials\";\nimport {\n  type GrokMediaCost,\n  grokImageCost,\n  grokReportedCost,\n} from \"../../utils/providers/common/model-cost\";\nimport {\n  type MediaDispatcher,\n  type MediaTokenSelection,\n  type VoiceDispatcher,\n} from \"../../utils/providers/common/provider-dispatcher\";\nimport { isProviderId } from \"../../utils/providers/common/provider-types\";\nimport { CallerSchemaValidationError } from \"../../utils/providers/common/schema-validation\";\nimport {\n  GROK_IMAGE_DEFAULT_MODEL,\n  GROK_STT_DEFAULT_MODEL,\n  GROK_VIDEO_DEFAULT_MODEL,\n  GrokCapabilityUnavailableError,\n  GrokCapacityError,\n  GrokInvalidRequestError,\n  GrokNoWorkersError,\n  GrokOnDemandExcludedError,\n  GrokRateLimitedError,\n  GrokZdrVideoUnavailableError,\n  completeGrokOAuth,\n  GrokCredentials as StrictGrokCredentials,\n  GrokOAuthError,\n  type GrokRefreshCoordinator,\n  type GrokTokenStateSnapshot,\n  pollGrokDeviceCode,\n  startGrokDeviceCode,\n  startGrokOAuth,\n} from \"../../utils/providers/grok\";\nimport {\n  decodeGrokImages,\n  GrokContentPolicyError,\n  summarizeGrokVideoStatus,\n} from \"../../utils/providers/grok/grok-media-client\";\nimport {\n  GROK_TTS_DEFAULT_FORMAT,\n  GROK_TTS_DEFAULT_LANGUAGE,\n  GROK_TTS_DEFAULT_VOICE,\n} from \"../../utils/providers/grok/grok-voice-client\";\nimport {\n  OPENAI_CALLBACK_PORTS,\n  openAICallbackRedirectUri,\n  startOpenAICallbackRelay,\n} from \"../../utils/providers/openai/openai-callback-relay\";\nimport {\n  buildOpenAIAuthUrl,\n  exchangeOpenAICode,\n  generateOpenAIPKCE,\n} from \"../../utils/providers/openai/openai-oauth\";\nimport {\n  type FinishRunParams,\n  MICRO_USD,\n  RequestLogModel,\n  type RequestLogStepFields,\n} from \"../request-log/request-log.model\";\nimport { type RequestLogListParams } from \"../request-log/request-log.types\";\nimport { type TokenSubsetA } from \"../sonamu.generated\";\n\n/** Fields token refresh reads; dispatchers pass their pooled view of a token. */\ntype RefreshableToken = Pick<TokenSubsetA, \"id\" | \"name\" | \"provider\" | \"credentials\">;\n\nimport { TokenModel, type TokenUpdateFields } from \"../token/token.model\";\nimport { GrokCredentials as StoredGrokCredentials, TokenCredentials } from \"../token/token.types\";\nimport {\n  CONSOLE_CALLBACK_URL,\n  type AnthropicUsageRaw,\n  buildAuthUrl,\n  exchangeCodeForTokens,\n  fetchUsage,\n  generatePKCE,\n  refreshAccessToken,\n  RefreshFailedError,\n} from \"./oauth\";\nimport { CODEX_IMAGE_GENERATION_MODEL } from \"./qgrid-image-generation\";\nimport {\n  afterQuery,\n  beforeQuery,\n  finishRunAborted,\n  finishRunWithError,\n} from \"./qgrid-run-lifecycle\";\nimport {\n  buildAndValidateStrictOutputSchema,\n  completedDriverFromImageFailure,\n  type InternalQueryInput,\n  QgridDispatcher,\n} from \"./qgrid.dispatcher\";\nimport {\n  type QueryInput,\n  type AppendStepInput,\n  type CreateRunInput,\n  type FinishRunInput,\n  GenerateImagesInput,\n  type GenerateImagesOutput,\n  SpeakInput,\n  type SpeakOutput,\n  TranscribeInput,\n  type TranscribeOutput,\n  VideoStartInput,\n  type VideoStartOutput,\n  VideoStatusInput,\n  type VideoStatusOutput,\n  type GrokDeviceCodeStart,\n  type GrokDevicePollResult,\n  type HealthResponse,\n  type OAuthStartResult,\n  type QueryOutput,\n  type QgridRunContext,\n  type QgridThreadCoord,\n  REQUEST_BODY_LIMIT_BYTES,\n  StreamEvents,\n  type TokenStats,\n  type UsageResponse,\n} from \"./qgrid.types\";\nimport { deactivateAuthDeadToken, notifyTokenAdded } from \"./token-death\";\nimport { ToolSchemaCompositionError } from \"./tool-emulation-schema\";\n\nconst pendingStreams = new Map<string, QueryInput>();\n\nconst PendingOAuth = z.object({\n  codeVerifier: z.string(),\n  name: z.string(),\n  redirectUri: z.string(),\n  provider: z.enum([\"anthropic\", \"openai\", \"grok\"]),\n});\n\ntype PendingOAuth = z.infer<typeof PendingOAuth>;\n\nconst OAUTH_STATE_PREFIX = \"oauth:state:\";\nconst OAUTH_STATE_TTL = \"5m\";\nconst OAUTH_STATE_TTL_MS = 5 * 60_000;\n\n// A bare pasted Grok code carries no state, so it binds to the newest pending Grok login.\nconst GROK_LATEST_STATE_KEY = \"oauth:grok:latest\";\nconst GROK_DEVICE_PREFIX = \"oauth:grok:device:\";\n\nconst PendingGrokDevice = z.object({\n  name: z.string(),\n  interval: z.number(),\n  expiresAtMs: z.number(),\n});\n\ntype PendingGrokDevice = z.infer<typeof PendingGrokDevice>;\n\nfunction unixSecondsToIso(seconds: number | null | undefined): string | null {\n  return seconds === null || seconds === undefined ? null : new Date(seconds * 1000).toISOString();\n}\n\nasync function setOAuthState(state: string, data: PendingOAuth): Promise<void> {\n  const cache = getCacheManagerRef();\n\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\n  if (!cache) throw new Error(\"CacheManager not initialized\");\n  const raw = await cache.get<string>({ key: `${OAUTH_STATE_PREFIX}${state}` });\n\n  if (!raw) return undefined;\n\n  return PendingOAuth.safeParse(JSON.parse(raw)).data;\n}\n\nasync function deleteOAuthState(state: string): Promise<void> {\n  const cache = getCacheManagerRef();\n\n  if (!cache) return;\n  await cache.delete({ key: `${OAUTH_STATE_PREFIX}${state}` });\n}\n\nasync function setGrokLatestState(state: string): Promise<void> {\n  const cache = getCacheManagerRef();\n\n  if (!cache) throw new Error(\"CacheManager not initialized\");\n  await cache.set({ key: GROK_LATEST_STATE_KEY, value: state, ttl: OAUTH_STATE_TTL });\n}\n\nasync function getGrokLatestState(): Promise<string | undefined> {\n  const cache = getCacheManagerRef();\n\n  if (!cache) throw new Error(\"CacheManager not initialized\");\n\n  return (await cache.get<string>({ key: GROK_LATEST_STATE_KEY })) ?? undefined;\n}\n\nasync function setGrokDeviceState(deviceCode: string, data: PendingGrokDevice): Promise<void> {\n  const cache = getCacheManagerRef();\n\n  if (!cache) throw new Error(\"CacheManager not initialized\");\n  const ttlSec = Math.max(1, Math.ceil((data.expiresAtMs - Date.now()) / 1000));\n  await cache.set({\n    key: `${GROK_DEVICE_PREFIX}${deviceCode}`,\n    value: JSON.stringify(data),\n    ttl: `${ttlSec}s`,\n  });\n}\n\nasync function getGrokDeviceState(deviceCode: string): Promise<PendingGrokDevice | undefined> {\n  const cache = getCacheManagerRef();\n\n  if (!cache) throw new Error(\"CacheManager not initialized\");\n  const raw = await cache.get<string>({ key: `${GROK_DEVICE_PREFIX}${deviceCode}` });\n\n  if (!raw) return undefined;\n  const data = PendingGrokDevice.safeParse(JSON.parse(raw)).data;\n\n  return data && data.expiresAtMs > Date.now() ? data : undefined;\n}\n\nasync function deleteGrokDeviceState(deviceCode: string): Promise<void> {\n  const cache = getCacheManagerRef();\n\n  if (!cache) return;\n  await cache.delete({ key: `${GROK_DEVICE_PREFIX}${deviceCode}` });\n}\n\nfunction grokOAuthBadRequest(cause: unknown): never {\n  if (cause instanceof GrokOAuthError) {\n    throw new BadRequestException(SD(\"qgrid.grokLoginFailed\")(cause.message));\n  }\n\n  throw cause;\n}\n\nfunction grokTokenSnapshot(tokenId: number): GrokTokenStateSnapshot | undefined {\n  // Token-state reporting is optional on the routing port; the concrete GrokDispatcher has it.\n  return QgridDispatcher.grokDispatcher?.tokenStates?.().find((state) => state.id === tokenId);\n}\n\n/** Stores refreshed Grok credentials; the token subscriber pushes the row to the dispatcher. */\nexport async function persistGrokCredentials(\n  tokenId: number,\n  next: StrictGrokCredentials,\n): Promise<void> {\n  const credentials = StrictGrokCredentials.parse(next);\n  const row = await TokenModel.findById(\"A\", tokenId);\n  await TokenModel.save([\n    {\n      id: row.id,\n      provider: row.provider,\n      credentials,\n      name: row.name,\n      reauth_required: false,\n    },\n  ]);\n}\n\nconst trustedLoopbackBase = () => `http://localhost:${process.env.PORT ?? \"44900\"}`;\n\nfunction isRemoteOAuthRequest(): boolean {\n  try {\n    const { headers } = Sonamu.getContext();\n    const origin = headers.origin;\n    const forwarded = headers[\"x-forwarded-host\"];\n    const rawHost = Array.isArray(forwarded) ? forwarded[0] : (forwarded ?? headers.host);\n\n    const host = origin\n      ? new URL(origin).hostname\n      : new URL(`http://${rawHost ?? \"localhost\"}`).hostname;\n\n    return !new Set([\"localhost\", \"127.0.0.1\", \"::1\", \"[::1]\"]).has(host);\n  } catch {}\n\n  return false;\n}\n\n// Anthropic's remote/manual flow uses its fixed console callback. Headers may select between two\n// allowlisted URIs, but never contribute authority or path bytes to either URI.\ninterface OAuthRedirect {\n  redirectUri: string;\n  mode: \"redirect\" | \"code\";\n}\n\nfunction resolveOAuthRedirect(): OAuthRedirect {\n  if (isRemoteOAuthRequest()) {\n    return { redirectUri: CONSOLE_CALLBACK_URL, mode: \"code\" };\n  }\n\n  return { redirectUri: `${trustedLoopbackBase()}/callback`, mode: \"redirect\" };\n}\n\nfunction parsePastedOAuthResult(input: string): { code: string; state: string } | null {\n  const trimmed = input.trim();\n\n  try {\n    const callback = new URL(trimmed);\n    const code = callback.searchParams.get(\"code\")?.trim() ?? \"\";\n    const state = callback.searchParams.get(\"state\")?.trim() ?? \"\";\n\n    if (code && state) return { code, state };\n  } catch {}\n\n  const separatorAt = trimmed.indexOf(\"#\");\n  const code = separatorAt > 0 ? trimmed.slice(0, separatorAt).trim() : \"\";\n  const state = separatorAt > 0 ? trimmed.slice(separatorAt + 1).trim() : \"\";\n\n  return code && state ? { code, state } : null;\n}\n\nfunction rejectImageGenerationStream(args: QueryInput): void {\n  if (!args.imageGeneration && args.model !== `openai/${CODEX_IMAGE_GENERATION_MODEL}`) return;\n  throw new BadRequestException(\n    SD(\"error.detail\")(\n      \"qgrid: imageGeneration is not supported with streaming; use query or generateImage with qgrid.image() instead.\",\n    ),\n  );\n}\n\nfunction rejectInvalidImageQuery(args: QueryInput): void {\n  const standalone = args.model === `openai/${CODEX_IMAGE_GENERATION_MODEL}`;\n\n  if (!standalone && args.imageGeneration !== \"auto\") return;\n\n  if (standalone && args.imageGeneration !== true) {\n    throw new BadRequestException(\n      SD(\"error.detail\")(\n        \"qgrid: the image model requires imageGeneration: true; use qgrid.image() with generateImage.\",\n      ),\n    );\n  }\n\n  if (args.tools?.length || args.jsonSchema !== undefined) {\n    throw new BadRequestException(\n      SD(\"error.detail\")(\n        \"qgrid: automatic and standalone image generation do not support caller tools or structured output.\",\n      ),\n    );\n  }\n\n  if (\n    args.imageGenerationOptions?.outputFormat &&\n    args.imageGenerationOptions.outputFormat !== \"png\"\n  ) {\n    throw new BadRequestException(\n      SD(\"error.detail\")(\n        \"qgrid: automatic and standalone image generation only support PNG output.\",\n      ),\n    );\n  }\n}\n\n// anthropic 은 --json-schema 를 쓰지 않으므로(SON-532) strict 변환·argv 제한 없이 원형의\n// 구문·복잡도만 검증된다 — provider 분기는 buildAndValidateStrictOutputSchema 가 소유한다.\nfunction rejectInvalidCallerSchemas(args: QueryInput): void {\n  if (args.jsonSchema === undefined && !args.tools?.length) return;\n\n  try {\n    buildAndValidateStrictOutputSchema(args);\n  } catch (error) {\n    if (\n      error instanceof CallerSchemaValidationError ||\n      error instanceof ToolSchemaCompositionError\n    ) {\n      throw new BadRequestException(SD(\"error.detail\")(error.message));\n    }\n\n    // 잘못된 keyword 형태(anyOf 를 객체로 보내는 등)는 파이프라인에서 untyped 오류로 나오므로,\n    // 타입 좁히기 대신 Error 전체를 caller-fault 400 으로 매핑한다(계약 테스트로 고정됨).\n    if (error instanceof Error) {\n      throw new BadRequestException(\n        SD(\"error.detail\")(`qgrid: caller schema cannot be normalized: ${error.message}`),\n      );\n    }\n\n    throw error;\n  }\n}\n\nasync function resolveTokenName(args: QueryInput): Promise<InternalQueryInput> {\n  if (!args.tokenName) return args;\n\n  const tokenProvider = args.tokenName.split(\"/\", 1)[0];\n  const modelProvider = args.model?.split(\"/\", 1)[0];\n\n  if (!isProviderId(tokenProvider)) {\n    throw new BadRequestException(SD(\"error.detail\")(`Invalid token name: ${args.tokenName}`));\n  }\n\n  if (modelProvider !== tokenProvider) {\n    throw new BadRequestException(\n      SD(\"error.detail\")(\"Token provider does not match model provider\"),\n    );\n  }\n\n  const token = await TokenModel.findActiveByProviderAndName(\"A\", tokenProvider, args.tokenName);\n\n  if (!token) {\n    throw new BadRequestException(SD(\"error.detail\")(`Active token not found: ${args.tokenName}`));\n  }\n\n  return { ...args, preferredTokenId: token.id, requirePreferredToken: true };\n}\n\ninterface HttpDisconnectHandle {\n  signal: AbortSignal;\n  dispose: () => void;\n}\n\nfunction createHttpDisconnectHandle(): HttpDisconnectHandle {\n  const abortController = new AbortController();\n  let requestRaw: FastifyRequest[\"raw\"] | undefined;\n  let responseRaw: FastifyReply[\"raw\"] | undefined;\n\n  try {\n    const ctx = Sonamu.getContext();\n    requestRaw = ctx.request?.raw;\n\n    if (ctx.transport === \"http\") responseRaw = ctx.reply.raw;\n  } catch {\n    // Direct frame calls (for example unit tests) do not have an HTTP context.\n  }\n\n  const abort = () => abortController.abort();\n\n  const abortOnIncompleteResponseClose = () => {\n    if (!responseRaw?.writableEnded) abort();\n  };\n\n  requestRaw?.once(\"aborted\", abort);\n  responseRaw?.once(\"close\", abortOnIncompleteResponseClose);\n\n  if (requestRaw?.aborted || (responseRaw?.destroyed && !responseRaw.writableEnded)) {\n    abort();\n  }\n\n  return {\n    signal: abortController.signal,\n    dispose: () => {\n      requestRaw?.removeListener(\"aborted\", abort);\n      responseRaw?.removeListener(\"close\", abortOnIncompleteResponseClose);\n    },\n  };\n}\n\nconst logger = getLogger([\"qgrid\"]);\nconst oauthLogger = getLogger([\"qgrid\", \"oauth\"]);\n\n// per-token refresh dedup — 회전 겹침으로 인한 사망 오판을 막는다.\nconst inflightAnthropicRefresh = new Map<number, Promise<string>>();\n\n// --- Grok media and voice ---\n\nconst mediaLogger = getLogger([\"qgrid\", \"media\"]);\n\ntype MediaKind = \"image\" | \"video\" | \"stt\" | \"tts\";\n\nconst MEDIA_TOOL_NAMES: Record<MediaKind, string> = {\n  image: \"image_generation\",\n  video: \"video_generation\",\n  stt: \"transcription\",\n  tts: \"speech\",\n};\n\nfunction grokNotReady(): Error {\n  return QgridDispatcher.startupState.grok === \"failed\"\n    ? new InternalServerErrorException(SD(\"qgrid.dispatcherFailed\")(\"Grok\"))\n    : new ServiceUnavailableException(SD(\"qgrid.dispatcherStarting\")(\"Grok\"));\n}\n\nfunction grokMedia(): MediaDispatcher {\n  const dispatcher = QgridDispatcher.grokDispatcher;\n  const generateImages = dispatcher?.generateImages;\n  const editImages = dispatcher?.editImages;\n  const startVideo = dispatcher?.startVideo;\n  const getVideo = dispatcher?.getVideo;\n\n  if (!dispatcher || !generateImages || !editImages || !startVideo || !getVideo) {\n    throw grokNotReady();\n  }\n\n  return {\n    generateImages: generateImages.bind(dispatcher),\n    editImages: editImages.bind(dispatcher),\n    startVideo: startVideo.bind(dispatcher),\n    getVideo: getVideo.bind(dispatcher),\n  };\n}\n\nfunction grokVoice(): VoiceDispatcher {\n  const dispatcher = QgridDispatcher.grokDispatcher;\n  const transcribe = dispatcher?.transcribe;\n  const speak = dispatcher?.speak;\n\n  if (!dispatcher || !transcribe || !speak) throw grokNotReady();\n\n  return { transcribe: transcribe.bind(dispatcher), speak: speak.bind(dispatcher) };\n}\n\nclass TooManyRequestsException extends SoException {\n  constructor(message: LocalizedString) {\n    super(429, message);\n  }\n}\n\n/**\n * Every Grok token is cooling down. A 429 rather than a 503: the server error handler pins 503's\n * Retry-After to its startup interval, while this delay comes from the upstream cooldown.\n */\nfunction grokRateLimited(error: GrokRateLimitedError): TooManyRequestsException {\n  let reply: FastifyReply | undefined;\n\n  try {\n    const ctx = Sonamu.getContext();\n\n    if (ctx.transport === \"http\") reply = ctx.reply;\n  } catch {\n    // Direct frame calls (for example unit tests) have no HTTP context and no header to set.\n  }\n\n  // An SSE stream has already sent its headers; the error event then carries the delay alone.\n  if (reply && !reply.raw.headersSent) reply.header(\"Retry-After\", String(error.retryAfterSec));\n\n  return new TooManyRequestsException(SD(\"qgrid.grokRateLimited\")(error.retryAfterSec));\n}\n\n/**\n * Caller-fault Grok errors become 400/429/503 at the chat and media boundaries; upstream and\n * provider failures propagate unchanged (500 by the server error handler). \"No eligible token for\n * this request class\" (no workers, in-flight cap, on-demand D6, ZDR video) is a 503, not a server\n * fault; every token cooling down is a 429 with the soonest retry delay.\n */\nfunction throwGrokCallerError(cause: unknown): never {\n  if (cause instanceof GrokInvalidRequestError) {\n    throw new BadRequestException(SD(\"qgrid.grokInvalidRequest\")(cause.message));\n  }\n\n  if (cause instanceof GrokContentPolicyError) {\n    throw new BadRequestException(SD(\"qgrid.grokContentPolicy\")(cause.message));\n  }\n\n  if (cause instanceof GrokCapabilityUnavailableError) {\n    throw new ServiceUnavailableException(SD(\"qgrid.grokCapabilityUnavailable\")(cause.message));\n  }\n\n  if (cause instanceof GrokOnDemandExcludedError) {\n    throw new ServiceUnavailableException(\n      SD(\"qgrid.grokOnDemandExcluded\")(cause.tokenNames.join(\", \")),\n    );\n  }\n\n  if (cause instanceof GrokZdrVideoUnavailableError) {\n    throw new ServiceUnavailableException(\n      SD(\"qgrid.grokZdrVideoUnavailable\")(cause.tokenNames.join(\", \")),\n    );\n  }\n\n  if (cause instanceof GrokCapacityError) {\n    throw new ServiceUnavailableException(SD(\"qgrid.grokCapacity\"));\n  }\n\n  if (cause instanceof GrokRateLimitedError) throw grokRateLimited(cause);\n\n  if (cause instanceof GrokNoWorkersError) {\n    throw new ServiceUnavailableException(SD(\"qgrid.grokNoWorkers\")(cause.message));\n  }\n\n  throw cause;\n}\n\nclass PayloadTooLargeException extends SoException {\n  constructor(message: LocalizedString) {\n    super(413, message);\n  }\n}\n\nconst MiB = 1024 * 1024;\n\n/**\n * Fastify rejects a body over `bodyLimit` before routing with FST_ERR_CTP_BODY_TOO_LARGE, which is\n * not a Sonamu exception and would otherwise answer 500. The server error handler applies this\n * first so the caller gets a Sonamu 413.\n */\nexport function mapRequestBodyTooLarge(error: Error): Error {\n  if (\"code\" in error && error.code === \"FST_ERR_CTP_BODY_TOO_LARGE\") {\n    return new PayloadTooLargeException(\n      SD(\"qgrid.requestBodyTooLarge\")(REQUEST_BODY_LIMIT_BYTES / MiB),\n    );\n  }\n\n  return error;\n}\n\n// Sonamu's generated validator does not carry zod refinements (size, https, base64), so media\n// endpoints re-validate with the full schema.\nfunction parseMediaInput<S extends z.ZodType>(schema: S, value: z.input<S>): z.infer<S> {\n  const parsed = schema.safeParse(value);\n\n  if (!parsed.success) {\n    const detail = parsed.error.issues\n      .map((issue) => `${issue.path.join(\".\") || \"input\"}: ${issue.message}`)\n      .join(\"; \");\n\n    throw new BadRequestException(SD(\"qgrid.invalidInput\")(detail));\n  }\n\n  return parsed.data;\n}\n\nasync function resolveGrokTokenSelection(\n  tokenName: string | undefined,\n): Promise<MediaTokenSelection> {\n  if (!tokenName) return {};\n\n  if (!tokenName.startsWith(\"grok/\")) {\n    throw new BadRequestException(\n      SD(\"error.detail\")(\"Token provider does not match model provider\"),\n    );\n  }\n\n  const token = await TokenModel.findActiveByProviderAndName(\"A\", \"grok\", tokenName);\n\n  if (!token) {\n    throw new BadRequestException(SD(\"error.detail\")(`Active token not found: ${tokenName}`));\n  }\n\n  return { preferredTokenId: token.id, requirePreferredToken: true };\n}\n\ninterface RoutedModelId {\n  id: string;\n  route: string;\n}\n\nfunction routeModelId(model: string | undefined, fallback: string): RoutedModelId {\n  const id = model ? model.slice(\"grok/\".length) : fallback;\n\n  return { id, route: `grok/${id}` };\n}\n\ntype GeneratedImage = GenerateImagesOutput[\"images\"][number];\n\n/** Adds the provider thread coordinate to the lifecycle run context without dropping either. */\nfunction mergeRunContext(\n  lifecycle: QgridRunContext | undefined,\n  threadCoord: QgridThreadCoord | undefined,\n): QgridRunContext | undefined {\n  if (!lifecycle && !threadCoord) return undefined;\n  const runContext: QgridRunContext = { ...lifecycle };\n\n  if (threadCoord) runContext.threadCoord = threadCoord;\n\n  return runContext;\n}\n\nfunction microUsd(usd: number | undefined): number | undefined {\n  return usd === undefined ? undefined : Math.round(usd * MICRO_USD);\n}\n\n/** Reference-image log metadata: a URL, or a data URL's media type and size (plus bytes). */\ntype ImageRefLog = { url: string } | { mediaType: string; data?: string; byteSize: number };\n\n/** Reference-image log metadata. Data URLs keep their bytes only when `withData` (images). */\nfunction describeImageRefs(refs: string[], withData: boolean): ImageRefLog[] {\n  return refs.map((ref) => {\n    const match = /^data:([^;,]+);base64,(.*)$/.exec(ref);\n\n    if (!match) return { url: ref };\n    const [, mediaType = \"\", data = \"\"] = match;\n    const byteSize = Buffer.byteLength(data, \"base64\");\n\n    return withData ? { mediaType, data, byteSize } : { mediaType, byteSize };\n  });\n}\n\nfunction imageTagForLog(b64: string, mimeType: string, alt: string | undefined): string {\n  const safeAlt = (alt ?? \"generated image\").replace(/[&\"<>]/g, (ch) => `&#${ch.charCodeAt(0)};`);\n\n  return `<img src=\"data:${mimeType};base64,${b64}\" alt=\"${safeAlt}\" />`;\n}\n\ntype MediaLogStart = { kind: MediaKind; model: string; prompt: string; projectName?: string };\n\n// Creating the running row is a precondition of a logged provider call, as for query.\nasync function startMediaRun(\n  loggerEnabled: boolean | undefined,\n  start: MediaLogStart,\n): Promise<number | undefined> {\n  if (loggerEnabled === false) return undefined;\n\n  return RequestLogModel.createRun({\n    user_prompt: start.prompt,\n    requested_model_name: start.model,\n    project_name: start.projectName,\n    is_image_generation: start.kind === \"image\",\n  });\n}\n\n/** JSON-serializable log arguments; `undefined` members are dropped by JSON.stringify. */\ntype MediaLogArg = string | number | boolean | null | undefined | MediaLogArg[] | MediaLogArgs;\n\ntype MediaLogArgs = { [key: string]: MediaLogArg };\n\n/** Image step arguments; cost and reference images are recorded only when known. */\ntype ImageStepArgs = {\n  kind: \"image\";\n  prompt: string;\n  model: string;\n  requestedOptions: MediaLogArgs;\n  imageCount: number;\n  costSource?: string;\n  costInUsdTicks?: number;\n  inputImages?: ImageRefLog[];\n};\n\n/** Video step arguments; reference images are recorded only when supplied. */\ntype VideoStepArgs = {\n  kind: \"video\";\n  prompt: string;\n  model: string;\n  requestedOptions: MediaLogArgs;\n  inputImages?: ImageRefLog[];\n};\n\ntype MediaLogSteps = Array<{ toolCallId: string; args: MediaLogArgs; result?: string }>;\n\ntype MediaLogSuccess = {\n  kind: MediaKind;\n  model: string;\n  tokenName: string;\n  durationMs: number;\n  response: string;\n  steps: MediaLogSteps;\n  cost?: GrokMediaCost;\n};\n\nfunction mediaToolSteps(\n  kind: MediaKind,\n  steps: MediaLogSteps,\n  durationMs: number,\n): RequestLogStepFields[] {\n  return steps.map((step, index) => {\n    const fields: RequestLogStepFields = {\n      step_index: 0,\n      type: \"tool_call\",\n      tool_call_index: index,\n      tool_call_id: step.toolCallId,\n      tool_name: MEDIA_TOOL_NAMES[kind],\n      tool_args: JSON.stringify(step.args),\n    };\n\n    if (step.result !== undefined) fields.tool_result = step.result;\n    fields.tool_duration_ms = durationMs;\n\n    return fields;\n  });\n}\n\n// Image cost follows the image-generation columns (driver cost 0); video and voice cost is the\n// row's own cost. An unknown cost stays NULL rather than a guessed 0.\ntype MediaCostFields = Pick<FinishRunParams, \"cost_usd\" | \"cost_source\"> &\n  Partial<Pick<FinishRunParams, \"is_image_generation\" | \"image_cost_usd\" | \"image_cost_method\">>;\n\nfunction mediaCostFields(\n  kind: MediaKind,\n  model: string,\n  cost: GrokMediaCost | undefined,\n): MediaCostFields {\n  if (kind === \"image\") {\n    return {\n      cost_usd: 0,\n      cost_source: cost?.costSource ?? null,\n      is_image_generation: true,\n      image_cost_usd: microUsd(cost?.costUsd) ?? null,\n      image_cost_method: cost\n        ? `${cost.costSource === \"provider\" ? \"reported\" : \"catalog\"}:${model}:ticks=${cost.ticks}`\n        : null,\n    };\n  }\n\n  return { cost_usd: microUsd(cost?.costUsd) ?? null, cost_source: cost?.costSource ?? null };\n}\n\nfunction mediaFinishFields(success: Omit<MediaLogSuccess, \"steps\">): FinishRunParams {\n  return {\n    status: \"succeeded\",\n    response: success.response,\n    token_name: success.tokenName,\n    requested_model_name: success.model,\n    model_name: success.model,\n    input_tokens: 0,\n    output_tokens: 0,\n    cache_read_tokens: 0,\n    cache_creation_tokens: 0,\n    duration_ms: success.durationMs,\n    ...mediaCostFields(success.kind, success.model, success.cost),\n  };\n}\n\n// Logging after a successful provider call is best-effort and never replaces the result.\nasync function finishMediaRun(\n  requestLogId: number | undefined,\n  success: MediaLogSuccess,\n): Promise<void> {\n  if (requestLogId === undefined) return;\n\n  try {\n    for (const step of mediaToolSteps(success.kind, success.steps, success.durationMs)) {\n      await RequestLogModel.appendStep(requestLogId, step);\n    }\n\n    await RequestLogModel.finishRun(requestLogId, mediaFinishFields(success));\n  } catch (e) {\n    mediaLogger.error(\n      `${success.kind} request log failed: ${e instanceof Error ? e.message : String(e)}`,\n    );\n  }\n}\n\nasync function failMediaRun(\n  requestLogId: number | undefined,\n  cause: unknown,\n  aborted: boolean,\n): Promise<void> {\n  if (requestLogId === undefined) return;\n\n  try {\n    await RequestLogModel.finishRun(requestLogId, {\n      status: aborted ? \"aborted\" : \"error\",\n      error_message: aborted\n        ? \"client disconnected\"\n        : cause instanceof Error\n          ? cause.message\n          : String(cause),\n    });\n  } catch (e) {\n    mediaLogger.error(`media request log failed: ${e instanceof Error ? e.message : String(e)}`);\n  }\n}\n\n/**\n * One provider call against an open media run. A failure closes the run as error (or aborted on\n * client disconnect) and surfaces as the caller-facing Grok error; success leaves the run open.\n */\nasync function dispatchMediaCall<T>(\n  requestLogId: number | undefined,\n  call: (signal: AbortSignal) => Promise<T>,\n): Promise<T> {\n  const disconnect = createHttpDisconnectHandle();\n  let result: T;\n\n  try {\n    result = await call(disconnect.signal);\n  } catch (e) {\n    await failMediaRun(requestLogId, e, disconnect.signal.aborted);\n    throwGrokCallerError(e);\n  } finally {\n    disconnect.dispose();\n  }\n\n  return result;\n}\n\ntype MediaRunLog = Omit<MediaLogSuccess, \"kind\" | \"model\" | \"durationMs\">;\n\n/**\n * A one-shot media endpoint: open the run, make the provider call, then log the result. `dispatch`\n * returns the endpoint output and what the run records about it.\n */\nasync function runMediaEndpoint<T>(\n  start: MediaLogStart & { logger: boolean | undefined },\n  dispatch: (\n    signal: AbortSignal,\n    requestLogId: number | undefined,\n  ) => Promise<{ output: T; log: MediaRunLog }>,\n): Promise<T> {\n  const requestLogId = await startMediaRun(start.logger, start);\n  const startedAt = Date.now();\n\n  const { output, log } = await dispatchMediaCall(requestLogId, (signal) =>\n    dispatch(signal, requestLogId),\n  );\n\n  await finishMediaRun(requestLogId, {\n    ...log,\n    kind: start.kind,\n    model: start.model,\n    durationMs: Date.now() - startedAt,\n  });\n\n  return output;\n}\n\n// Video jobs (plan 5.7): an unguessable handle maps to the token that started the job. Polls go\n// only to that token. The owner is the caller identity request logs already carry (projectName);\n// qgrid has no authenticated caller id, so the 128-bit handle is the actual capability.\nconst VIDEO_JOB_TTL_MS = 24 * 60 * 60_000;\nconst VIDEO_JOB_MAX = 10_000;\n\ntype VideoJob = {\n  tokenId: number;\n  tokenName: string;\n  requestId: string;\n  owner: string | null;\n  model: string;\n  createdAt: number;\n  requestLogId?: number;\n  final?: VideoStatusOutput;\n};\n\nconst videoJobs = new Map<string, VideoJob>();\n\nfunction pruneVideoJobs(now: number): void {\n  for (const [handle, job] of videoJobs) {\n    if (now - job.createdAt < VIDEO_JOB_TTL_MS && videoJobs.size <= VIDEO_JOB_MAX) break;\n    videoJobs.delete(handle);\n  }\n}\n\nfunction videoToolCallId(job: Pick<VideoJob, \"requestId\">): string {\n  return `video_generation:${job.requestId}`;\n}\n\n// Resolves the pending video step and finishes the run. Best-effort: a run already expired by\n// stale cleanup only loses its late result.\nasync function finishVideoRun(\n  job: VideoJob,\n  final: VideoStatusOutput,\n  cost: GrokMediaCost | undefined,\n): Promise<void> {\n  if (job.requestLogId === undefined) return;\n\n  try {\n    await RequestLogModel.continueToolRun(job.requestLogId, [\n      {\n        toolCallId: videoToolCallId(job),\n        output: JSON.stringify({\n          status: final.status,\n          url: final.url,\n          durationSec: final.durationSec,\n          costInUsdTicks: final.costInUsdTicks,\n          error: final.error,\n        }),\n        isError: final.status === \"failed\",\n      },\n    ]);\n\n    const fields = mediaFinishFields({\n      kind: \"video\",\n      model: job.model,\n      tokenName: job.tokenName,\n      durationMs: Date.now() - job.createdAt,\n      response: final.url ?? \"\",\n      cost,\n    });\n\n    await RequestLogModel.finishRun(\n      job.requestLogId,\n      final.status === \"done\"\n        ? fields\n        : { ...fields, status: \"error\", error_message: final.error ?? \"video generation failed\" },\n    );\n  } catch (e) {\n    mediaLogger.error(`video request log failed: ${e instanceof Error ? e.message : String(e)}`);\n  }\n}\n\nconst GROK_TTS_LOG_MODEL = \"grok/tts\";\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    rejectInvalidImageQuery(args);\n    rejectInvalidCallerSchemas(args);\n    const resolvedArgs = await resolveTokenName(args);\n    const disconnect = createHttpDisconnectHandle();\n\n    try {\n      if (resolvedArgs.logger === false) {\n        try {\n          return await QgridDispatcher.query(resolvedArgs, disconnect.signal);\n        } catch (e) {\n          throwGrokCallerError(e);\n        }\n      }\n\n      const { requestLogId, stepIndex } = await beforeQuery(resolvedArgs);\n      let result: QueryOutput;\n\n      try {\n        result = await QgridDispatcher.query(resolvedArgs, disconnect.signal);\n      } catch (e) {\n        const completedDriver = completedDriverFromImageFailure(e, resolvedArgs.serviceTier);\n\n        const completedStep = completedDriver\n          ? ([{ stepIndex, result: completedDriver }] as const)\n          : ([] as const);\n\n        if (disconnect.signal.aborted) {\n          await finishRunAborted(requestLogId, resolvedArgs, ...completedStep);\n        } else {\n          await finishRunWithError(\n            requestLogId,\n            e instanceof Error ? e.message : String(e),\n            resolvedArgs,\n            ...completedStep,\n          );\n        }\n\n        throwGrokCallerError(e);\n      }\n\n      try {\n        const lifecycle = await afterQuery(requestLogId, stepIndex, resolvedArgs, result);\n\n        if (disconnect.signal.aborted) {\n          await finishRunAborted(requestLogId, resolvedArgs);\n        }\n\n        // tool-call requestLogId와 provider threadCoord는 서로 독립적으로 유지한다.\n        const threadCoord = result.runContext?.threadCoord;\n\n        const runContext = mergeRunContext(lifecycle.runContext, threadCoord);\n\n        return { ...result, requestLogId, runContext };\n      } catch (e) {\n        logger.error(`query afterQuery failed: ${e instanceof Error ? e.message : String(e)}`);\n\n        if (disconnect.signal.aborted) {\n          await finishRunAborted(requestLogId, resolvedArgs);\n        } else {\n          await finishRunWithError(\n            requestLogId,\n            e instanceof Error ? e.message : String(e),\n            resolvedArgs,\n          );\n        }\n\n        // provider 응답은 성공했으므로 로깅 장애가 생성 결과를 덮어쓰지 않는다.\n        return { ...result, requestLogId };\n      }\n    } finally {\n      disconnect.dispose();\n    }\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async prepareStream(args: QueryInput): Promise<{ streamId: string }> {\n    rejectImageGenerationStream(args);\n    rejectInvalidCallerSchemas(args);\n    const resolvedArgs = await resolveTokenName(args);\n    const streamId = crypto.randomUUID();\n    pendingStreams.set(streamId, resolvedArgs);\n    const expiry = setTimeout(() => pendingStreams.delete(streamId), 30_000);\n    expiry.unref?.();\n\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\n    if (!args) throw new Error(\"invalid or expired streamId\");\n    rejectImageGenerationStream(args);\n\n    const ctx = Sonamu.getContext();\n    const sse = ctx.createSSE(StreamEvents);\n    let streamResult: QueryOutput | undefined;\n    let streamError: Error | undefined;\n    let clientClosed = false;\n    const abortController = new AbortController();\n\n    sse.onClose(() => {\n      clientClosed = true;\n      abortController.abort();\n    });\n\n    let runInfo: { requestLogId: number; stepIndex: number } | undefined;\n\n    if (args.logger !== false) {\n      // provider 실행 전 running row 생성에 실패하면 logged 요청으로 진행하지 않는다.\n      runInfo = await beforeQuery(args);\n    }\n\n    // beforeQuery DB 작업 중 close를 놓치지 않고 provider 실행 전에 마감한다.\n    if (clientClosed || sse.closed) {\n      if (runInfo) await finishRunAborted(runInfo.requestLogId, args);\n      await sse.end();\n\n      return;\n    }\n\n    try {\n      await QgridDispatcher.queryStream(\n        args,\n        {\n          onDelta: (text) => {\n            if (!clientClosed && !sse.closed) sse.publish(\"delta\", { text });\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 instanceof Error ? e : new Error(String(e));\n    }\n\n    // provider 결과가 없는 close는 즉시 aborted로 마감한다.\n    if (clientClosed && !streamResult) {\n      if (runInfo) await finishRunAborted(runInfo.requestLogId, args);\n      await sse.end();\n\n      return;\n    }\n\n    // dispatcher 완료 후 lifecycle 처리 (await 안전)\n    if (streamResult) {\n      // dispatcher 가 실은 thread 재사용 좌표는 logger 설정과 무관하게 회송한다.\n      const threadCoord = streamResult.runContext?.threadCoord;\n\n      let runContext: QgridRunContext | undefined =\n        threadCoord === undefined ? undefined : { threadCoord };\n\n      if (runInfo) {\n        try {\n          // close 후 도착한 결과도 step/usage는 남기되, 아래에서 최종 status를 aborted로 덮어쓴다.\n          const lifecycle = await afterQuery(\n            runInfo.requestLogId,\n            runInfo.stepIndex,\n            args,\n            streamResult,\n          );\n\n          runContext = mergeRunContext(lifecycle.runContext, threadCoord);\n\n          // afterQuery가 진행되는 사이 client가 닫힌 경우 완료 상태를 aborted로 되돌린다.\n          if (clientClosed) {\n            await finishRunAborted(runInfo.requestLogId, args);\n            await sse.end();\n\n            return;\n          }\n        } catch (e) {\n          logger.error(`stream afterQuery failed: ${e instanceof Error ? e.message : String(e)}`);\n          await finishRunWithError(\n            runInfo.requestLogId,\n            e instanceof Error ? e.message : String(e),\n            args,\n          );\n\n          if (clientClosed) {\n            await finishRunAborted(runInfo.requestLogId, args);\n            await sse.end();\n\n            return;\n          }\n        }\n      }\n\n      if (!clientClosed && !sse.closed) {\n        const done: QueryOutput = { ...streamResult };\n\n        if (runInfo) done.requestLogId = runInfo.requestLogId;\n        done.runContext = runContext;\n        sse.publish(\"done\", done);\n      }\n    } else if (streamError) {\n      if (runInfo) await finishRunWithError(runInfo.requestLogId, streamError.message, args);\n\n      if (!clientClosed && !sse.closed) sse.publish(\"error\", { message: streamError.message });\n    } else if ((clientClosed || 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      requested_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      is_structured: input.isStructured,\n      json_schema: input.jsonSchema,\n    });\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      model_name: input.modelName,\n      requested_model_name: input.requestedModelName,\n      fallback_count: input.fallbackCount,\n      input_tokens: input.inputTokens,\n      output_tokens: input.outputTokens,\n      cache_read_tokens: input.cacheReadTokens,\n      cache_creation_tokens: input.cacheCreationTokens,\n      cache_creation_5m_tokens: input.cacheCreation5mTokens,\n      cache_creation_1h_tokens: input.cacheCreation1hTokens,\n      cost_usd: input.costUsd === undefined ? undefined : Math.round(input.costUsd * MICRO_USD),\n      cost_source: input.costSource,\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\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      model_name: input.modelName,\n      requested_model_name: input.requestedModelName,\n      fallback_count: input.fallbackCount,\n      input_tokens: input.totalInputTokens,\n      output_tokens: input.totalOutputTokens,\n      cache_read_tokens: input.totalCacheReadTokens,\n      cache_creation_tokens: input.totalCacheCreationTokens,\n      cache_creation_5m_tokens: input.totalCacheCreation5mTokens,\n      cache_creation_1h_tokens: input.totalCacheCreation1hTokens,\n      cost_usd: input.costUsd === undefined ? undefined : Math.round(input.costUsd * MICRO_USD),\n      cost_source: input.costSource,\n      duration_ms: input.totalDurationMs,\n      history: input.history ? JSON.parse(input.history) : undefined,\n      error_message: input.errorMessage,\n      response_json_ok: input.responseJsonOk,\n    });\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  // 화면의 목록 필터를 그대로 받아 같은 조건의 합계를 돌려준다 — 목록과 비용이\n  // 서로 다른 모수를 보면 사용자에게는 숫자가 어긋난 것으로 읽힌다.\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"] })\n  async totalCost(\n    params?: RequestLogListParams,\n  ): Promise<{ usd: number; unknownImageCostCount: number; unknownCostCount: number }> {\n    return RequestLogModel.totalCost(params);\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: \"GET\", clients: [\"axios\", \"tanstack-query\"] })\n  async modelNames(): Promise<{ names: string[] }> {\n    return { names: await RequestLogModel.distinctModelNames() };\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\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    keepaliveEnabled?: boolean,\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        SD(\"error.detail\")(\"quotaThreshold must be an integer between 1 and 100, or null\"),\n      );\n    }\n\n    if (weight !== undefined && (!Number.isInteger(weight) || weight < 1 || weight > 100)) {\n      throw new BadRequestException(\n        SD(\"error.detail\")(\"weight must be an integer between 1 and 100\"),\n      );\n    }\n\n    const patch: TokenUpdateFields = {};\n\n    if (name !== undefined) patch.name = name;\n\n    if (quotaThreshold !== undefined) patch.quota_threshold = quotaThreshold;\n\n    if (weight !== undefined) patch.weight = weight;\n\n    if (keepaliveEnabled !== undefined) patch.keepalive_enabled = keepaliveEnabled;\n\n    if (Object.keys(patch).length === 0) return { updated: false };\n\n    const updated = await TokenModel.updateFields(id, patch);\n\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\n    if (!entry) return { removed: false };\n    await TokenModel.del([entry.id]);\n\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 result = await TokenModel.toggleActive(id);\n\n    if (!result) return { active: false };\n\n    if (result.reauthRequired) {\n      throw new BadRequestException(SD(\"error.detail\")(\"Re-login required\"));\n    }\n\n    return { active: result.active };\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, mode } = resolveOAuthRedirect();\n    const authUrl = buildAuthUrl(codeChallenge, state, redirectUri);\n\n    await setOAuthState(state, { codeVerifier, name, redirectUri, provider: \"anthropic\" });\n\n    return { authUrl, mode };\n  }\n\n  // 원격 접속의 수동 완료: Anthropic `code#state` 또는 OpenAI callback URL을 받아 교환한다.\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async oauthComplete(pastedCode: string): Promise<{ added: boolean; name: string }> {\n    const result = parsePastedOAuthResult(pastedCode);\n\n    if (!result) {\n      // Grok accepts a bare authorization code, which carries no state (grok-build login.rs).\n      const grokState = await getGrokLatestState();\n      const grokPending = grokState ? await getOAuthState(grokState) : undefined;\n\n      if (grokState && grokPending?.provider === \"grok\" && pastedCode.trim()) {\n        await deleteOAuthState(grokState);\n        await this.completeGrokLogin(pastedCode, grokState, grokPending);\n\n        return { added: true, name: grokPending.name };\n      }\n\n      throw new BadRequestException(\n        SD(\"error.detail\")(\n          \"expected the callback URL or code shown after login, in code#state form\",\n        ),\n      );\n    }\n\n    const { code, state } = result;\n\n    const pending = await getOAuthState(state);\n\n    if (!pending) {\n      throw new BadRequestException(\n        SD(\"error.detail\")(\"login session not found or expired — start the login again\"),\n      );\n    }\n\n    await deleteOAuthState(state);\n\n    if (pending.provider === \"openai\") {\n      await this.completeOpenAILogin(code, pending);\n    } else if (pending.provider === \"grok\") {\n      // completeGrokOAuth re-checks the pasted URL's state against the stored one.\n      await this.completeGrokLogin(pastedCode, state, pending);\n    } else {\n      await this.completeAnthropicLogin(code, state, pending);\n    }\n\n    return { added: true, name: pending.name };\n  }\n\n  // 교환 + 계정 중복 제거 + 저장 — redirect 콜백과 코드 붙여넣기 플로우가 공유한다.\n  async completeAnthropicLogin(code: string, state: string, pending: PendingOAuth): Promise<void> {\n    const tokens = await exchangeCodeForTokens(\n      code,\n      pending.codeVerifier,\n      state,\n      pending.redirectUri,\n    );\n\n    await TokenModel.replaceByAccount(\"anthropic\", tokens.accountUuid, {\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    notifyTokenAdded(pending.name, \"anthropic\");\n  }\n\n  async completeOpenAILogin(code: string, pending: PendingOAuth): Promise<void> {\n    const creds = await exchangeOpenAICode(code, pending.codeVerifier, pending.redirectUri);\n    await TokenModel.replaceByAccount(\"openai\", creds.accountId, {\n      provider: \"openai\",\n      credentials: creds,\n      name: pending.name,\n    });\n    logger.info(`OpenAI token saved for ${pending.name}`);\n    notifyTokenAdded(pending.name, \"openai\");\n  }\n\n  async completeGrokLogin(codeOrUrl: string, state: string, pending: PendingOAuth): Promise<void> {\n    let credentials: StrictGrokCredentials;\n\n    try {\n      credentials = await completeGrokOAuth({\n        codeOrUrl,\n        verifier: pending.codeVerifier,\n        redirectUri: pending.redirectUri,\n        state,\n      });\n    } catch (error) {\n      grokOAuthBadRequest(error);\n    }\n\n    await this.saveGrokToken(credentials, pending.name);\n  }\n\n  // Registration rejects anything that is not an xAI OAuth at+jwt (API keys, opaque tokens).\n  async saveGrokToken(candidate: StrictGrokCredentials, name: string): Promise<void> {\n    const parsed = StrictGrokCredentials.safeParse(candidate);\n\n    if (!parsed.success) {\n      throw new BadRequestException(SD(\"qgrid.grokNotOAuthToken\"));\n    }\n\n    await TokenModel.replaceByAccount(\"grok\", parsed.data.userId, {\n      provider: \"grok\",\n      credentials: parsed.data,\n      name,\n    });\n    logger.info(`Grok token saved for ${name}`);\n    notifyTokenAdded(name, \"grok\");\n  }\n\n  async handleOAuthCallback(code: string, state: string, reply: FastifyReply): Promise<void> {\n    const pending = await getOAuthState(state);\n\n    if (!pending) {\n      logger.warn(\"oauth callback: invalid_state\");\n\n      return reply.redirect(\"/?oauth=error&reason=invalid_state\");\n    }\n\n    await deleteOAuthState(state);\n\n    try {\n      if (pending.provider === \"openai\") {\n        await this.completeOpenAILogin(code, pending);\n      } else if (pending.provider === \"grok\") {\n        await this.completeGrokLogin(code, state, pending);\n      } else {\n        await this.completeAnthropicLogin(code, state, pending);\n      }\n\n      return reply.redirect(`/?oauth=success&name=${encodeURIComponent(pending.name)}`);\n    } catch {\n      logger.warn(\"oauth callback failed\", {\n        provider: pending.provider,\n        reason: \"exchange_failed\",\n      });\n\n      return reply.redirect(\"/?oauth=error&reason=exchange_failed\");\n    }\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async oauthStartOpenAI(name: string): Promise<OAuthStartResult> {\n    const { codeVerifier, codeChallenge, state } = generateOpenAIPKCE();\n    const mode = isRemoteOAuthRequest() ? \"code\" : \"redirect\";\n    let redirectUri: string;\n\n    if (mode === \"code\") {\n      // OpenAI accepts only the Codex CLI's registered loopback URI. On a remote dashboard the\n      // browser cannot reach the server's loopback, so the user pastes the resulting callback URL.\n      redirectUri = openAICallbackRedirectUri(OPENAI_CALLBACK_PORTS[0]);\n    } else {\n      try {\n        redirectUri = await startOpenAICallbackRelay(trustedLoopbackBase(), OAUTH_STATE_TTL_MS);\n      } catch {\n        throw new BadRequestException(\n          SD(\"error.detail\")(\n            `OpenAI login needs local port ${OPENAI_CALLBACK_PORTS.join(\" or \")} — close any running \\`codex login\\` and retry`,\n          ),\n        );\n      }\n    }\n\n    const authUrl = buildOpenAIAuthUrl(codeChallenge, state, redirectUri);\n    await setOAuthState(state, { codeVerifier, name, redirectUri, provider: \"openai\" });\n\n    return { authUrl, mode };\n  }\n\n  // Grok's registered redirect is a random 127.0.0.1 loopback port that qgrid does not serve, so\n  // the user always pastes the resulting callback URL (or the bare code) into oauthComplete.\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async oauthStartGrok(name: string): Promise<OAuthStartResult> {\n    const state = crypto.randomBytes(32).toString(\"base64url\");\n    let started;\n\n    try {\n      started = await startGrokOAuth({ state });\n    } catch (error) {\n      grokOAuthBadRequest(error);\n    }\n\n    await setOAuthState(state, {\n      codeVerifier: started.verifier,\n      name,\n      redirectUri: started.redirectUri,\n      provider: \"grok\",\n    });\n    await setGrokLatestState(state);\n\n    return { authUrl: started.authorizeUrl, mode: \"code\" };\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async oauthStartGrokDevice(name: string): Promise<GrokDeviceCodeStart> {\n    let device;\n\n    try {\n      device = await startGrokDeviceCode();\n    } catch (error) {\n      grokOAuthBadRequest(error);\n    }\n\n    await setGrokDeviceState(device.deviceCode, {\n      name,\n      interval: device.interval,\n      expiresAtMs: Date.now() + device.expiresIn * 1000,\n    });\n\n    return device;\n  }\n\n  // One poll per call; the web waits intervalSec between calls.\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async oauthPollGrokDevice(deviceCode: string): Promise<GrokDevicePollResult> {\n    const pending = await getGrokDeviceState(deviceCode);\n\n    if (!pending) {\n      throw new BadRequestException(\n        SD(\"error.detail\")(\"login session not found or expired — start the login again\"),\n      );\n    }\n\n    let result;\n\n    try {\n      result = await pollGrokDeviceCode({ deviceCode, interval: pending.interval });\n    } catch (error) {\n      if (error instanceof GrokOAuthError && !error.options.retryable) {\n        await deleteGrokDeviceState(deviceCode);\n      }\n\n      grokOAuthBadRequest(error);\n    }\n\n    if (result.status === \"pending\") {\n      const slowDown = result.interval > pending.interval;\n\n      if (slowDown) await setGrokDeviceState(deviceCode, { ...pending, interval: result.interval });\n\n      return { status: slowDown ? \"slow_down\" : \"pending\", intervalSec: result.interval };\n    }\n\n    await deleteGrokDeviceState(deviceCode);\n    await this.saveGrokToken(result.credentials, pending.name);\n\n    return { status: \"added\", name: pending.name };\n  }\n\n  // Grok image generation (grok/* only; OpenAI images stay on query/qgrid.image()). With\n  // referenceImages the request goes to /images/edits.\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async generateImages(params: GenerateImagesInput): Promise<GenerateImagesOutput> {\n    const input = parseMediaInput(GenerateImagesInput, params);\n    const media = grokMedia();\n    const selection = await resolveGrokTokenSelection(input.tokenName);\n    const { id, route } = routeModelId(input.model, GROK_IMAGE_DEFAULT_MODEL);\n    const refs = input.referenceImages ?? [];\n\n    const start = {\n      kind: \"image\",\n      model: route,\n      prompt: input.prompt,\n      projectName: input.projectName,\n      logger: input.logger,\n    } as const;\n\n    return runMediaEndpoint(start, async (signal, requestLogId) => {\n      const request = {\n        model: id,\n        prompt: input.prompt,\n        n: input.n,\n        aspectRatio: input.aspectRatio,\n        resolution: input.resolution,\n        quality: input.quality,\n        outputFormat: input.outputFormat,\n        signal,\n        ...selection,\n      };\n\n      const dispatched = refs.length\n        ? await media.editImages({ ...request, images: refs })\n        : await media.generateImages(request);\n\n      const decoded = decodeGrokImages(dispatched.result);\n      const cost = grokImageCost(id, decoded.images.length, decoded.costInUsdTicks);\n\n      const output: GenerateImagesOutput = {\n        model: route,\n        tokenName: dispatched.tokenName,\n        images: decoded.images.map((image) => {\n          const generated: GeneratedImage = {\n            b64: Buffer.from(image.bytes).toString(\"base64\"),\n            mimeType: image.mediaType,\n          };\n\n          if (image.revisedPrompt) generated.revisedPrompt = image.revisedPrompt;\n\n          return generated;\n        }),\n        usage: { imageCount: decoded.images.length },\n      };\n\n      if (decoded.costInUsdTicks !== undefined) {\n        output.usage.costInUsdTicks = decoded.costInUsdTicks;\n      }\n\n      if (cost) {\n        output.costUsd = cost.costUsd;\n        output.costSource = cost.costSource;\n      }\n\n      if (requestLogId !== undefined) output.requestLogId = requestLogId;\n\n      const log: MediaRunLog = {\n        tokenName: output.tokenName,\n        cost,\n        response: output.images\n          .map((image) => imageTagForLog(image.b64, image.mimeType, image.revisedPrompt))\n          .join(\"\\n\"),\n        steps: output.images.map((image, index) => {\n          const args: ImageStepArgs = {\n            kind: \"image\",\n            prompt: input.prompt,\n            model: route,\n            requestedOptions: {\n              n: input.n,\n              aspectRatio: input.aspectRatio,\n              resolution: input.resolution,\n              quality: input.quality,\n              outputFormat: input.outputFormat,\n            },\n            imageCount: output.usage.imageCount,\n          };\n\n          if (cost) {\n            args.costSource = cost.costSource;\n            args.costInUsdTicks = cost.ticks;\n          }\n\n          // Reference images are stored once, on the first output step.\n          if (index === 0 && refs.length) args.inputImages = describeImageRefs(refs, true);\n\n          return {\n            toolCallId: `image_generation:0:${index}`,\n            args,\n            result: imageTagForLog(image.b64, image.mimeType, image.revisedPrompt),\n          };\n        }),\n      };\n\n      return { output, log };\n    });\n  }\n\n  // Starts a Grok video job. Poll videoStatus with the returned handle and the same projectName.\n  // The run stays open after a successful start (a pending tool step), so only the provider call\n  // goes through dispatchMediaCall; videoStatus finishes the run on a terminal status.\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async videoStart(params: VideoStartInput): Promise<VideoStartOutput> {\n    const input = parseMediaInput(VideoStartInput, params);\n    const media = grokMedia();\n    const selection = await resolveGrokTokenSelection(input.tokenName);\n    const { id, route } = routeModelId(input.model, GROK_VIDEO_DEFAULT_MODEL);\n\n    const requestLogId = await startMediaRun(input.logger, {\n      kind: \"video\",\n      model: route,\n      prompt: input.prompt,\n      projectName: input.projectName,\n    });\n\n    const startedAt = Date.now();\n\n    const started = await dispatchMediaCall(requestLogId, (signal) =>\n      media.startVideo({\n        model: id,\n        prompt: input.prompt,\n        duration: input.duration,\n        aspectRatio: input.aspectRatio,\n        resolution: input.resolution,\n        image: input.image,\n        lastFrame: input.lastFrame,\n        referenceImages: input.referenceImages,\n        mode: input.mode,\n        signal,\n        ...selection,\n      }),\n    );\n\n    const now = Date.now();\n    pruneVideoJobs(now);\n    const jobHandle = crypto.randomBytes(16).toString(\"base64url\");\n\n    const job: VideoJob = {\n      tokenId: started.tokenId,\n      tokenName: started.tokenName,\n      requestId: started.result.request_id,\n      owner: input.projectName ?? null,\n      model: route,\n      createdAt: now,\n    };\n\n    if (requestLogId !== undefined) job.requestLogId = requestLogId;\n\n    videoJobs.set(jobHandle, job);\n\n    if (requestLogId !== undefined) {\n      // The pending tool step keeps the run open; an abandoned job is expired by stale cleanup.\n      const refs = [\n        ...(input.image ? [input.image] : []),\n        ...(input.lastFrame ? [input.lastFrame] : []),\n        ...(input.referenceImages ?? []),\n      ];\n\n      const args: VideoStepArgs = {\n        kind: \"video\",\n        prompt: input.prompt,\n        model: route,\n        requestedOptions: {\n          duration: input.duration,\n          aspectRatio: input.aspectRatio,\n          resolution: input.resolution,\n          mode: input.mode,\n        },\n      };\n\n      if (refs.length) args.inputImages = describeImageRefs(refs, false);\n\n      const [step] = mediaToolSteps(\n        \"video\",\n        [{ toolCallId: videoToolCallId(job), args }],\n        now - startedAt,\n      );\n\n      try {\n        await RequestLogModel.appendStep(requestLogId, step!);\n      } catch (e) {\n        mediaLogger.error(\n          `video request log failed: ${e instanceof Error ? e.message : String(e)}`,\n        );\n      }\n    }\n\n    const output: VideoStartOutput = { jobHandle, model: route };\n\n    if (requestLogId !== undefined) output.requestLogId = requestLogId;\n\n    return output;\n  }\n\n  // Polls the token that started the job. A terminal status is cached so the run is logged once.\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async videoStatus(params: VideoStatusInput): Promise<VideoStatusOutput> {\n    const input = parseMediaInput(VideoStatusInput, params);\n    pruneVideoJobs(Date.now());\n    const job = videoJobs.get(input.jobHandle);\n\n    // A foreign owner gets the same 404 as an unknown handle, so handles cannot be probed.\n    if (!job || job.owner !== (input.projectName ?? null)) {\n      throw new NotFoundException(SD(\"qgrid.videoJobNotFound\"));\n    }\n\n    if (job.final) return job.final;\n\n    const media = grokMedia();\n    const disconnect = createHttpDisconnectHandle();\n    let summary: ReturnType<typeof summarizeGrokVideoStatus>;\n    let durationSec: number | undefined;\n\n    try {\n      const polled = await media.getVideo(job.tokenId, job.requestId, disconnect.signal);\n      summary = summarizeGrokVideoStatus(polled.result);\n      durationSec = polled.result.video?.duration ?? undefined;\n    } catch (e) {\n      if (!(e instanceof GrokContentPolicyError)) throwGrokCallerError(e);\n      summary = { status: \"failed\", mimeType: \"video/mp4\", error: e.message };\n    } finally {\n      disconnect.dispose();\n    }\n\n    // An overlapping poll may have finished the job while this one awaited upstream.\n    if (job.final) return job.final;\n\n    const status: VideoStatusOutput = { status: summary.status, mimeType: \"video/mp4\" };\n\n    if (job.requestLogId !== undefined) status.requestLogId = job.requestLogId;\n\n    if (summary.status === \"pending\") return status;\n\n    const cost = grokReportedCost(summary.usageTicks);\n    const final = status;\n\n    if (summary.url) final.url = summary.url;\n\n    if (durationSec !== undefined) final.durationSec = durationSec;\n\n    if (cost) {\n      final.costInUsdTicks = cost.ticks;\n      final.costUsd = cost.costUsd;\n    }\n\n    if (summary.error) final.error = summary.error;\n\n    // Set before finishVideoRun's await: overlapping polls return this result instead of logging again.\n    job.final = final;\n    await finishVideoRun(job, final, cost);\n\n    return final;\n  }\n\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async transcribe(params: TranscribeInput): Promise<TranscribeOutput> {\n    const input = parseMediaInput(TranscribeInput, params);\n    const voice = grokVoice();\n    const selection = await resolveGrokTokenSelection(input.tokenName);\n    const { id, route } = routeModelId(input.model, GROK_STT_DEFAULT_MODEL);\n    const audio = new Uint8Array(Buffer.from(input.audio, \"base64\"));\n\n    const start = {\n      kind: \"stt\",\n      model: route,\n      prompt: `[audio ${input.mediaType} ${audio.byteLength} bytes]`,\n      projectName: input.projectName,\n      logger: input.logger,\n    } as const;\n\n    return runMediaEndpoint(start, async (signal, requestLogId) => {\n      const dispatched = await voice.transcribe({\n        audio,\n        mediaType: input.mediaType,\n        model: id,\n        language: input.language,\n        signal,\n        ...selection,\n      });\n\n      const { text, language, duration } = dispatched.result;\n\n      const output: TranscribeOutput = { text, model: route, tokenName: dispatched.tokenName };\n\n      if (language) output.language = language;\n\n      if (duration !== undefined) output.durationSec = duration;\n\n      if (requestLogId !== undefined) output.requestLogId = requestLogId;\n\n      const log: MediaRunLog = {\n        tokenName: output.tokenName,\n        response: output.text,\n        steps: [\n          {\n            toolCallId: \"transcription:0\",\n            args: {\n              kind: \"stt\",\n              model: route,\n              mediaType: input.mediaType,\n              audioBytes: audio.byteLength,\n              language: input.language,\n              durationSec: output.durationSec,\n            },\n            result: JSON.stringify({\n              text: output.text,\n              language: output.language,\n              durationSec: output.durationSec,\n            }),\n          },\n        ],\n      };\n\n      return { output, log };\n    });\n  }\n\n  // /tts takes no model; `model` only labels the request log.\n  @api({ httpMethod: \"POST\", clients: [\"axios\", \"tanstack-mutation\"] })\n  async speak(params: SpeakInput): Promise<SpeakOutput> {\n    const input = parseMediaInput(SpeakInput, params);\n    const voice = grokVoice();\n    const selection = await resolveGrokTokenSelection(input.tokenName);\n    const route = input.model ?? GROK_TTS_LOG_MODEL;\n\n    const request = {\n      text: input.text,\n      voice: input.voice ?? GROK_TTS_DEFAULT_VOICE,\n      language: input.language ?? GROK_TTS_DEFAULT_LANGUAGE,\n      format: input.format ?? GROK_TTS_DEFAULT_FORMAT,\n    };\n\n    const start = {\n      kind: \"tts\",\n      model: route,\n      prompt: input.text,\n      projectName: input.projectName,\n      logger: input.logger,\n    } as const;\n\n    return runMediaEndpoint(start, async (signal, requestLogId) => {\n      const dispatched = await voice.speak({ ...request, signal, ...selection });\n      const audioBytes = dispatched.result.audio.byteLength;\n\n      const output: SpeakOutput = {\n        audio: Buffer.from(dispatched.result.audio).toString(\"base64\"),\n        mimeType: dispatched.result.mediaType,\n        tokenName: dispatched.tokenName,\n      };\n\n      if (requestLogId !== undefined) output.requestLogId = requestLogId;\n\n      const log: MediaRunLog = {\n        tokenName: output.tokenName,\n        response: `[audio ${output.mimeType} ${audioBytes} bytes]`,\n        steps: [\n          {\n            toolCallId: \"speech:0\",\n            args: {\n              kind: \"tts\",\n              model: route,\n              voice: request.voice,\n              language: request.language,\n              format: request.format,\n              characters: input.text.length,\n            },\n            result: JSON.stringify({ mimeType: output.mimeType, audioBytes }),\n          },\n        ],\n      };\n\n      return { output, log };\n    });\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\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.reauth_required) return { error: \"re-login required\" };\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\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 instanceof Error ? e.message : String(e)}` };\n      }\n    }\n\n    if (entry.provider === \"grok\") {\n      // Cached billing from the dispatcher's prefetch; usage never calls xAI itself.\n      const snapshot = entry.active ? grokTokenSnapshot(entry.id) : undefined;\n      const billing = snapshot?.lastBilling;\n      const storedTier = StoredGrokCredentials.safeParse(entry.credentials).data?.subscriptionTier;\n\n      return {\n        provider: \"grok\",\n        fiveHour: null,\n        sevenDay: billing\n          ? { utilization: billing.utilizationPct, resetsAt: billing.periodEnd }\n          : null,\n        periodType: billing?.periodType ?? null,\n        tier: snapshot?.lastTier ?? storedTier ?? null,\n        onDemandExcluded: snapshot?.onDemandExcluded ?? false,\n        zdrVideoExcluded: snapshot?.zdrVideoExcluded ?? false,\n        keepaliveApplicable: false,\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(\n          `refresh failed for ${entry.name}: ${e instanceof Error ? e.message : String(e)}`,\n        );\n\n        return { error: \"Token refresh failed; usage is unavailable\" };\n      }\n    }\n\n    const raw = await fetchUsage(accessToken);\n\n    if (raw.error && getRefreshToken(entry.credentials)) {\n      try {\n        accessToken = await this.refreshToken(entry);\n        const retried = await fetchUsage(accessToken);\n\n        if (retried.error) return { error: retried.error };\n\n        return convertAnthropicUsage(retried);\n      } catch (e) {\n        oauthLogger.warn(\n          `refresh failed for ${entry.name}: ${e instanceof Error ? e.message : String(e)}`,\n        );\n\n        return { error: \"Token refresh failed; usage is unavailable\" };\n      }\n    }\n\n    if (raw.error) return { error: raw.error };\n\n    return convertAnthropicUsage(raw);\n  }\n\n  // 동시 refresh 가 회전을 겹치면 뒤늦은 호출이 이미 폐기된 refresh token 을 쓰게 되어\n  // 멀쩡한 토큰이 사망으로 오판된다. openai-refresh.ts 와 같은 per-token dedup 을 둔다.\n  async refreshToken(token: RefreshableToken): Promise<string> {\n    if (token.provider === \"grok\") return this.refreshGrokToken(token);\n    const inflight = inflightAnthropicRefresh.get(token.id);\n\n    if (inflight) return inflight;\n\n    const promise = this.doRefreshToken(token);\n    inflightAnthropicRefresh.set(token.id, promise);\n\n    try {\n      return await promise;\n    } finally {\n      inflightAnthropicRefresh.delete(token.id);\n    }\n  }\n\n  // Set by bootstrap; the same coordinator the GrokDispatcher uses, so refreshes are single-flight.\n  grokRefresher: GrokRefreshCoordinator | null = null;\n\n  async refreshGrokToken(token: RefreshableToken): Promise<string> {\n    if (!this.grokRefresher) throw new Error(\"Grok refresher not initialized\");\n    const current = StrictGrokCredentials.parse(token.credentials);\n\n    const next = await this.grokRefresher.refresh(token.id, current, (creds) =>\n      persistGrokCredentials(token.id, creds),\n    );\n\n    return next.accessToken;\n  }\n\n  async doRefreshToken(token: RefreshableToken): Promise<string> {\n    const creds = token.credentials;\n    const rt = getRefreshToken(creds);\n\n    if (!rt) throw new Error(\"No refresh token\");\n\n    let refreshed;\n\n    try {\n      refreshed = await refreshAccessToken(rt);\n    } catch (e) {\n      if (e instanceof RefreshFailedError && e.isAuthDead()) {\n        await deactivateAuthDeadToken(token, `anthropic:${e.status}`);\n      }\n\n      throw e;\n    }\n\n    const updated = TokenCredentials.parse({\n      ...creds,\n      accessToken: refreshed.accessToken,\n      refreshToken: refreshed.refreshToken,\n      expiresAt: refreshed.expiresAt,\n    });\n\n    await TokenModel.save([\n      {\n        id: token.id,\n        provider: token.provider,\n        credentials: updated,\n        name: token.name,\n        reauth_required: false,\n      },\n    ]);\n\n    return refreshed.accessToken;\n  }\n\n  @api({ httpMethod: \"GET\", clients: [\"axios\", \"tanstack-query\"] })\n  async health(): Promise<HealthResponse> {\n    const providers = { ...QgridDispatcher.startupState };\n\n    return {\n      status: \"ok\",\n      activeTokens: QgridDispatcher.tokens.size,\n      subscriber: QgridDispatcher.subscriber?.status() ?? null,\n      // provider 별 라우팅이라 하나만 준비돼도 그 provider 요청은 처리된다.\n      ready: Object.values(providers).includes(\"ready\"),\n      providers,\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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"}