@cartanova/qgrid-cli 2.10.10 → 2.11.1

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

@@ -0,0 +1,1313 @@
+import { GROK_BUILD_VERSION, GROK_USD_PER_TICK } from "./grok-constants.js";
+import { isJsonObject, jsonString } from "../common/provider-types.js";
+import { QuotaThresholdExceededError } from "../../../application/qgrid/qgrid.types.js";
+import { SmoothWeightedRoundRobin } from "../common/smooth-weighted-round-robin.js";
+import { ThinkingValidationError } from "../common/thinking.js";
+import { buildGrokResponsesRequest } from "./grok-backend-protocol.js";
+import { GrokChatClient, GrokHttpError, GrokIdleTimeoutError } from "./grok-direct-client.js";
+import { buildGrokChatHeaders } from "./grok-headers.js";
+import { GrokCredentials } from "./grok-types.js";
+import { GrokModelCatalog } from "./grok-models.js";
+import { readGrokBilling, readGrokSettings, readGrokSubscription } from "./grok-quota.js";
+import { grokNeedsRefresh } from "./grok-refresh.js";
+import { z } from "zod";
+import { getLogger } from "@logtape/logtape";
+import { createHash, randomUUID } from "node:crypto";
+//#region src/utils/providers/grok/grok-dispatcher.ts
+const logger = getLogger(["qgrid", "grok-dispatcher"]);
+const GROK_LOOKUP_CACHE_TTL_MS = 6e4;
+const GROK_MAX_COOLDOWN_MS = 12e4;
+const GROK_DEFAULT_COOLDOWN_MS = 1e4;
+const GROK_MAX_COOLDOWN_WAIT_MS = 3e4;
+const GROK_QUOTA_BLOCK_FALLBACK_MS = 36e5;
+const GROK_ENTITLEMENT_BLOCK_MS = 36e5;
+const GROK_VERSION_GATE_REPROBE_MS = 6e5;
+const GROK_MAX_HOPS = 2;
+const GROK_MAX_REFRESHES = 1;
+const GROK_MAX_TRANSIENT_FAILOVERS = 1;
+/** A token whose pre-lookup refresh failed transiently sits out selection this long (§5.1). */
+const GROK_REFRESH_FAILED_COOLDOWN_MS = 5e3;
+/** Retries with the token's current credentials after a 401 that a newer bearer superseded. */
+const GROK_MAX_STALE_AUTH_RETRIES = 1;
+const DEFAULT_REQUEST_TIMEOUT_MS = 6e5;
+const DEFAULT_IDLE_TIMEOUT_MS = 3e5;
+var GrokInvalidRequestError = class extends Error {
+	code = "GROK_INVALID_REQUEST";
+	constructor(message) {
+		super(message);
+		this.name = "GrokInvalidRequestError";
+	}
+};
+var GrokRateLimitedError = class extends Error {
+	code = "GROK_RATE_LIMITED";
+	retryAfterSec;
+	constructor(retryAfterSec, message) {
+		super(message ?? `All grok tokens are rate limited; retry after ${retryAfterSec}s`);
+		this.name = "GrokRateLimitedError";
+		this.retryAfterSec = retryAfterSec;
+	}
+};
+var GrokCapacityError = class extends Error {
+	code = "GROK_CAPACITY";
+	constructor(message = "All grok tokens are at their in-flight request cap") {
+		super(message);
+		this.name = "GrokCapacityError";
+	}
+};
+var GrokOnDemandExcludedError = class extends Error {
+	code = "GROK_ON_DEMAND_EXCLUDED";
+	tokenNames;
+	constructor(tokenNames) {
+		super(`All grok tokens are excluded because on-demand billing is enabled: ${tokenNames.join(", ")}`);
+		this.name = "GrokOnDemandExcludedError";
+		this.tokenNames = tokenNames;
+	}
+};
+/**
+* xAI refuses video generation for Zero Data Retention accounts unless the caller supplies its own
+* `output.upload_url` (plan §11), which qgrid does not implement.
+*/
+var GrokZdrVideoUnavailableError = class extends Error {
+	code = "GROK_ZDR_VIDEO_UNAVAILABLE";
+	tokenNames;
+	constructor(tokenNames) {
+		super(`Grok video is unavailable because Zero Data Retention is on for: ${tokenNames.join(", ")}. Turn off the data-retention opt-out at xAI, or use a non-ZDR account.`);
+		this.name = "GrokZdrVideoUnavailableError";
+		this.tokenNames = tokenNames;
+	}
+};
+/** The upstream 400 body for a ZDR account on POST /v1/videos/generations. */
+const ZDR_VIDEO_REJECTION = /zero data retention/i;
+function isGrokZdrVideoRejection(error) {
+	return error.status === 400 && (ZDR_VIDEO_REJECTION.test(error.classification.message ?? "") || ZDR_VIDEO_REJECTION.test(error.bodyText));
+}
+var GrokVersionGateError = class extends Error {
+	code = "GROK_VERSION_GATE";
+	minClientVersion;
+	constructor(minClientVersion) {
+		super(`Grok chat proxy rejected client version ${GROK_BUILD_VERSION} (HTTP 426; requires ${minClientVersion ?? "a newer version"} or later). Bump GROK_BUILD_VERSION in grok-constants.ts and re-capture the golden fixture.`);
+		this.name = "GrokVersionGateError";
+		this.minClientVersion = minClientVersion;
+	}
+};
+var GrokAttemptBudgetExceededError = class extends Error {
+	code = "GROK_ATTEMPT_BUDGET_EXCEEDED";
+	constructor(attempts, cause) {
+		super(`Grok request failed after ${attempts} attempts: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+		this.name = "GrokAttemptBudgetExceededError";
+	}
+};
+var GrokNoWorkersError = class extends Error {
+	code = "NO_GROK_WORKERS";
+	constructor(message = "NO_GROK_WORKERS") {
+		super(message);
+		this.name = "GrokNoWorkersError";
+	}
+};
+var GrokCapabilityUnavailableError = class extends Error {
+	code = "GROK_CAPABILITY_UNAVAILABLE";
+	constructor(capability) {
+		super(`Grok ${capability} is not configured on this server`);
+		this.name = "GrokCapabilityUnavailableError";
+	}
+};
+/** The refresher could not produce usable credentials for a token before the request was sent. */
+var GrokCredentialRefreshError = class GrokCredentialRefreshError extends Error {
+	code = "GROK_CREDENTIAL_REFRESH";
+	reauthRequired;
+	/**
+	* `reauthRequired` defaults to the cause's convention: the port signals a dead refresh token with
+	* GrokReauthRequiredError (grok-refresh.ts), checked by name so any GrokRefresher implementation
+	* can use it.
+	*/
+	constructor(cause, reauthRequired = cause instanceof Error && cause.name === "GrokReauthRequiredError") {
+		super(`Grok credential refresh failed: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+		this.name = "GrokCredentialRefreshError";
+		this.reauthRequired = reauthRequired;
+	}
+	/** The refresher answered `reauth_required`: the refresh token is dead. */
+	static reauthRequired(reason) {
+		return new GrokCredentialRefreshError(reason, true);
+	}
+};
+var GrokIncompleteResponseError = class extends Error {
+	code = "GROK_INCOMPLETE_RESPONSE";
+	reason;
+	constructor(reason) {
+		super(`Grok response incomplete${reason ? `: ${reason}` : ""}`);
+		this.name = "GrokIncompleteResponseError";
+		this.reason = reason;
+	}
+};
+const ContentPart = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("input_text"),
+		text: z.string()
+	}),
+	z.object({
+		type: z.literal("input_image"),
+		image_url: z.string().min(1)
+	}),
+	z.object({
+		type: z.literal("output_text"),
+		text: z.string()
+	})
+]);
+const HistoryItem = z.union([
+	z.object({
+		type: z.literal("message").optional(),
+		role: z.enum(["user", "assistant"]),
+		content: z.union([z.string(), z.array(ContentPart)])
+	}),
+	z.object({
+		type: z.literal("function_call"),
+		call_id: z.string().min(1),
+		name: z.string().min(1),
+		arguments: z.string(),
+		id: z.string().optional()
+	}),
+	z.object({
+		type: z.literal("function_call_output"),
+		call_id: z.string().min(1),
+		output: z.string()
+	}),
+	z.object({
+		type: z.literal("reasoning"),
+		id: z.string().optional(),
+		summary: z.array(z.object({
+			type: z.literal("summary_text"),
+			text: z.string()
+		})).optional(),
+		encrypted_content: z.string().optional()
+	})
+]);
+function historyItems(history) {
+	return (history ?? []).map((raw, index) => {
+		const parsed = HistoryItem.safeParse(raw);
+		if (!parsed.success) throw new GrokInvalidRequestError(`Unsupported Grok history item at index ${index}`);
+		const item = parsed.data;
+		if ("role" in item) return {
+			type: "message",
+			role: item.role,
+			content: item.content
+		};
+		return item;
+	});
+}
+function userMessage(req) {
+	return {
+		type: "message",
+		role: "user",
+		content: req.coldInput.map((input) => {
+			if (input.type === "text") return {
+				type: "input_text",
+				text: input.text
+			};
+			if (input.type === "image") return {
+				type: "input_image",
+				image_url: input.url
+			};
+			if (input.type === "localImage") throw new GrokInvalidRequestError("Grok does not accept local image paths; send a data URL");
+			return {
+				type: "input_text",
+				text: `${input.name}: ${input.path}`
+			};
+		})
+	};
+}
+function grokTools(tools) {
+	if (!tools?.length) return void 0;
+	return tools.map((tool) => {
+		if (tool.type !== "function") return { type: tool.type };
+		const fn = {
+			type: "function",
+			name: tool.name,
+			parameters: tool.parameters,
+			strict: tool.strict ?? false
+		};
+		if (tool.description !== void 0) fn.description = tool.description;
+		return fn;
+	});
+}
+/** Deterministic UUID-shaped id, so one qgrid conversation maps to one Grok conversation. */
+function derivedGuid(namespace, key) {
+	const hex = createHash("sha256").update(`${namespace}\0${key}`).digest("hex");
+	const variant = (Number.parseInt(hex[16], 16) & 3 | 8).toString(16);
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-${variant}${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+}
+function grokConversationIds(promptCacheKey) {
+	const convId = promptCacheKey ? derivedGuid("grok-conv", promptCacheKey) : randomUUID();
+	return {
+		convId,
+		convGroupId: derivedGuid("grok-conv-group", convId)
+	};
+}
+/** USD from cost_in_usd_ticks, rounded to the tick resolution (1e-10). */
+function grokTicksToUsd(ticks) {
+	return Number((ticks * GROK_USD_PER_TICK).toFixed(10));
+}
+function parseMaxInflight(value) {
+	if (value === void 0 || value.trim() === "") return void 0;
+	const parsed = Number(value);
+	if (!Number.isSafeInteger(parsed) || parsed < 1) {
+		logger.warn(`ignoring QGRID_GROK_MAX_INFLIGHT_PER_TOKEN=${value}: not a positive integer`);
+		return;
+	}
+	return parsed;
+}
+function abortReason(signal) {
+	const reason = signal.reason;
+	return reason instanceof Error ? reason : new DOMException("Aborted", "AbortError");
+}
+/** Imagine calls carry the token's session id like grok-build's per-request session header. */
+function mediaAuth(credentials) {
+	return {
+		bearer: credentials.accessToken,
+		sessionId: credentials.sessionId
+	};
+}
+function defaultSleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(abortReason(signal));
+			return;
+		}
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(abortReason(signal));
+		};
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+function quotaMessage(entries) {
+	const detail = entries.map((e) => e.threshold === null ? `${e.name} (exhausted)` : `${e.name} (threshold ${e.threshold}%)`).join(", ");
+	return detail ? `All grok tokens exceeded quota threshold: ${detail}` : "All grok tokens exceeded quota threshold";
+}
+function mapRecord(map, now) {
+	return Object.fromEntries([...map].filter(([, until]) => until > now));
+}
+async function persistGrokReauth(token, reasonCode) {
+	const { deactivateAuthDeadToken } = await import("../../../application/qgrid/token-death.js");
+	return deactivateAuthDeadToken({
+		...token,
+		provider: "grok"
+	}, reasonCode);
+}
+/** Internal `grok:<code>` reason; provider text may carry account data, so only codes pass. */
+function reauthReasonCode(code) {
+	return code !== void 0 && /^[a-z_0-9]{1,80}$/.test(code) ? `grok:${code}` : "grok:unknown";
+}
+const oauthErrorCodeSchema = z.string();
+function oauthErrorOf(cause) {
+	return cause instanceof Error && "oauthError" in cause ? oauthErrorCodeSchema.safeParse(cause.oauthError).data : void 0;
+}
+/** The same bearer and refresh token: a failure judged against `b` applies to `a`. */
+function sameCredentials(a, b) {
+	return a?.accessToken === b.accessToken && a.refreshToken === b.refreshToken;
+}
+/** Names of the tokens that were ineligible for exactly `reason`. */
+function tokenNamesWithReason(reasons, reason) {
+	return [...reasons].flatMap(([token, tokenReason]) => tokenReason === reason ? [token.name] : []);
+}
+var GrokDispatcher = class {
+	tokens = /* @__PURE__ */ new Map();
+	selector = new SmoothWeightedRoundRobin();
+	refresher;
+	fetchImpl;
+	media;
+	voice;
+	now;
+	maxInflightPerToken;
+	sleep;
+	client;
+	catalog;
+	idleTimeoutMs;
+	reportReauthRequired;
+	pendingBilling = /* @__PURE__ */ new Map();
+	pendingSettings = /* @__PURE__ */ new Map();
+	pendingSubscription = /* @__PURE__ */ new Map();
+	versionGate;
+	constructor(options) {
+		this.refresher = options.refresher;
+		this.fetchImpl = options.fetch ?? fetch;
+		this.media = options.media;
+		this.voice = options.voice;
+		this.now = options.now ?? Date.now;
+		this.maxInflightPerToken = "maxInflightPerToken" in options ? options.maxInflightPerToken : parseMaxInflight(process.env.QGRID_GROK_MAX_INFLIGHT_PER_TOKEN);
+		this.sleep = options.sleep ?? defaultSleep;
+		this.client = options.client ?? new GrokChatClient({ fetch: this.fetchImpl });
+		this.catalog = options.catalog ?? new GrokModelCatalog();
+		this.idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+		this.reportReauthRequired = options.reportReauthRequired ?? persistGrokReauth;
+	}
+	async start() {
+		logger.info(`started grok runtime with ${this.tokens.size} tokens`);
+	}
+	async stop() {
+		this.tokens.clear();
+		this.pendingBilling.clear();
+		this.pendingSettings.clear();
+		this.pendingSubscription.clear();
+		for (const id of this.selector.weights.keys()) this.selector.removeToken(id);
+		this.versionGate = void 0;
+	}
+	onTokenAdded(id, name, credentials, quotaThreshold, weight) {
+		this.upsertToken(id, name, credentials, quotaThreshold, weight);
+	}
+	onTokenUpdated(id, name, credentials, quotaThreshold, weight) {
+		this.upsertToken(id, name, credentials, quotaThreshold, weight);
+	}
+	onTokenRemoved(id) {
+		this.tokens.delete(id);
+		this.selector.removeToken(id);
+		this.pendingBilling.delete(id);
+		this.pendingSettings.delete(id);
+		this.pendingSubscription.delete(id);
+	}
+	replaceTokens(rows) {
+		const ids = new Set(rows.map((row) => row.id));
+		for (const id of this.tokens.keys()) if (!ids.has(id)) this.onTokenRemoved(id);
+		for (const row of rows) this.upsertToken(row.id, row.name, row.credentials, row.quotaThreshold, row.weight);
+	}
+	upsertToken(id, name, rawCredentials, quotaThreshold, weight) {
+		const parsed = GrokCredentials.safeParse(rawCredentials);
+		let invalidReason = parsed.success ? void 0 : `invalid credentials at ${[...new Set(parsed.error.issues.map((i) => i.path.join(".") || "<root>"))].join(", ")}`;
+		if (!invalidReason && (!Number.isInteger(weight) || weight < 1 || weight > 100)) invalidReason = `invalid weight ${weight}`;
+		const credentials = parsed.success ? parsed.data : void 0;
+		const old = this.tokens.get(id);
+		if (old) {
+			const credentialsChanged = old.credentials?.accessToken !== credentials?.accessToken || old.credentials?.refreshToken !== credentials?.refreshToken;
+			const thresholdChanged = old.quotaThreshold !== quotaThreshold;
+			old.name = name;
+			old.weight = weight;
+			old.quotaThreshold = quotaThreshold;
+			old.credentials = credentials;
+			old.invalidReason = invalidReason;
+			if (credentialsChanged || thresholdChanged) {
+				old.generation++;
+				old.billing = void 0;
+				old.settings = void 0;
+				old.subscription = void 0;
+				old.overThreshold = false;
+			}
+			if (credentialsChanged) {
+				old.reauthRequired = false;
+				old.refreshFailedUntil = 0;
+				old.refreshFailure = void 0;
+				old.zdr = null;
+			}
+		} else this.tokens.set(id, {
+			id,
+			name,
+			weight,
+			quotaThreshold,
+			credentials,
+			invalidReason,
+			generation: 1,
+			inFlight: 0,
+			cooldowns: /* @__PURE__ */ new Map(),
+			quotaBlocks: /* @__PURE__ */ new Map(),
+			entitlementBlocks: /* @__PURE__ */ new Map(),
+			reauthRequired: false,
+			refreshFailedUntil: 0,
+			refreshFailure: void 0,
+			billing: void 0,
+			billingNotBefore: 0,
+			settings: void 0,
+			subscription: void 0,
+			zdr: null,
+			overThreshold: false,
+			lastTier: credentials?.subscriptionTier,
+			failoverCount: 0
+		});
+		if (invalidReason) {
+			logger.warn(`grok token ${name}[${id}] treated as inactive: ${invalidReason}`);
+			this.selector.removeToken(id);
+		} else this.selector.setToken(id, weight);
+	}
+	/**
+	* `held` counts reservations the caller already holds on `token` (re-checks mid-request).
+	* `ungated` skips the admission gates and checks only that the credentials are usable.
+	*/
+	ineligibility(token, requestClass, now, held = 0, ungated = false) {
+		if (!token.credentials || token.invalidReason) return "inactive";
+		if (token.reauthRequired) return "reauth";
+		if (token.refreshFailedUntil > now) return "refresh_failed";
+		if (ungated) return void 0;
+		const settings = token.settings?.value;
+		if (settings?.kind === "ok" && settings.onDemandEnabled === true) return "on_demand";
+		if (requestClass === "video" && token.zdr === true) return "zdr";
+		if ((token.entitlementBlocks.get(requestClass) ?? 0) > now) return "entitlement";
+		if ((token.quotaBlocks.get(requestClass) ?? 0) > now) return "quota";
+		if (token.quotaThreshold !== null && token.overThreshold) return "quota";
+		if ((token.cooldowns.get(requestClass) ?? 0) > now) return "cooldown";
+		if (this.maxInflightPerToken !== void 0 && token.inFlight - held >= this.maxInflightPerToken) return "capacity";
+	}
+	isEligible(token, requestClass) {
+		return this.ineligibility(token, requestClass, this.now()) === void 0;
+	}
+	/**
+	* Refreshes the 60 s settings/subscription/billing caches. Lookup failures fail open, so an
+	* expired bearer is refreshed first: a lookup with it would fail and open every gate. A failed
+	* refresh therefore takes the token out of selection (`refresh_failed`) instead of failing open.
+	*/
+	async prefetch(token, signal) {
+		if (!token.credentials || token.invalidReason || token.reauthRequired) return;
+		let now = this.now();
+		const tasks = [];
+		const stale = (entry) => !entry || entry.generation !== token.generation || now - entry.fetchedAt >= 6e4;
+		const billingDue = () => (token.quotaThreshold !== null || [...token.quotaBlocks.values()].some((u) => u > now)) && stale(token.billing) && now >= token.billingNotBefore;
+		if (!stale(token.settings) && !stale(token.subscription) && !billingDue()) return;
+		if (grokNeedsRefresh(token.credentials, now)) {
+			if (token.refreshFailedUntil > now) return;
+			const presented = token.credentials;
+			try {
+				await this.freshCredentials(token, signal ?? new AbortController().signal);
+			} catch (error) {
+				if (signal?.aborted) return;
+				if (error instanceof Error && error.name === "GrokReauthRequiredError") this.markReauthRequired(token, presented, reauthReasonCode(oauthErrorOf(error)));
+				else this.markRefreshFailed(token, presented, error);
+				return;
+			}
+			if (!token.credentials || token.reauthRequired || this.tokens.get(token.id) !== token) return;
+			now = this.now();
+		}
+		if (stale(token.settings)) tasks.push(this.loadSettings(token));
+		if (stale(token.subscription)) tasks.push(this.loadSubscription(token));
+		const blocked = [...token.quotaBlocks.values()].some((until) => until > now);
+		if ((token.quotaThreshold !== null || blocked) && stale(token.billing)) {
+			if (now >= token.billingNotBefore) tasks.push(this.loadBilling(token));
+		}
+		await Promise.all(tasks);
+	}
+	/** Transient refresh failure for `presented`; ignored when the token already holds newer ones. */
+	markRefreshFailed(token, presented, cause) {
+		if (this.tokens.get(token.id) !== token || !sameCredentials(token.credentials, presented)) return;
+		token.refreshFailedUntil = this.now() + GROK_REFRESH_FAILED_COOLDOWN_MS;
+		token.refreshFailure = cause;
+		logger.warn(`grok token ${token.name}[${token.id}] refresh failed; out of selection for ${GROK_REFRESH_FAILED_COOLDOWN_MS}ms: ${cause instanceof Error ? cause.name : "unknown"}`);
+	}
+	loadSettings(token) {
+		const pending = this.pendingSettings.get(token.id);
+		if (pending) return pending;
+		const generation = token.generation;
+		const credentials = token.credentials;
+		const promise = readGrokSettings(credentials, { fetch: this.fetchImpl }).then((result) => {
+			if (this.tokens.get(token.id) !== token || token.generation !== generation) return;
+			token.settings = {
+				value: result,
+				fetchedAt: this.now(),
+				generation
+			};
+			if (result.kind === "lookup_failed") {
+				logger.warn("quota_threshold gate: settings_lookup_fail_open", {
+					tokenId: token.id,
+					tokenName: token.name,
+					lookupReason: result.reason
+				});
+				return;
+			}
+			if (result.subscriptionTierDisplay) token.lastTier = result.subscriptionTierDisplay;
+			if (result.onDemandEnabled === true) logger.info(`quota_threshold gate: on_demand_excluded ${token.name}[${token.id}] (on_demand_enabled=true)`);
+		}).finally(() => {
+			if (this.pendingSettings.get(token.id) === promise) this.pendingSettings.delete(token.id);
+		});
+		this.pendingSettings.set(token.id, promise);
+		return promise;
+	}
+	/** /user codingDataRetentionOptOut is the primary ZDR signal; a failed read keeps the last value. */
+	loadSubscription(token) {
+		const pending = this.pendingSubscription.get(token.id);
+		if (pending) return pending;
+		const generation = token.generation;
+		const credentials = token.credentials;
+		const promise = readGrokSubscription(credentials, { fetch: this.fetchImpl }).then((result) => {
+			if (this.tokens.get(token.id) !== token || token.generation !== generation) return;
+			token.subscription = {
+				value: result,
+				fetchedAt: this.now(),
+				generation
+			};
+			if (result.kind === "lookup_failed") {
+				logger.debug(`grok subscription lookup failed for ${token.name}[${token.id}]`, { lookupReason: result.reason });
+				return;
+			}
+			if (result.dataRetentionOptOut !== null) this.setZdr(token, result.dataRetentionOptOut, "codingDataRetentionOptOut");
+		}).finally(() => {
+			if (this.pendingSubscription.get(token.id) === promise) this.pendingSubscription.delete(token.id);
+		});
+		this.pendingSubscription.set(token.id, promise);
+		return promise;
+	}
+	setZdr(token, zdr, source) {
+		if (this.tokens.get(token.id) !== token || token.zdr === zdr) return;
+		token.zdr = zdr;
+		logger.info(zdr ? `grok token ${token.name}[${token.id}] excluded from video: zero data retention (${source})` : `grok token ${token.name}[${token.id}] video eligible: zero data retention off (${source})`);
+	}
+	/** `x-zero-data-retention: true` confirms ZDR; its absence never clears it (next /user read does). */
+	observeResponseHeaders(token, credentials, headers) {
+		if (token.credentials?.accessToken !== credentials.accessToken) return;
+		if (headers.zeroDataRetention === true) this.setZdr(token, true, "x-zero-data-retention");
+	}
+	loadBilling(token) {
+		const pending = this.pendingBilling.get(token.id);
+		if (pending) return pending;
+		const generation = token.generation;
+		const credentials = token.credentials;
+		const promise = readGrokBilling(credentials, { fetch: this.fetchImpl }).then((result) => {
+			if (this.tokens.get(token.id) !== token || token.generation !== generation) return;
+			token.billing = {
+				value: result,
+				fetchedAt: this.now(),
+				generation
+			};
+			if (result.kind === "lookup_failed") {
+				token.overThreshold = false;
+				logger.warn("quota_threshold gate: lookup_fail_open", {
+					tokenId: token.id,
+					tokenName: token.name,
+					lookupReason: result.reason
+				});
+				return;
+			}
+			const limit = token.quotaThreshold ?? 100;
+			const over = token.quotaThreshold !== null && result.utilizationPct >= token.quotaThreshold;
+			if (over && !token.overThreshold) logger.info(`quota_threshold gate: over_threshold ${token.name}[${token.id}] (${result.utilizationPct}% >= ${token.quotaThreshold}%)`);
+			if (!over && token.overThreshold) logger.info(`quota_threshold gate: recovered ${token.name}[${token.id}] (${result.utilizationPct}% < ${token.quotaThreshold}%)`);
+			token.overThreshold = over;
+			if (result.utilizationPct < limit && token.quotaBlocks.size) {
+				token.quotaBlocks.clear();
+				logger.info(`quota_threshold gate: exhaustion_cleared ${token.name}[${token.id}] (${result.utilizationPct}% < ${limit}%)`);
+			}
+		}).finally(() => {
+			if (this.pendingBilling.get(token.id) === promise) this.pendingBilling.delete(token.id);
+		});
+		this.pendingBilling.set(token.id, promise);
+		return promise;
+	}
+	reserve(token) {
+		token.inFlight++;
+		let released = false;
+		return {
+			token,
+			release: () => {
+				if (released) return;
+				released = true;
+				token.inFlight = Math.max(0, token.inFlight - 1);
+			}
+		};
+	}
+	checkVersionGate(requestClass) {
+		if (requestClass !== "chat" || !this.versionGate) return;
+		if (this.now() - this.versionGate.trippedAt < 6e5) throw new GrokVersionGateError(this.versionGate.minClientVersion);
+	}
+	async selectToken(requestClass, options = {}) {
+		this.checkVersionGate(requestClass);
+		const excluded = options.excluded ?? /* @__PURE__ */ new Set();
+		if (options.preferredTokenId !== void 0) {
+			const preferred = this.tokens.get(options.preferredTokenId);
+			if (preferred && !excluded.has(preferred.id)) for (let round = 0;; round++) {
+				await this.prefetch(preferred, options.signal);
+				options.signal?.throwIfAborted();
+				const now = this.now();
+				const reason = this.ineligibility(preferred, requestClass, now, 0, options.ungated);
+				if (!reason) return this.reserve(preferred);
+				if (!options.requirePreferredToken) break;
+				const waitMs = preferred.refreshFailedUntil - now;
+				if (reason === "refresh_failed" && round === 0 && waitMs <= 3e4 && (options.deadline === void 0 || now + waitMs < options.deadline)) {
+					await this.sleep(Math.max(0, waitMs), options.signal);
+					continue;
+				}
+				throw this.preferredError(preferred, reason);
+			}
+			else if (options.requirePreferredToken) throw new GrokNoWorkersError(`Preferred grok token ${options.preferredTokenId} is not available`);
+		}
+		for (let round = 0;; round++) {
+			const candidates = [...this.tokens.values()].filter((token) => !excluded.has(token.id));
+			await Promise.all(candidates.map((token) => this.prefetch(token, options.signal)));
+			options.signal?.throwIfAborted();
+			const now = this.now();
+			const reasons = /* @__PURE__ */ new Map();
+			const eligible = /* @__PURE__ */ new Set();
+			for (const token of candidates) {
+				const reason = this.ineligibility(token, requestClass, now);
+				if (reason) reasons.set(token, reason);
+				else eligible.add(token.id);
+			}
+			if (eligible.size) {
+				const selected = this.selector.select(eligible);
+				const token = selected === null ? void 0 : this.tokens.get(selected);
+				if (token) return this.reserve(token);
+			}
+			const present = new Set(reasons.values());
+			if (present.has("capacity")) throw new GrokCapacityError();
+			if (present.has("cooldown") || present.has("refresh_failed")) {
+				const until = (token, reason) => reason === "cooldown" ? token.cooldowns.get(requestClass) ?? now : reason === "refresh_failed" ? token.refreshFailedUntil : Number.POSITIVE_INFINITY;
+				const soonest = Math.min(...[...reasons].map(([token, reason]) => until(token, reason)));
+				const waitMs = Math.max(0, Math.min(soonest - now, GROK_MAX_COOLDOWN_WAIT_MS));
+				const withinDeadline = options.deadline === void 0 || now + waitMs < options.deadline;
+				if (round === 0 && withinDeadline) {
+					await this.sleep(waitMs, options.signal);
+					continue;
+				}
+				const cooling = [...reasons].filter(([, reason]) => reason === "cooldown");
+				if (cooling.length) {
+					const soonestCooldown = Math.min(...cooling.map(([token]) => until(token, "cooldown")));
+					throw new GrokRateLimitedError(Math.max(1, Math.ceil((soonestCooldown - now) / 1e3)));
+				}
+				throw new GrokCredentialRefreshError([...reasons].find(([, reason]) => reason === "refresh_failed")?.[0].refreshFailure ?? "refresh failed", false);
+			}
+			if (present.has("quota")) {
+				const over = [...reasons].flatMap(([token, reason]) => reason === "quota" ? [{
+					name: token.name,
+					threshold: token.overThreshold ? token.quotaThreshold : null
+				}] : []);
+				logger.warn("quota_threshold gate: all_exceeded", {
+					provider: "grok",
+					overThresholdTokens: over
+				});
+				throw new QuotaThresholdExceededError(quotaMessage(over));
+			}
+			if (present.has("on_demand")) throw new GrokOnDemandExcludedError(tokenNamesWithReason(reasons, "on_demand"));
+			if (present.has("zdr")) throw new GrokZdrVideoUnavailableError(tokenNamesWithReason(reasons, "zdr"));
+			throw new GrokNoWorkersError();
+		}
+	}
+	preferredError(token, reason) {
+		const now = this.now();
+		if (reason === "quota") return new QuotaThresholdExceededError(quotaMessage([{
+			name: token.name,
+			threshold: token.overThreshold ? token.quotaThreshold : null
+		}]));
+		if (reason === "cooldown") {
+			const until = Math.max(...token.cooldowns.values());
+			return new GrokRateLimitedError(Math.max(1, Math.ceil((until - now) / 1e3)));
+		}
+		if (reason === "capacity") return new GrokCapacityError();
+		if (reason === "refresh_failed") return new GrokCredentialRefreshError(token.refreshFailure ?? "refresh failed", false);
+		if (reason === "on_demand") return new GrokOnDemandExcludedError([token.name]);
+		if (reason === "zdr") return new GrokZdrVideoUnavailableError([token.name]);
+		return new GrokNoWorkersError(`Preferred grok token ${token.id} is not available (${reason})`);
+	}
+	applyHttpFailure(token, requestClass, error) {
+		const now = this.now();
+		const { classification } = error;
+		if (classification.kind === "rate_limited") {
+			const cooldownMs = Math.min(classification.retryAfterSec === void 0 ? GROK_DEFAULT_COOLDOWN_MS : classification.retryAfterSec * 1e3, GROK_MAX_COOLDOWN_MS);
+			token.cooldowns.set(requestClass, now + cooldownMs);
+			logger.info(`grok token ${token.name}[${token.id}] cooldown ${cooldownMs}ms (${requestClass})`);
+		} else if (classification.kind === "quota_exhausted") {
+			const billing = token.billing?.value;
+			const periodEnd = billing?.kind === "ok" ? billing.periodEndMs : null;
+			const until = periodEnd !== null && periodEnd > now ? periodEnd : now + GROK_QUOTA_BLOCK_FALLBACK_MS;
+			token.quotaBlocks.set(requestClass, until);
+			token.billing = void 0;
+			token.billingNotBefore = now + GROK_LOOKUP_CACHE_TTL_MS;
+			logger.info(`quota_threshold gate: exhausted ${token.name}[${token.id}] until ${new Date(until).toISOString()} (${classification.code ?? "429"})`);
+		} else if (classification.kind === "entitlement" && requestClass !== "chat") token.entitlementBlocks.set(requestClass, now + GROK_ENTITLEMENT_BLOCK_MS);
+		else if (classification.kind === "version_gate" && requestClass === "chat") {
+			this.versionGate = {
+				trippedAt: now,
+				minClientVersion: classification.minClientVersion
+			};
+			logger.error(`grok chat proxy version gate tripped: ${GROK_BUILD_VERSION} < ${classification.minClientVersion ?? "?"}`);
+		}
+	}
+	classifyFailure(token, requestClass, cause, presented, refreshedThisRequest, refreshBudgetLeft) {
+		if (cause instanceof GrokIdleTimeoutError) return requestClass === "chat" ? {
+			kind: "failover",
+			error: cause,
+			transient: true
+		} : {
+			kind: "fail",
+			error: cause
+		};
+		if (cause instanceof GrokCredentialRefreshError) {
+			if (presented) if (cause.reauthRequired) this.markReauthRequired(token, presented, reauthReasonCode(oauthErrorOf(cause.cause)));
+			else this.markRefreshFailed(token, presented, cause.cause);
+			return {
+				kind: "failover",
+				error: cause,
+				transient: false
+			};
+		}
+		if (!(cause instanceof GrokHttpError)) return {
+			kind: "fail",
+			error: cause
+		};
+		if (requestClass === "video" && isGrokZdrVideoRejection(cause)) {
+			this.setZdr(token, true, "upstream video 400");
+			token.entitlementBlocks.set("video", this.now() + GROK_ENTITLEMENT_BLOCK_MS);
+			return {
+				kind: "failover",
+				error: cause,
+				transient: false
+			};
+		}
+		this.applyHttpFailure(token, requestClass, cause);
+		const { classification } = cause;
+		if (classification.kind === "version_gate") return {
+			kind: "fail",
+			error: new GrokVersionGateError(classification.minClientVersion)
+		};
+		if (classification.shouldRetry === false) return {
+			kind: "fail",
+			error: cause
+		};
+		switch (classification.kind) {
+			case "auth":
+				if (!presented || !token.credentials) return {
+					kind: "failover",
+					error: cause,
+					transient: false
+				};
+				if (token.credentials.accessToken !== presented.accessToken) return {
+					kind: "retry",
+					error: cause
+				};
+				if (refreshedThisRequest) {
+					this.markReauthRequired(token, presented, "grok:unauthorized_after_refresh");
+					return {
+						kind: "failover",
+						error: cause,
+						transient: false
+					};
+				}
+				if (refreshBudgetLeft) return {
+					kind: "refresh",
+					presented
+				};
+				return {
+					kind: "failover",
+					error: cause,
+					transient: false
+				};
+			case "rate_limited":
+			case "quota_exhausted": return {
+				kind: "failover",
+				error: cause,
+				transient: false
+			};
+			case "entitlement": return requestClass === "chat" ? {
+				kind: "fail",
+				error: cause
+			} : {
+				kind: "failover",
+				error: cause,
+				transient: false
+			};
+			case "transient":
+				if (requestClass === "chat") return {
+					kind: "failover",
+					error: cause,
+					transient: true
+				};
+				return cause.status === 0 ? {
+					kind: "failover",
+					error: cause,
+					transient: true
+				} : {
+					kind: "fail",
+					error: cause
+				};
+			default: return {
+				kind: "fail",
+				error: cause
+			};
+		}
+	}
+	/**
+	* Marks `token` dead in memory and, on the first transition, persists `tokens.reauth_required`.
+	* `credentials` are the ones the failed attempt presented; a token already holding newer ones
+	* (another bearer or refresh token) is left alone.
+	*/
+	markReauthRequired(token, credentials, reasonCode) {
+		if (this.tokens.get(token.id) !== token) return;
+		if (!sameCredentials(token.credentials, credentials)) return;
+		if (token.reauthRequired) return;
+		token.reauthRequired = true;
+		logger.warn(`grok token ${token.name}[${token.id}] requires re-authentication (${reasonCode})`);
+		this.reportReauthRequired({
+			id: token.id,
+			name: token.name,
+			credentials
+		}, reasonCode).catch((cause) => {
+			logger.warn(`grok token ${token.name}[${token.id}] reauth_required persist failed: ${cause instanceof Error ? cause.name : "unknown"}`);
+		});
+	}
+	/**
+	* Runs `attempt` with the §5.1 attempt budget: one forced refresh, at most GROK_MAX_HOPS
+	* failovers (one of them transient). `canRetry` reports whether upstream execution may have
+	* started, in which case nothing is retried.
+	*
+	* The reservation is held from selection until the request leaves the token (failover) or ends,
+	* so a refresh and its same-token retry never step outside the in-flight cap. Whenever the
+	* attempt is about to present credentials other than the ones the token's gates were evaluated
+	* with (a refresh happened), the lookups and gates are re-run before anything is sent.
+	*/
+	async withAttempts(requestClass, selection, attempt) {
+		const excluded = /* @__PURE__ */ new Set();
+		const refreshed = /* @__PURE__ */ new Set();
+		let refreshes = 0;
+		let hops = 0;
+		let transientFailovers = 0;
+		let attempts = 0;
+		let staleRetries = 0;
+		let reservation = await this.selectToken(requestClass, {
+			...selection,
+			excluded
+		});
+		let gated = reservation.token.credentials;
+		try {
+			for (;;) {
+				const token = reservation.token;
+				const state = {
+					upstreamStarted: false,
+					forwarded: false,
+					presented: token.credentials
+				};
+				let action;
+				attempts++;
+				try {
+					let credentials;
+					try {
+						credentials = await this.freshCredentials(token, selection.signal);
+					} catch (error) {
+						if (selection.signal.aborted) throw error;
+						throw new GrokCredentialRefreshError(error);
+					}
+					state.presented = credentials;
+					const blocked = credentials.accessToken === gated?.accessToken ? void 0 : await this.regate(token, requestClass, selection.signal, selection.ungated);
+					gated = credentials;
+					if (blocked) action = {
+						kind: "failover",
+						error: blocked,
+						transient: false
+					};
+					else return await attempt(token, credentials, state);
+				} catch (error) {
+					if (selection.signal.aborted) throw abortReason(selection.signal);
+					if (state.forwarded || state.upstreamStarted) throw error;
+					action = this.classifyFailure(token, requestClass, error, state.presented, refreshed.has(token.id), refreshes < 1);
+				}
+				if (action.kind === "fail") throw action.error;
+				if (action.kind === "retry") {
+					if (staleRetries++ < 1) continue;
+					excluded.add(token.id);
+					action = {
+						kind: "failover",
+						error: action.error,
+						transient: false
+					};
+				}
+				if (action.kind === "refresh") {
+					refreshes++;
+					refreshed.add(token.id);
+					const next = await this.tryRefresh(token, action.presented, selection.signal);
+					if (next.kind === "refreshed") continue;
+					action = {
+						kind: "failover",
+						error: next.error,
+						transient: false
+					};
+				}
+				if (selection.requirePreferredToken) throw action.error;
+				if (action.transient && ++transientFailovers > 1) throw action.error;
+				if (++hops > 2) throw new GrokAttemptBudgetExceededError(attempts, action.error);
+				if (action.transient || action.error instanceof GrokCredentialRefreshError) excluded.add(token.id);
+				token.failoverCount++;
+				logger.info(`grok failover from ${token.name}[${token.id}] (${requestClass})`, { reason: action.error instanceof Error ? action.error.message : String(action.error) });
+				reservation.release();
+				try {
+					reservation = await this.selectToken(requestClass, {
+						excluded,
+						signal: selection.signal,
+						deadline: selection.deadline
+					});
+				} catch (selectionError) {
+					if (selectionError instanceof GrokNoWorkersError) throw action.error;
+					throw selectionError;
+				}
+				gated = reservation.token.credentials;
+			}
+		} finally {
+			reservation.release();
+		}
+	}
+	/**
+	* Re-runs the lookups and gates for a token whose credentials changed after selection. Returns
+	* the gate's error when the token is no longer eligible; the caller still holds one reservation.
+	*/
+	async regate(token, requestClass, signal, ungated) {
+		await this.prefetch(token, signal);
+		signal.throwIfAborted();
+		const reason = this.ineligibility(token, requestClass, this.now(), 1, ungated);
+		return reason ? this.preferredError(token, reason) : void 0;
+	}
+	/**
+	* The one forced refresh after an upstream 401. A refreshed token is retried; otherwise the
+	* request fails over. Only a `reauth_required` answer marks the token dead — a thrown refresh
+	* failure is treated as transient and leaves the token alive.
+	*/
+	async tryRefresh(token, presented, signal) {
+		let result;
+		try {
+			result = await this.refresher.refreshAfterUnauthorized({
+				tokenId: token.id,
+				credentials: presented
+			}, signal);
+		} catch (error) {
+			if (signal.aborted) throw abortReason(signal);
+			return {
+				kind: "failover",
+				error: new GrokCredentialRefreshError(error)
+			};
+		}
+		if (result.status === "refreshed") {
+			this.storeCredentials(token, result.credentials);
+			return { kind: "refreshed" };
+		}
+		this.markReauthRequired(token, presented, reauthReasonCode(result.reason));
+		return {
+			kind: "failover",
+			error: GrokCredentialRefreshError.reauthRequired(result.reason)
+		};
+	}
+	async freshCredentials(token, signal) {
+		const current = token.credentials;
+		if (!current) throw new GrokNoWorkersError(`grok token ${token.id} has no valid credentials`);
+		const fresh = await this.refresher.ensureFresh({
+			tokenId: token.id,
+			credentials: current
+		}, signal);
+		this.storeCredentials(token, fresh);
+		return fresh;
+	}
+	storeCredentials(token, credentials) {
+		if (this.tokens.get(token.id) !== token) return;
+		if (token.credentials?.accessToken === credentials.accessToken) return;
+		token.credentials = credentials;
+		token.reauthRequired = false;
+		token.generation++;
+		this.pendingBilling.delete(token.id);
+		this.pendingSettings.delete(token.id);
+		this.pendingSubscription.delete(token.id);
+	}
+	async generate(req) {
+		return this.runChat(req);
+	}
+	async generateStream(req, cb) {
+		try {
+			cb.onComplete(await this.runChat(req, cb.onDelta));
+		} catch (error) {
+			cb.onError(error instanceof Error ? error : new Error(String(error)));
+			throw error;
+		}
+	}
+	buildChatBody(req) {
+		if (req.imageGeneration !== void 0 && req.imageGeneration !== false) throw new GrokInvalidRequestError("imageGeneration is not supported on grok chat models; use the Grok image endpoint");
+		if (req.imageGenerationOptions !== void 0) throw new GrokInvalidRequestError("imageGenerationOptions is not supported on grok chat models");
+		if (req.serviceTier !== void 0) throw new GrokInvalidRequestError("serviceTier is not supported on grok chat models");
+		const xai = req.providerOptions?.xai;
+		if (isJsonObject(xai)) {
+			for (const key of ["serviceTier", "parallelToolCalls"]) if (xai[key] !== void 0 && xai[key] !== null) throw new GrokInvalidRequestError(`providerOptions.xai.${key} is not supported on grok chat models: the subscription proxy's handling is unverified`);
+		}
+		if (req.thinking === false) throw new ThinkingValidationError("thinking:false is unavailable for Grok models: thinking-off support has not been verified on the subscription proxy");
+		const model = this.catalog.resolve(req.model);
+		if (!model.known) logger.info(`grok model "${model.id}" is not in the catalog; forwarding it unvalidated`);
+		let effort = model.defaultEffort;
+		if (req.effort !== void 0) {
+			const validated = this.catalog.validateEffort(model.id, req.effort);
+			if (validated) effort = validated;
+			else logger.debug(`ignoring effort "${req.effort}" for grok/${model.id}`);
+		}
+		const history = historyItems(req.coldHistory);
+		const { convId, convGroupId } = grokConversationIds(req.promptCacheKey);
+		const turnIdx = history.filter((item) => item.type === "message" && item.role === "user").length + 1;
+		const tools = grokTools(req.tools);
+		return {
+			body: buildGrokResponsesRequest({
+				model: model.id,
+				systemPrompt: req.systemPrompt,
+				history: [...history, userMessage(req)],
+				promptCacheKey: convId,
+				effort,
+				outputSchema: req.outputSchema === void 0 ? void 0 : { schema: req.outputSchema },
+				tools
+			}),
+			model,
+			convId,
+			convGroupId,
+			turnIdx
+		};
+	}
+	async runChat(req, onDelta) {
+		const { body, model, convId, convGroupId, turnIdx } = this.buildChatBody(req);
+		const timeoutMs = req.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+		const timeout = AbortSignal.timeout(timeoutMs);
+		const signal = req.abortSignal ? AbortSignal.any([req.abortSignal, timeout]) : timeout;
+		signal.throwIfAborted();
+		const deadline = this.now() + timeoutMs;
+		return this.withAttempts("chat", {
+			preferredTokenId: req.preferredTokenId,
+			requirePreferredToken: req.requirePreferredToken,
+			signal,
+			deadline
+		}, (token, credentials, state) => this.chatAttempt(token, credentials, state, {
+			req,
+			body,
+			model,
+			convId,
+			convGroupId,
+			turnIdx,
+			signal,
+			onDelta
+		}));
+	}
+	async chatAttempt(token, credentials, state, context) {
+		const { req, model } = context;
+		const startedAt = this.now();
+		const headers = buildGrokChatHeaders({
+			bearer: credentials.accessToken,
+			model: model.id,
+			convId: context.convId,
+			reqId: randomUUID(),
+			sessionId: credentials.sessionId,
+			agentId: credentials.agentId,
+			userId: credentials.userId,
+			convGroupId: context.convGroupId,
+			turnIdx: context.turnIdx,
+			zstd: true
+		});
+		let stream;
+		try {
+			stream = await this.client.stream({
+				body: context.body,
+				headers,
+				signal: context.signal,
+				idleTimeoutMs: this.idleTimeoutMs
+			});
+		} catch (error) {
+			if (error instanceof GrokHttpError) this.observeResponseHeaders(token, credentials, error.responseHeaders);
+			throw error;
+		}
+		this.observeResponseHeaders(token, credentials, stream.headers);
+		this.versionGate = void 0;
+		if (this.catalog.isStale(stream.headers.modelsEtag)) this.catalog.refresh(credentials, { fetch: this.fetchImpl }).then((result) => {
+			if (result.kind === "lookup_failed") logger.warn(`grok model catalog refresh failed: ${result.reason}`);
+		});
+		let text = "";
+		let firstDeltaAt;
+		let usage;
+		let servingModel = model.id;
+		let outputMessageAccepted = false;
+		const toolCalls = [];
+		let completed = false;
+		for await (const event of stream.events) {
+			state.upstreamStarted = true;
+			if (event.type === "created") {
+				if (event.model) servingModel = event.model;
+			} else if (event.type === "text-delta") {
+				if (outputMessageAccepted) continue;
+				firstDeltaAt ??= this.now();
+				text += event.text;
+				if (context.onDelta) {
+					state.forwarded = true;
+					context.onDelta(event.text);
+				}
+			} else if (event.type === "output-item" && event.completed) {
+				const item = event.item;
+				if (item.type === "function_call") {
+					const callId = jsonString(item.call_id);
+					const name = jsonString(item.name);
+					const args = jsonString(item.arguments);
+					if (callId !== void 0 && name !== void 0 && args !== void 0) toolCalls.push({
+						toolCallId: callId,
+						toolName: name,
+						input: args
+					});
+				} else if (item.type === "message" && req.stopAfterOutputMessage && !outputMessageAccepted && Array.isArray(item.content)) {
+					const messageText = item.content.map((part) => isJsonObject(part) && part.type === "output_text" ? jsonString(part.text) ?? "" : "").join("");
+					if (messageText) outputMessageAccepted = req.stopAfterOutputMessage(messageText);
+				}
+			} else if (event.type === "completed") {
+				completed = true;
+				if (event.model) servingModel = event.model;
+				usage = event.usage;
+			} else if (event.type === "incomplete") throw new GrokIncompleteResponseError(event.reason);
+			else if (event.type === "error") throw event.error;
+		}
+		if (!completed) throw new GrokIncompleteResponseError("stream ended without response.completed");
+		const ticks = usage?.costInUsdTicks;
+		const contextTokens = usage?.contextInputTokens === void 0 && usage?.contextOutputTokens === void 0 ? void 0 : (usage.contextInputTokens ?? 0) + (usage.contextOutputTokens ?? 0);
+		const contextWindow = stream.headers.contextWindow ?? model.contextWindow;
+		const resultUsage = {
+			totalTokens: usage?.totalTokens ?? 0,
+			inputTokens: usage?.inputTokens ?? 0,
+			cachedInputTokens: usage?.cachedInputTokens ?? 0,
+			outputTokens: usage?.outputTokens ?? 0,
+			reasoningOutputTokens: usage?.reasoningTokens ?? 0
+		};
+		if (contextTokens !== void 0) resultUsage.contextTokens = contextTokens;
+		const xai = {};
+		if (ticks !== void 0) xai.costInUsdTicks = ticks;
+		if (contextWindow !== void 0) xai.contextWindow = contextWindow;
+		const result = {
+			text,
+			tokenName: token.name,
+			usage: resultUsage,
+			durationMs: this.now() - startedAt,
+			ttftMs: firstDeltaAt === void 0 ? null : firstDeltaAt - startedAt,
+			model: servingModel,
+			threadCoord: {
+				workerId: token.id,
+				threadId: req.promptCacheKey ?? "",
+				epoch: -1
+			},
+			providerMetadata: { xai }
+		};
+		if (servingModel !== model.id) result.requestedModel = model.id;
+		if (ticks !== void 0) {
+			result.costUsd = grokTicksToUsd(ticks);
+			result.costSource = "provider";
+		}
+		if (toolCalls.length) result.toolCalls = toolCalls;
+		return result;
+	}
+	async runPort(requestClass, selection, signal, call) {
+		const active = signal ?? new AbortController().signal;
+		return this.withAttempts(requestClass, {
+			preferredTokenId: selection.preferredTokenId,
+			requirePreferredToken: selection.requirePreferredToken,
+			ungated: selection.ungated,
+			signal: active
+		}, async (token, credentials) => ({
+			result: await call(credentials),
+			tokenId: token.id,
+			tokenName: token.name
+		}));
+	}
+	requireMedia() {
+		if (!this.media) throw new GrokCapabilityUnavailableError("media");
+		return this.media;
+	}
+	requireVoice() {
+		if (!this.voice) throw new GrokCapabilityUnavailableError("voice");
+		return this.voice;
+	}
+	async generateImages(request) {
+		const media = this.requireMedia();
+		const { preferredTokenId, requirePreferredToken, ...portRequest } = request;
+		return this.runPort("image", {
+			preferredTokenId,
+			requirePreferredToken
+		}, request.signal, (credentials) => media.generateImages(mediaAuth(credentials), portRequest));
+	}
+	async editImages(request) {
+		const media = this.requireMedia();
+		const { preferredTokenId, requirePreferredToken, ...portRequest } = request;
+		return this.runPort("image", {
+			preferredTokenId,
+			requirePreferredToken
+		}, request.signal, (credentials) => media.editImages(mediaAuth(credentials), portRequest));
+	}
+	async startVideo(request) {
+		const media = this.requireMedia();
+		const { preferredTokenId, requirePreferredToken, ...portRequest } = request;
+		return this.runPort("video", {
+			preferredTokenId,
+			requirePreferredToken
+		}, request.signal, (credentials) => media.startVideo(mediaAuth(credentials), portRequest));
+	}
+	/**
+	* Polls on the token that started the job; no selection, no failover. The job is already
+	* admitted (and billed), so quota, cooldown and capacity gates must not strand its result.
+	*/
+	async getVideo(tokenId, requestId, signal) {
+		const media = this.requireMedia();
+		return this.runPort("video", {
+			preferredTokenId: tokenId,
+			requirePreferredToken: true,
+			ungated: true
+		}, signal, (credentials) => media.getVideo(mediaAuth(credentials), requestId, signal));
+	}
+	async transcribe(request) {
+		const voice = this.requireVoice();
+		const { preferredTokenId, requirePreferredToken, ...portRequest } = request;
+		return this.runPort("stt", {
+			preferredTokenId,
+			requirePreferredToken
+		}, request.signal, (credentials) => voice.transcribe(credentials.accessToken, portRequest));
+	}
+	async speak(request) {
+		const voice = this.requireVoice();
+		const { preferredTokenId, requirePreferredToken, ...portRequest } = request;
+		return this.runPort("tts", {
+			preferredTokenId,
+			requirePreferredToken
+		}, request.signal, (credentials) => voice.speak(credentials.accessToken, portRequest));
+	}
+	tokenStates() {
+		const now = this.now();
+		return [...this.tokens.values()].map((token) => {
+			const billing = token.billing?.value;
+			const settings = token.settings?.value;
+			return {
+				id: token.id,
+				name: token.name,
+				weight: token.weight,
+				active: token.credentials !== void 0 && token.invalidReason === void 0,
+				invalidReason: token.invalidReason ?? null,
+				inFlight: token.inFlight,
+				cooldownUntil: mapRecord(token.cooldowns, now),
+				quotaBlockedUntil: mapRecord(token.quotaBlocks, now),
+				entitlementBlocks: mapRecord(token.entitlementBlocks, now),
+				lastBilling: billing?.kind === "ok" ? {
+					utilizationPct: billing.utilizationPct,
+					periodType: billing.periodType,
+					periodEnd: billing.periodEnd,
+					fetchedAt: token.billing.fetchedAt
+				} : null,
+				quotaThreshold: token.quotaThreshold,
+				overThreshold: token.overThreshold,
+				onDemandExcluded: settings?.kind === "ok" && settings.onDemandEnabled === true,
+				zdrVideoExcluded: token.zdr === true,
+				lastTier: token.lastTier ?? null,
+				reauthRequired: token.reauthRequired,
+				failoverCount: token.failoverCount
+			};
+		}).toSorted((a, b) => a.name.localeCompare(b.name));
+	}
+	/** Chat-proxy version gate state for the usage endpoint. */
+	versionGateState() {
+		return {
+			tripped: this.versionGate !== void 0,
+			minClientVersion: this.versionGate?.minClientVersion ?? null,
+			trippedAt: this.versionGate?.trippedAt ?? null
+		};
+	}
+	/** Same shape as OpenAIDispatcher.getQuotaSnapshot; reads caches only. */
+	getQuotaSnapshot() {
+		const now = this.now();
+		return [...this.tokens.values()].map((token) => {
+			const billing = token.billing?.value;
+			const fresh = billing?.kind === "ok" && token.billing.generation === token.generation && now - token.billing.fetchedAt < 6e4;
+			return {
+				name: token.name,
+				usedPercent: fresh ? billing.utilizationPct : null,
+				threshold: token.quotaThreshold,
+				blocked: token.overThreshold || [...token.quotaBlocks.values()].some((until) => until > now),
+				resetsAt: fresh ? billing.periodEndMs : null,
+				zdrVideoExcluded: token.zdr === true
+			};
+		}).toSorted((a, b) => a.name.localeCompare(b.name));
+	}
+};
+//#endregion
+export { GROK_DEFAULT_COOLDOWN_MS, GROK_ENTITLEMENT_BLOCK_MS, GROK_LOOKUP_CACHE_TTL_MS, GROK_MAX_COOLDOWN_MS, GROK_MAX_COOLDOWN_WAIT_MS, GROK_MAX_HOPS, GROK_MAX_REFRESHES, GROK_MAX_STALE_AUTH_RETRIES, GROK_MAX_TRANSIENT_FAILOVERS, GROK_QUOTA_BLOCK_FALLBACK_MS, GROK_REFRESH_FAILED_COOLDOWN_MS, GROK_VERSION_GATE_REPROBE_MS, GrokAttemptBudgetExceededError, GrokCapabilityUnavailableError, GrokCapacityError, GrokCredentialRefreshError, GrokDispatcher, GrokIncompleteResponseError, GrokInvalidRequestError, GrokNoWorkersError, GrokOnDemandExcludedError, GrokRateLimitedError, GrokVersionGateError, GrokZdrVideoUnavailableError, grokConversationIds, grokTicksToUsd, isGrokZdrVideoRejection };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"grok-dispatcher.js","names":[],"sources":["../../../../src/utils/providers/grok/grok-dispatcher.ts"],"sourcesContent":["import { createHash, randomUUID } from \"node:crypto\";\n\nimport { getLogger } from \"@logtape/logtape\";\nimport { z } from \"zod\";\n\nimport {\n  type GrokProviderDispatcher,\n  type GrokTokenRow,\n} from \"../../../application/qgrid/qgrid.dispatcher\";\nimport { QuotaThresholdExceededError } from \"../../../application/qgrid/qgrid.types\";\nimport {\n  type GenerateRequest,\n  type GenerateResult,\n  type GenerateStreamCallbacks,\n  type MediaDispatcher,\n  type MediaDispatchResult,\n  type MediaTokenSelection,\n  type ProviderToolCall,\n  type ToolDefinition,\n  type VoiceDispatcher,\n  type XaiProviderMetadata,\n} from \"../common/provider-dispatcher\";\nimport { isJsonObject, type JsonValue, jsonString } from \"../common/provider-types\";\nimport { SmoothWeightedRoundRobin } from \"../common/smooth-weighted-round-robin\";\nimport { ThinkingValidationError } from \"../common/thinking\";\nimport {\n  buildGrokResponsesRequest,\n  type GrokFunctionTool,\n  type GrokInputContentPart,\n  type GrokInputItem,\n  type GrokResponsesRequest,\n  type GrokTool,\n  type GrokUsage,\n} from \"./grok-backend-protocol\";\nimport { GROK_BUILD_VERSION, GROK_USD_PER_TICK, type GrokReasoningEffort } from \"./grok-constants\";\nimport { GrokChatClient, GrokHttpError, GrokIdleTimeoutError } from \"./grok-direct-client\";\nimport { buildGrokChatHeaders } from \"./grok-headers\";\nimport { GrokModelCatalog, type GrokResolvedModel } from \"./grok-models\";\nimport {\n  readGrokBilling,\n  readGrokSettings,\n  readGrokSubscription,\n  type GrokQuotaUsageResult,\n  type GrokSettingsResult,\n  type GrokSubscriptionResult,\n} from \"./grok-quota\";\nimport { grokNeedsRefresh } from \"./grok-refresh\";\nimport {\n  GrokCredentials,\n  type GrokImageEditRequest,\n  type GrokImageGenerateRequest,\n  type GrokImageResponse,\n  type GrokMediaAuth,\n  type GrokMediaPort,\n  type GrokRefresher,\n  type GrokSpeechResult,\n  type GrokSttResponse,\n  type GrokTranscribeRequest,\n  type GrokTtsRequest,\n  type GrokVideoStart,\n  type GrokVideoStartRequest,\n  type GrokVideoStatus,\n  type GrokVoicePort,\n} from \"./grok-types\";\n\nconst logger = getLogger([\"qgrid\", \"grok-dispatcher\"]);\n\nexport type GrokRequestClass = \"chat\" | \"image\" | \"video\" | \"stt\" | \"tts\";\n\nexport const GROK_LOOKUP_CACHE_TTL_MS = 60_000;\nexport const GROK_MAX_COOLDOWN_MS = 120_000;\nexport const GROK_DEFAULT_COOLDOWN_MS = 10_000;\nexport const GROK_MAX_COOLDOWN_WAIT_MS = 30_000;\nexport const GROK_QUOTA_BLOCK_FALLBACK_MS = 3_600_000;\nexport const GROK_ENTITLEMENT_BLOCK_MS = 3_600_000;\nexport const GROK_VERSION_GATE_REPROBE_MS = 600_000;\nexport const GROK_MAX_HOPS = 2;\nexport const GROK_MAX_REFRESHES = 1;\nexport const GROK_MAX_TRANSIENT_FAILOVERS = 1;\n\n/** A token whose pre-lookup refresh failed transiently sits out selection this long (§5.1). */\nexport const GROK_REFRESH_FAILED_COOLDOWN_MS = 5_000;\n\n/** Retries with the token's current credentials after a 401 that a newer bearer superseded. */\nexport const GROK_MAX_STALE_AUTH_RETRIES = 1;\nconst DEFAULT_REQUEST_TIMEOUT_MS = 600_000;\nconst DEFAULT_IDLE_TIMEOUT_MS = 300_000;\n\n// ---------------------------------------------------------------------------\n// Errors\n// ---------------------------------------------------------------------------\n\nexport class GrokInvalidRequestError extends Error {\n  readonly code = \"GROK_INVALID_REQUEST\" as const;\n\n  constructor(message: string) {\n    super(message);\n    this.name = \"GrokInvalidRequestError\";\n  }\n}\n\nexport class GrokRateLimitedError extends Error {\n  readonly code = \"GROK_RATE_LIMITED\" as const;\n  readonly retryAfterSec: number;\n\n  constructor(retryAfterSec: number, message?: string) {\n    super(message ?? `All grok tokens are rate limited; retry after ${retryAfterSec}s`);\n    this.name = \"GrokRateLimitedError\";\n    this.retryAfterSec = retryAfterSec;\n  }\n}\n\nexport class GrokCapacityError extends Error {\n  readonly code = \"GROK_CAPACITY\" as const;\n\n  constructor(message = \"All grok tokens are at their in-flight request cap\") {\n    super(message);\n    this.name = \"GrokCapacityError\";\n  }\n}\n\nexport class GrokOnDemandExcludedError extends Error {\n  readonly code = \"GROK_ON_DEMAND_EXCLUDED\" as const;\n  readonly tokenNames: string[];\n\n  constructor(tokenNames: string[]) {\n    super(\n      `All grok tokens are excluded because on-demand billing is enabled: ${tokenNames.join(\", \")}`,\n    );\n    this.name = \"GrokOnDemandExcludedError\";\n    this.tokenNames = tokenNames;\n  }\n}\n\n/**\n * xAI refuses video generation for Zero Data Retention accounts unless the caller supplies its own\n * `output.upload_url` (plan §11), which qgrid does not implement.\n */\nexport class GrokZdrVideoUnavailableError extends Error {\n  readonly code = \"GROK_ZDR_VIDEO_UNAVAILABLE\" as const;\n  readonly tokenNames: string[];\n\n  constructor(tokenNames: string[]) {\n    super(\n      `Grok video is unavailable because Zero Data Retention is on for: ${tokenNames.join(\", \")}. Turn off the data-retention opt-out at xAI, or use a non-ZDR account.`,\n    );\n    this.name = \"GrokZdrVideoUnavailableError\";\n    this.tokenNames = tokenNames;\n  }\n}\n\n/** The upstream 400 body for a ZDR account on POST /v1/videos/generations. */\nconst ZDR_VIDEO_REJECTION = /zero data retention/i;\n\nexport function isGrokZdrVideoRejection(error: GrokHttpError): boolean {\n  return (\n    error.status === 400 &&\n    (ZDR_VIDEO_REJECTION.test(error.classification.message ?? \"\") ||\n      ZDR_VIDEO_REJECTION.test(error.bodyText))\n  );\n}\n\nexport class GrokVersionGateError extends Error {\n  readonly code = \"GROK_VERSION_GATE\" as const;\n  readonly minClientVersion: string | undefined;\n\n  constructor(minClientVersion: string | undefined) {\n    super(\n      `Grok chat proxy rejected client version ${GROK_BUILD_VERSION} (HTTP 426; requires ${\n        minClientVersion ?? \"a newer version\"\n      } or later). Bump GROK_BUILD_VERSION in grok-constants.ts and re-capture the golden fixture.`,\n    );\n    this.name = \"GrokVersionGateError\";\n    this.minClientVersion = minClientVersion;\n  }\n}\n\nexport class GrokAttemptBudgetExceededError extends Error {\n  readonly code = \"GROK_ATTEMPT_BUDGET_EXCEEDED\" as const;\n\n  constructor(attempts: number, cause: unknown) {\n    super(\n      `Grok request failed after ${attempts} attempts: ${\n        cause instanceof Error ? cause.message : String(cause)\n      }`,\n      { cause },\n    );\n    this.name = \"GrokAttemptBudgetExceededError\";\n  }\n}\n\nexport class GrokNoWorkersError extends Error {\n  readonly code = \"NO_GROK_WORKERS\" as const;\n\n  constructor(message = \"NO_GROK_WORKERS\") {\n    super(message);\n    this.name = \"GrokNoWorkersError\";\n  }\n}\n\nexport class GrokCapabilityUnavailableError extends Error {\n  readonly code = \"GROK_CAPABILITY_UNAVAILABLE\" as const;\n\n  constructor(capability: string) {\n    super(`Grok ${capability} is not configured on this server`);\n    this.name = \"GrokCapabilityUnavailableError\";\n  }\n}\n\n/** The refresher could not produce usable credentials for a token before the request was sent. */\nexport class GrokCredentialRefreshError extends Error {\n  readonly code = \"GROK_CREDENTIAL_REFRESH\" as const;\n  readonly reauthRequired: boolean;\n\n  /**\n   * `reauthRequired` defaults to the cause's convention: the port signals a dead refresh token with\n   * GrokReauthRequiredError (grok-refresh.ts), checked by name so any GrokRefresher implementation\n   * can use it.\n   */\n  constructor(\n    cause: unknown,\n    reauthRequired = cause instanceof Error && cause.name === \"GrokReauthRequiredError\",\n  ) {\n    super(\n      `Grok credential refresh failed: ${cause instanceof Error ? cause.message : String(cause)}`,\n      { cause },\n    );\n    this.name = \"GrokCredentialRefreshError\";\n    this.reauthRequired = reauthRequired;\n  }\n\n  /** The refresher answered `reauth_required`: the refresh token is dead. */\n  static reauthRequired(reason: string): GrokCredentialRefreshError {\n    return new GrokCredentialRefreshError(reason, true);\n  }\n}\n\nexport class GrokIncompleteResponseError extends Error {\n  readonly code = \"GROK_INCOMPLETE_RESPONSE\" as const;\n  readonly reason: string | undefined;\n\n  constructor(reason: string | undefined) {\n    super(`Grok response incomplete${reason ? `: ${reason}` : \"\"}`);\n    this.name = \"GrokIncompleteResponseError\";\n    this.reason = reason;\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Token state (§5.1)\n// ---------------------------------------------------------------------------\n\ntype Cached<T> = { value: T; fetchedAt: number; generation: number };\n\ntype IneligibleReason =\n  | \"inactive\"\n  | \"reauth\"\n  | \"refresh_failed\"\n  | \"on_demand\"\n  | \"zdr\"\n  | \"entitlement\"\n  | \"quota\"\n  | \"cooldown\"\n  | \"capacity\";\n\nexport interface GrokTokenState {\n  id: number;\n  name: string;\n  weight: number;\n  quotaThreshold: number | null;\n  credentials: GrokCredentials | undefined;\n  invalidReason: string | undefined;\n  generation: number;\n  inFlight: number;\n  cooldowns: Map<GrokRequestClass, number>;\n  quotaBlocks: Map<GrokRequestClass, number>;\n  entitlementBlocks: Map<GrokRequestClass, number>;\n  reauthRequired: boolean;\n  /**\n   * Until when the token is out of selection after a transient pre-lookup refresh failure: its\n   * gating lookups could not run with a valid bearer, so the gates are unknown.\n   */\n  refreshFailedUntil: number;\n  refreshFailure: unknown;\n  billing: Cached<GrokQuotaUsageResult> | undefined;\n  billingNotBefore: number;\n  settings: Cached<GrokSettingsResult> | undefined;\n  subscription: Cached<GrokSubscriptionResult> | undefined;\n  /**\n   * Zero Data Retention (plan §11): true excludes the token from video. Learned from\n   * /user codingDataRetentionOptOut, confirmed by `x-zero-data-retention: true` or the upstream\n   * ZDR 400; null is unknown and eligible.\n   */\n  zdr: boolean | null;\n  overThreshold: boolean;\n  lastTier: string | undefined;\n  failoverCount: number;\n}\n\nexport interface GrokTokenStateSnapshot {\n  id: number;\n  name: string;\n  weight: number;\n  active: boolean;\n  invalidReason: string | null;\n  inFlight: number;\n  cooldownUntil: Partial<Record<GrokRequestClass, number>>;\n  quotaBlockedUntil: Partial<Record<GrokRequestClass, number>>;\n  entitlementBlocks: Partial<Record<GrokRequestClass, number>>;\n  lastBilling: {\n    utilizationPct: number;\n    periodType: string;\n    periodEnd: string;\n    fetchedAt: number;\n  } | null;\n  quotaThreshold: number | null;\n  overThreshold: boolean;\n  onDemandExcluded: boolean;\n  zdrVideoExcluded: boolean;\n  lastTier: string | null;\n  reauthRequired: boolean;\n  failoverCount: number;\n}\n\ninterface Reservation {\n  token: GrokTokenState;\n  release(): void;\n}\n\n// ---------------------------------------------------------------------------\n// Request mapping\n// ---------------------------------------------------------------------------\n\nconst ContentPart = z.discriminatedUnion(\"type\", [\n  z.object({ type: z.literal(\"input_text\"), text: z.string() }),\n  z.object({ type: z.literal(\"input_image\"), image_url: z.string().min(1) }),\n  z.object({ type: z.literal(\"output_text\"), text: z.string() }),\n]);\n\nconst HistoryItem = z.union([\n  z.object({\n    type: z.literal(\"message\").optional(),\n    role: z.enum([\"user\", \"assistant\"]),\n    content: z.union([z.string(), z.array(ContentPart)]),\n  }),\n  z.object({\n    type: z.literal(\"function_call\"),\n    call_id: z.string().min(1),\n    name: z.string().min(1),\n    arguments: z.string(),\n    id: z.string().optional(),\n  }),\n  z.object({\n    type: z.literal(\"function_call_output\"),\n    call_id: z.string().min(1),\n    output: z.string(),\n  }),\n  z.object({\n    type: z.literal(\"reasoning\"),\n    id: z.string().optional(),\n    summary: z.array(z.object({ type: z.literal(\"summary_text\"), text: z.string() })).optional(),\n    encrypted_content: z.string().optional(),\n  }),\n]);\n\nfunction historyItems(history: readonly JsonValue[] | undefined): GrokInputItem[] {\n  return (history ?? []).map((raw, index) => {\n    const parsed = HistoryItem.safeParse(raw);\n\n    if (!parsed.success) {\n      throw new GrokInvalidRequestError(`Unsupported Grok history item at index ${index}`);\n    }\n\n    const item = parsed.data;\n\n    if (\"role\" in item) return { type: \"message\", role: item.role, content: item.content };\n\n    return item;\n  });\n}\n\nfunction userMessage(req: GenerateRequest): GrokInputItem {\n  const content: GrokInputContentPart[] = req.coldInput.map((input) => {\n    if (input.type === \"text\") return { type: \"input_text\", text: input.text };\n\n    if (input.type === \"image\") return { type: \"input_image\", image_url: input.url };\n\n    if (input.type === \"localImage\") {\n      throw new GrokInvalidRequestError(\"Grok does not accept local image paths; send a data URL\");\n    }\n\n    return { type: \"input_text\", text: `${input.name}: ${input.path}` };\n  });\n\n  return { type: \"message\", role: \"user\", content };\n}\n\nfunction grokTools(tools: readonly ToolDefinition[] | undefined): GrokTool[] | undefined {\n  if (!tools?.length) return undefined;\n\n  return tools.map((tool): GrokTool => {\n    if (tool.type !== \"function\") return { type: tool.type };\n\n    const fn: GrokFunctionTool = {\n      type: \"function\",\n      name: tool.name,\n      parameters: tool.parameters,\n      strict: tool.strict ?? false,\n    };\n\n    if (tool.description !== undefined) fn.description = tool.description;\n\n    return fn;\n  });\n}\n\n/** Deterministic UUID-shaped id, so one qgrid conversation maps to one Grok conversation. */\nfunction derivedGuid(namespace: string, key: string): string {\n  const hex = createHash(\"sha256\").update(`${namespace}\\0${key}`).digest(\"hex\");\n  const variant = ((Number.parseInt(hex[16]!, 16) & 0x3) | 0x8).toString(16);\n\n  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-${variant}${hex.slice(17, 20)}-${hex.slice(20, 32)}`;\n}\n\nexport interface GrokConversationIds {\n  convId: string;\n  convGroupId: string;\n}\n\nexport function grokConversationIds(promptCacheKey: string | undefined): GrokConversationIds {\n  const convId = promptCacheKey ? derivedGuid(\"grok-conv\", promptCacheKey) : randomUUID();\n\n  return { convId, convGroupId: derivedGuid(\"grok-conv-group\", convId) };\n}\n\n/** USD from cost_in_usd_ticks, rounded to the tick resolution (1e-10). */\nexport function grokTicksToUsd(ticks: number): number {\n  return Number((ticks * GROK_USD_PER_TICK).toFixed(10));\n}\n\nfunction parseMaxInflight(value: string | undefined): number | undefined {\n  if (value === undefined || value.trim() === \"\") return undefined;\n  const parsed = Number(value);\n\n  if (!Number.isSafeInteger(parsed) || parsed < 1) {\n    logger.warn(`ignoring QGRID_GROK_MAX_INFLIGHT_PER_TOKEN=${value}: not a positive integer`);\n\n    return undefined;\n  }\n\n  return parsed;\n}\n\nfunction abortReason(signal: AbortSignal): Error {\n  const reason: unknown = signal.reason;\n\n  return reason instanceof Error ? reason : new DOMException(\"Aborted\", \"AbortError\");\n}\n\n/** Imagine calls carry the token's session id like grok-build's per-request session header. */\nfunction mediaAuth(credentials: GrokCredentials): GrokMediaAuth {\n  return { bearer: credentials.accessToken, sessionId: credentials.sessionId };\n}\n\nfunction defaultSleep(ms: number, signal?: AbortSignal): Promise<void> {\n  return new Promise((resolve, reject) => {\n    if (signal?.aborted) {\n      reject(abortReason(signal));\n\n      return;\n    }\n\n    const onAbort = () => {\n      clearTimeout(timer);\n      reject(abortReason(signal!));\n    };\n\n    const timer = setTimeout(() => {\n      signal?.removeEventListener(\"abort\", onAbort);\n      resolve();\n    }, ms);\n\n    signal?.addEventListener(\"abort\", onAbort, { once: true });\n  });\n}\n\nfunction quotaMessage(entries: Array<{ name: string; threshold: number | null }>): string {\n  const detail = entries\n    .map((e) =>\n      e.threshold === null ? `${e.name} (exhausted)` : `${e.name} (threshold ${e.threshold}%)`,\n    )\n    .join(\", \");\n\n  return detail\n    ? `All grok tokens exceeded quota threshold: ${detail}`\n    : \"All grok tokens exceeded quota threshold\";\n}\n\nfunction mapRecord(map: Map<GrokRequestClass, number>, now: number) {\n  return Object.fromEntries([...map].filter(([, until]) => until > now));\n}\n\n/**\n * Persists a proven re-login requirement (`tokens.reauth_required`), mirroring the other providers'\n * auth-death path. `credentials` are the ones the failed attempt presented; the store skips the\n * write when the row has rotated since.\n */\nexport type GrokReauthReporter = (\n  token: { id: number; name: string; credentials: GrokCredentials },\n  reasonCode: string,\n) => Promise<boolean>;\n\nasync function persistGrokReauth(\n  token: { id: number; name: string; credentials: GrokCredentials },\n  reasonCode: string,\n): Promise<boolean> {\n  // Loaded lazily: the token model pulls in the database layer, which the runtime does not need\n  // until a token actually dies.\n  const { deactivateAuthDeadToken } = await import(\"../../../application/qgrid/token-death\");\n\n  return deactivateAuthDeadToken({ ...token, provider: \"grok\" }, reasonCode);\n}\n\n/** Internal `grok:<code>` reason; provider text may carry account data, so only codes pass. */\nfunction reauthReasonCode(code: string | undefined): string {\n  return code !== undefined && /^[a-z_0-9]{1,80}$/.test(code) ? `grok:${code}` : \"grok:unknown\";\n}\n\nconst oauthErrorCodeSchema = z.string();\n\nfunction oauthErrorOf(cause: unknown): string | undefined {\n  return cause instanceof Error && \"oauthError\" in cause\n    ? oauthErrorCodeSchema.safeParse(cause.oauthError).data\n    : undefined;\n}\n\n/** The same bearer and refresh token: a failure judged against `b` applies to `a`. */\nfunction sameCredentials(a: GrokCredentials | undefined, b: GrokCredentials): boolean {\n  return a?.accessToken === b.accessToken && a.refreshToken === b.refreshToken;\n}\n\n// ---------------------------------------------------------------------------\n// Dispatcher\n// ---------------------------------------------------------------------------\n\nexport interface GrokDispatcherOptions {\n  refresher: GrokRefresher;\n  fetch?: typeof fetch;\n  media?: GrokMediaPort;\n  voice?: GrokVoicePort;\n  now?: () => number;\n  /** Default: QGRID_GROK_MAX_INFLIGHT_PER_TOKEN; undefined means uncapped (§5.6). */\n  maxInflightPerToken?: number;\n  sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;\n  client?: GrokChatClient;\n  catalog?: GrokModelCatalog;\n  idleTimeoutMs?: number;\n  /** Default: deactivateAuthDeadToken (application/qgrid/token-death.ts). */\n  reportReauthRequired?: GrokReauthReporter;\n}\n\ntype FailureAction =\n  | { kind: \"fail\"; error: unknown }\n  | { kind: \"refresh\"; presented: GrokCredentials }\n  | { kind: \"retry\"; error: unknown }\n  | { kind: \"failover\"; error: unknown; transient: boolean };\n\n/** Names of the tokens that were ineligible for exactly `reason`. */\nfunction tokenNamesWithReason(\n  reasons: ReadonlyMap<GrokTokenState, IneligibleReason>,\n  reason: IneligibleReason,\n): string[] {\n  return [...reasons].flatMap(([token, tokenReason]) =>\n    tokenReason === reason ? [token.name] : [],\n  );\n}\n\n/** A token row whose stored credentials are validated here, not trusted. */\ntype GrokTokenInput = Omit<GrokTokenRow, \"credentials\"> & { credentials: JsonValue };\n\nexport interface GrokChatBody {\n  body: GrokResponsesRequest;\n  model: GrokResolvedModel;\n  convId: string;\n  convGroupId: string;\n  turnIdx: number;\n}\n\nexport interface GrokVersionGateState {\n  tripped: boolean;\n  minClientVersion: string | null;\n  trippedAt: number | null;\n}\n\ninterface AttemptState {\n  upstreamStarted: boolean;\n  forwarded: boolean;\n  /** The exact credentials this attempt presented (or tried to refresh); failures judge these. */\n  presented: GrokCredentials | undefined;\n}\n\nexport class GrokDispatcher implements GrokProviderDispatcher, MediaDispatcher, VoiceDispatcher {\n  readonly tokens = new Map<number, GrokTokenState>();\n  readonly selector = new SmoothWeightedRoundRobin();\n  readonly refresher: GrokRefresher;\n  readonly fetchImpl: typeof fetch;\n  readonly media: GrokMediaPort | undefined;\n  readonly voice: GrokVoicePort | undefined;\n  readonly now: () => number;\n  readonly maxInflightPerToken: number | undefined;\n  readonly sleep: (ms: number, signal?: AbortSignal) => Promise<void>;\n  readonly client: GrokChatClient;\n  readonly catalog: GrokModelCatalog;\n  readonly idleTimeoutMs: number;\n  readonly reportReauthRequired: GrokReauthReporter;\n  readonly pendingBilling = new Map<number, Promise<void>>();\n  readonly pendingSettings = new Map<number, Promise<void>>();\n  readonly pendingSubscription = new Map<number, Promise<void>>();\n  versionGate: { trippedAt: number; minClientVersion: string | undefined } | undefined;\n\n  constructor(options: GrokDispatcherOptions) {\n    this.refresher = options.refresher;\n    this.fetchImpl = options.fetch ?? fetch;\n    this.media = options.media;\n    this.voice = options.voice;\n    this.now = options.now ?? Date.now;\n    this.maxInflightPerToken =\n      \"maxInflightPerToken\" in options\n        ? options.maxInflightPerToken\n        : parseMaxInflight(process.env.QGRID_GROK_MAX_INFLIGHT_PER_TOKEN);\n    this.sleep = options.sleep ?? defaultSleep;\n    this.client = options.client ?? new GrokChatClient({ fetch: this.fetchImpl });\n    this.catalog = options.catalog ?? new GrokModelCatalog();\n    this.idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;\n    this.reportReauthRequired = options.reportReauthRequired ?? persistGrokReauth;\n  }\n\n  // Tokens arrive through GrokTokenSink (TokenSubscriber reconciles on start).\n  async start(): Promise<void> {\n    logger.info(`started grok runtime with ${this.tokens.size} tokens`);\n  }\n\n  async stop(): Promise<void> {\n    this.tokens.clear();\n    this.pendingBilling.clear();\n    this.pendingSettings.clear();\n    this.pendingSubscription.clear();\n\n    for (const id of this.selector.weights.keys()) this.selector.removeToken(id);\n    this.versionGate = undefined;\n  }\n\n  // ---- GrokTokenSink -------------------------------------------------------\n\n  onTokenAdded(\n    id: number,\n    name: string,\n    credentials: JsonValue,\n    quotaThreshold: number | null,\n    weight: number,\n  ): void {\n    this.upsertToken(id, name, credentials, quotaThreshold, weight);\n  }\n\n  onTokenUpdated(\n    id: number,\n    name: string,\n    credentials: JsonValue,\n    quotaThreshold: number | null,\n    weight: number,\n  ): void {\n    this.upsertToken(id, name, credentials, quotaThreshold, weight);\n  }\n\n  onTokenRemoved(id: number): void {\n    this.tokens.delete(id);\n    this.selector.removeToken(id);\n    this.pendingBilling.delete(id);\n    this.pendingSettings.delete(id);\n    this.pendingSubscription.delete(id);\n  }\n\n  replaceTokens(rows: GrokTokenInput[]): void {\n    const ids = new Set(rows.map((row) => row.id));\n\n    for (const id of this.tokens.keys()) if (!ids.has(id)) this.onTokenRemoved(id);\n\n    for (const row of rows)\n      this.upsertToken(row.id, row.name, row.credentials, row.quotaThreshold, row.weight);\n  }\n\n  upsertToken(\n    id: number,\n    name: string,\n    rawCredentials: JsonValue,\n    quotaThreshold: number | null,\n    weight: number,\n  ): void {\n    const parsed = GrokCredentials.safeParse(rawCredentials);\n\n    // Only paths are logged; values may be secrets.\n    let invalidReason = parsed.success\n      ? undefined\n      : `invalid credentials at ${[...new Set(parsed.error.issues.map((i) => i.path.join(\".\") || \"<root>\"))].join(\", \")}`;\n\n    if (!invalidReason && (!Number.isInteger(weight) || weight < 1 || weight > 100)) {\n      invalidReason = `invalid weight ${weight}`;\n    }\n\n    const credentials = parsed.success ? parsed.data : undefined;\n    const old = this.tokens.get(id);\n\n    if (old) {\n      const credentialsChanged =\n        old.credentials?.accessToken !== credentials?.accessToken ||\n        old.credentials?.refreshToken !== credentials?.refreshToken;\n\n      const thresholdChanged = old.quotaThreshold !== quotaThreshold;\n      old.name = name;\n      old.weight = weight;\n      old.quotaThreshold = quotaThreshold;\n      old.credentials = credentials;\n      old.invalidReason = invalidReason;\n\n      if (credentialsChanged || thresholdChanged) {\n        old.generation++;\n        old.billing = undefined;\n        old.settings = undefined;\n        old.subscription = undefined;\n        old.overThreshold = false;\n      }\n\n      if (credentialsChanged) {\n        old.reauthRequired = false;\n        old.refreshFailedUntil = 0;\n        old.refreshFailure = undefined;\n        // New credentials may belong to another account; ZDR is account-level.\n        old.zdr = null;\n      }\n    } else {\n      this.tokens.set(id, {\n        id,\n        name,\n        weight,\n        quotaThreshold,\n        credentials,\n        invalidReason,\n        generation: 1,\n        inFlight: 0,\n        cooldowns: new Map(),\n        quotaBlocks: new Map(),\n        entitlementBlocks: new Map(),\n        reauthRequired: false,\n        refreshFailedUntil: 0,\n        refreshFailure: undefined,\n        billing: undefined,\n        billingNotBefore: 0,\n        settings: undefined,\n        subscription: undefined,\n        zdr: null,\n        overThreshold: false,\n        lastTier: credentials?.subscriptionTier,\n        failoverCount: 0,\n      });\n    }\n\n    if (invalidReason) {\n      logger.warn(`grok token ${name}[${id}] treated as inactive: ${invalidReason}`);\n      this.selector.removeToken(id);\n    } else {\n      this.selector.setToken(id, weight);\n    }\n  }\n\n  // ---- Eligibility (§5.1) -------------------------------------------------\n\n  /**\n   * `held` counts reservations the caller already holds on `token` (re-checks mid-request).\n   * `ungated` skips the admission gates and checks only that the credentials are usable.\n   */\n  ineligibility(\n    token: GrokTokenState,\n    requestClass: GrokRequestClass,\n    now: number,\n    held = 0,\n    ungated = false,\n  ): IneligibleReason | undefined {\n    if (!token.credentials || token.invalidReason) return \"inactive\";\n\n    if (token.reauthRequired) return \"reauth\";\n\n    if (token.refreshFailedUntil > now) return \"refresh_failed\";\n\n    if (ungated) return undefined;\n    const settings = token.settings?.value;\n\n    if (settings?.kind === \"ok\" && settings.onDemandEnabled === true) return \"on_demand\";\n\n    if (requestClass === \"video\" && token.zdr === true) return \"zdr\";\n\n    if ((token.entitlementBlocks.get(requestClass) ?? 0) > now) return \"entitlement\";\n\n    if ((token.quotaBlocks.get(requestClass) ?? 0) > now) return \"quota\";\n\n    if (token.quotaThreshold !== null && token.overThreshold) return \"quota\";\n\n    if ((token.cooldowns.get(requestClass) ?? 0) > now) return \"cooldown\";\n\n    if (this.maxInflightPerToken !== undefined && token.inFlight - held >= this.maxInflightPerToken)\n      return \"capacity\";\n\n    return undefined;\n  }\n\n  isEligible(token: GrokTokenState, requestClass: GrokRequestClass): boolean {\n    return this.ineligibility(token, requestClass, this.now()) === undefined;\n  }\n\n  /**\n   * Refreshes the 60 s settings/subscription/billing caches. Lookup failures fail open, so an\n   * expired bearer is refreshed first: a lookup with it would fail and open every gate. A failed\n   * refresh therefore takes the token out of selection (`refresh_failed`) instead of failing open.\n   */\n  async prefetch(token: GrokTokenState, signal?: AbortSignal): Promise<void> {\n    if (!token.credentials || token.invalidReason || token.reauthRequired) return;\n    let now = this.now();\n    const tasks: Promise<void>[] = [];\n\n    const stale = (entry: Cached<unknown> | undefined) =>\n      !entry ||\n      entry.generation !== token.generation ||\n      now - entry.fetchedAt >= GROK_LOOKUP_CACHE_TTL_MS;\n\n    const billingDue = () =>\n      (token.quotaThreshold !== null || [...token.quotaBlocks.values()].some((u) => u > now)) &&\n      stale(token.billing) &&\n      now >= token.billingNotBefore;\n\n    if (!stale(token.settings) && !stale(token.subscription) && !billingDue()) return;\n\n    if (grokNeedsRefresh(token.credentials, now)) {\n      // Do not hammer the IdP: the cooldown expires before the next refresh is tried.\n      if (token.refreshFailedUntil > now) return;\n      const presented = token.credentials;\n\n      try {\n        await this.freshCredentials(token, signal ?? new AbortController().signal);\n      } catch (error) {\n        // Lookups with this bearer would fail open, so the gates stay unknown and the token sits\n        // out selection until a later refresh succeeds.\n        if (signal?.aborted) return;\n\n        if (error instanceof Error && error.name === \"GrokReauthRequiredError\")\n          this.markReauthRequired(token, presented, reauthReasonCode(oauthErrorOf(error)));\n        else this.markRefreshFailed(token, presented, error);\n\n        return;\n      }\n\n      if (!token.credentials || token.reauthRequired || this.tokens.get(token.id) !== token) return;\n      now = this.now();\n    }\n\n    if (stale(token.settings)) tasks.push(this.loadSettings(token));\n\n    if (stale(token.subscription)) tasks.push(this.loadSubscription(token));\n    const blocked = [...token.quotaBlocks.values()].some((until) => until > now);\n\n    if ((token.quotaThreshold !== null || blocked) && stale(token.billing)) {\n      if (now >= token.billingNotBefore) tasks.push(this.loadBilling(token));\n    }\n\n    await Promise.all(tasks);\n  }\n\n  /** Transient refresh failure for `presented`; ignored when the token already holds newer ones. */\n  markRefreshFailed(token: GrokTokenState, presented: GrokCredentials, cause: unknown): void {\n    if (this.tokens.get(token.id) !== token || !sameCredentials(token.credentials, presented))\n      return;\n    token.refreshFailedUntil = this.now() + GROK_REFRESH_FAILED_COOLDOWN_MS;\n    token.refreshFailure = cause;\n    logger.warn(\n      `grok token ${token.name}[${token.id}] refresh failed; out of selection for ${GROK_REFRESH_FAILED_COOLDOWN_MS}ms: ${cause instanceof Error ? cause.name : \"unknown\"}`,\n    );\n  }\n\n  loadSettings(token: GrokTokenState): Promise<void> {\n    const pending = this.pendingSettings.get(token.id);\n\n    if (pending) return pending;\n    const generation = token.generation;\n    const credentials = token.credentials!;\n\n    const promise = readGrokSettings(credentials, { fetch: this.fetchImpl })\n      .then((result) => {\n        if (this.tokens.get(token.id) !== token || token.generation !== generation) return;\n        token.settings = { value: result, fetchedAt: this.now(), generation };\n\n        if (result.kind === \"lookup_failed\") {\n          logger.warn(\"quota_threshold gate: settings_lookup_fail_open\", {\n            tokenId: token.id,\n            tokenName: token.name,\n            lookupReason: result.reason,\n          });\n\n          return;\n        }\n\n        if (result.subscriptionTierDisplay) token.lastTier = result.subscriptionTierDisplay;\n\n        if (result.onDemandEnabled === true) {\n          logger.info(\n            `quota_threshold gate: on_demand_excluded ${token.name}[${token.id}] (on_demand_enabled=true)`,\n          );\n        }\n      })\n      .finally(() => {\n        if (this.pendingSettings.get(token.id) === promise) this.pendingSettings.delete(token.id);\n      });\n\n    this.pendingSettings.set(token.id, promise);\n\n    return promise;\n  }\n\n  /** /user codingDataRetentionOptOut is the primary ZDR signal; a failed read keeps the last value. */\n  loadSubscription(token: GrokTokenState): Promise<void> {\n    const pending = this.pendingSubscription.get(token.id);\n\n    if (pending) return pending;\n    const generation = token.generation;\n    const credentials = token.credentials!;\n\n    const promise = readGrokSubscription(credentials, { fetch: this.fetchImpl })\n      .then((result) => {\n        if (this.tokens.get(token.id) !== token || token.generation !== generation) return;\n        token.subscription = { value: result, fetchedAt: this.now(), generation };\n\n        if (result.kind === \"lookup_failed\") {\n          logger.debug(`grok subscription lookup failed for ${token.name}[${token.id}]`, {\n            lookupReason: result.reason,\n          });\n\n          return;\n        }\n\n        if (result.dataRetentionOptOut !== null) {\n          this.setZdr(token, result.dataRetentionOptOut, \"codingDataRetentionOptOut\");\n        }\n      })\n      .finally(() => {\n        if (this.pendingSubscription.get(token.id) === promise)\n          this.pendingSubscription.delete(token.id);\n      });\n\n    this.pendingSubscription.set(token.id, promise);\n\n    return promise;\n  }\n\n  setZdr(token: GrokTokenState, zdr: boolean, source: string): void {\n    if (this.tokens.get(token.id) !== token || token.zdr === zdr) return;\n    token.zdr = zdr;\n    logger.info(\n      zdr\n        ? `grok token ${token.name}[${token.id}] excluded from video: zero data retention (${source})`\n        : `grok token ${token.name}[${token.id}] video eligible: zero data retention off (${source})`,\n    );\n  }\n\n  /** `x-zero-data-retention: true` confirms ZDR; its absence never clears it (next /user read does). */\n  observeResponseHeaders(\n    token: GrokTokenState,\n    credentials: GrokCredentials,\n    headers: { zeroDataRetention?: boolean },\n  ): void {\n    if (token.credentials?.accessToken !== credentials.accessToken) return;\n\n    if (headers.zeroDataRetention === true) this.setZdr(token, true, \"x-zero-data-retention\");\n  }\n\n  loadBilling(token: GrokTokenState): Promise<void> {\n    const pending = this.pendingBilling.get(token.id);\n\n    if (pending) return pending;\n    const generation = token.generation;\n    const credentials = token.credentials!;\n\n    const promise = readGrokBilling(credentials, { fetch: this.fetchImpl })\n      .then((result) => {\n        if (this.tokens.get(token.id) !== token || token.generation !== generation) return;\n        const now = this.now();\n        token.billing = { value: result, fetchedAt: now, generation };\n\n        if (result.kind === \"lookup_failed\") {\n          token.overThreshold = false;\n          logger.warn(\"quota_threshold gate: lookup_fail_open\", {\n            tokenId: token.id,\n            tokenName: token.name,\n            lookupReason: result.reason,\n          });\n\n          return;\n        }\n\n        const limit = token.quotaThreshold ?? 100;\n        const over = token.quotaThreshold !== null && result.utilizationPct >= token.quotaThreshold;\n\n        if (over && !token.overThreshold) {\n          logger.info(\n            `quota_threshold gate: over_threshold ${token.name}[${token.id}] (${result.utilizationPct}% >= ${token.quotaThreshold}%)`,\n          );\n        }\n\n        if (!over && token.overThreshold) {\n          logger.info(\n            `quota_threshold gate: recovered ${token.name}[${token.id}] (${result.utilizationPct}% < ${token.quotaThreshold}%)`,\n          );\n        }\n\n        token.overThreshold = over;\n\n        if (result.utilizationPct < limit && token.quotaBlocks.size) {\n          token.quotaBlocks.clear();\n          logger.info(\n            `quota_threshold gate: exhaustion_cleared ${token.name}[${token.id}] (${result.utilizationPct}% < ${limit}%)`,\n          );\n        }\n      })\n      .finally(() => {\n        if (this.pendingBilling.get(token.id) === promise) this.pendingBilling.delete(token.id);\n      });\n\n    this.pendingBilling.set(token.id, promise);\n\n    return promise;\n  }\n\n  // ---- Selection (§5.2) ---------------------------------------------------\n\n  reserve(token: GrokTokenState): Reservation {\n    token.inFlight++;\n    let released = false;\n\n    return {\n      token,\n      release: () => {\n        if (released) return;\n        released = true;\n        token.inFlight = Math.max(0, token.inFlight - 1);\n      },\n    };\n  }\n\n  checkVersionGate(requestClass: GrokRequestClass): void {\n    if (requestClass !== \"chat\" || !this.versionGate) return;\n\n    if (this.now() - this.versionGate.trippedAt < GROK_VERSION_GATE_REPROBE_MS) {\n      throw new GrokVersionGateError(this.versionGate.minClientVersion);\n    }\n    // Re-probe: let requests through; a fresh 426 trips the gate again.\n  }\n\n  async selectToken(\n    requestClass: GrokRequestClass,\n    options: {\n      preferredTokenId?: number;\n      requirePreferredToken?: boolean;\n      excluded?: ReadonlySet<number>;\n      signal?: AbortSignal;\n      deadline?: number;\n      ungated?: boolean;\n    } = {},\n  ): Promise<Reservation> {\n    this.checkVersionGate(requestClass);\n    const excluded = options.excluded ?? new Set<number>();\n\n    if (options.preferredTokenId !== undefined) {\n      const preferred = this.tokens.get(options.preferredTokenId);\n\n      if (preferred && !excluded.has(preferred.id)) {\n        for (let round = 0; ; round++) {\n          await this.prefetch(preferred, options.signal);\n          options.signal?.throwIfAborted();\n          const now = this.now();\n          const reason = this.ineligibility(preferred, requestClass, now, 0, options.ungated);\n\n          if (!reason) return this.reserve(preferred);\n\n          if (!options.requirePreferredToken) break;\n          // An exact target has no alternative: wait out one failed refresh, like a cooldown.\n          const waitMs = preferred.refreshFailedUntil - now;\n\n          if (\n            reason === \"refresh_failed\" &&\n            round === 0 &&\n            waitMs <= GROK_MAX_COOLDOWN_WAIT_MS &&\n            (options.deadline === undefined || now + waitMs < options.deadline)\n          ) {\n            await this.sleep(Math.max(0, waitMs), options.signal);\n            continue;\n          }\n\n          throw this.preferredError(preferred, reason);\n        }\n      } else if (options.requirePreferredToken) {\n        throw new GrokNoWorkersError(\n          `Preferred grok token ${options.preferredTokenId} is not available`,\n        );\n      }\n    }\n\n    for (let round = 0; ; round++) {\n      const candidates = [...this.tokens.values()].filter((token) => !excluded.has(token.id));\n      await Promise.all(candidates.map((token) => this.prefetch(token, options.signal)));\n      options.signal?.throwIfAborted();\n      // Synchronous from here to reserve(): concurrent selections cannot overshoot the cap.\n      const now = this.now();\n      const reasons = new Map<GrokTokenState, IneligibleReason>();\n      const eligible = new Set<number>();\n\n      for (const token of candidates) {\n        const reason = this.ineligibility(token, requestClass, now);\n\n        if (reason) reasons.set(token, reason);\n        else eligible.add(token.id);\n      }\n\n      if (eligible.size) {\n        const selected = this.selector.select(eligible);\n        const token = selected === null ? undefined : this.tokens.get(selected);\n\n        if (token) return this.reserve(token);\n      }\n\n      const present = new Set(reasons.values());\n\n      if (present.has(\"capacity\")) throw new GrokCapacityError();\n\n      if (present.has(\"cooldown\") || present.has(\"refresh_failed\")) {\n        // A failed refresh is a short transient cooldown: wait once, then re-run the lookups.\n        const until = (token: GrokTokenState, reason: IneligibleReason) =>\n          reason === \"cooldown\"\n            ? (token.cooldowns.get(requestClass) ?? now)\n            : reason === \"refresh_failed\"\n              ? token.refreshFailedUntil\n              : Number.POSITIVE_INFINITY;\n\n        const soonest = Math.min(...[...reasons].map(([token, reason]) => until(token, reason)));\n        const waitMs = Math.max(0, Math.min(soonest - now, GROK_MAX_COOLDOWN_WAIT_MS));\n        const withinDeadline = options.deadline === undefined || now + waitMs < options.deadline;\n\n        if (round === 0 && withinDeadline) {\n          await this.sleep(waitMs, options.signal);\n          continue;\n        }\n\n        const cooling = [...reasons].filter(([, reason]) => reason === \"cooldown\");\n\n        if (cooling.length) {\n          const soonestCooldown = Math.min(...cooling.map(([token]) => until(token, \"cooldown\")));\n          throw new GrokRateLimitedError(Math.max(1, Math.ceil((soonestCooldown - now) / 1000)));\n        }\n\n        const failed = [...reasons].find(([, reason]) => reason === \"refresh_failed\");\n        throw new GrokCredentialRefreshError(failed?.[0].refreshFailure ?? \"refresh failed\", false);\n      }\n\n      if (present.has(\"quota\")) {\n        const over = [...reasons].flatMap(([token, reason]) =>\n          reason === \"quota\"\n            ? [{ name: token.name, threshold: token.overThreshold ? token.quotaThreshold : null }]\n            : [],\n        );\n\n        logger.warn(\"quota_threshold gate: all_exceeded\", {\n          provider: \"grok\",\n          overThresholdTokens: over,\n        });\n        throw new QuotaThresholdExceededError(quotaMessage(over));\n      }\n\n      if (present.has(\"on_demand\")) {\n        throw new GrokOnDemandExcludedError(tokenNamesWithReason(reasons, \"on_demand\"));\n      }\n\n      if (present.has(\"zdr\")) {\n        throw new GrokZdrVideoUnavailableError(tokenNamesWithReason(reasons, \"zdr\"));\n      }\n\n      throw new GrokNoWorkersError();\n    }\n  }\n\n  preferredError(token: GrokTokenState, reason: IneligibleReason): Error {\n    const now = this.now();\n\n    if (reason === \"quota\") {\n      return new QuotaThresholdExceededError(\n        quotaMessage([\n          { name: token.name, threshold: token.overThreshold ? token.quotaThreshold : null },\n        ]),\n      );\n    }\n\n    if (reason === \"cooldown\") {\n      const until = Math.max(...token.cooldowns.values());\n\n      return new GrokRateLimitedError(Math.max(1, Math.ceil((until - now) / 1000)));\n    }\n\n    if (reason === \"capacity\") return new GrokCapacityError();\n\n    if (reason === \"refresh_failed\")\n      return new GrokCredentialRefreshError(token.refreshFailure ?? \"refresh failed\", false);\n\n    if (reason === \"on_demand\") return new GrokOnDemandExcludedError([token.name]);\n\n    if (reason === \"zdr\") return new GrokZdrVideoUnavailableError([token.name]);\n\n    return new GrokNoWorkersError(`Preferred grok token ${token.id} is not available (${reason})`);\n  }\n\n  // ---- Failure handling (§5.4) -------------------------------------------\n\n  applyHttpFailure(\n    token: GrokTokenState,\n    requestClass: GrokRequestClass,\n    error: GrokHttpError,\n  ): void {\n    const now = this.now();\n    const { classification } = error;\n\n    if (classification.kind === \"rate_limited\") {\n      const cooldownMs = Math.min(\n        classification.retryAfterSec === undefined\n          ? GROK_DEFAULT_COOLDOWN_MS\n          : classification.retryAfterSec * 1000,\n        GROK_MAX_COOLDOWN_MS,\n      );\n\n      token.cooldowns.set(requestClass, now + cooldownMs);\n      logger.info(\n        `grok token ${token.name}[${token.id}] cooldown ${cooldownMs}ms (${requestClass})`,\n      );\n    } else if (classification.kind === \"quota_exhausted\") {\n      const billing = token.billing?.value;\n      const periodEnd = billing?.kind === \"ok\" ? billing.periodEndMs : null;\n\n      const until =\n        periodEnd !== null && periodEnd > now ? periodEnd : now + GROK_QUOTA_BLOCK_FALLBACK_MS;\n\n      token.quotaBlocks.set(requestClass, until);\n      token.billing = undefined;\n      // A billing read right after the 429 may still lag the proxy; wait one cache period.\n      token.billingNotBefore = now + GROK_LOOKUP_CACHE_TTL_MS;\n      logger.info(\n        `quota_threshold gate: exhausted ${token.name}[${token.id}] until ${new Date(until).toISOString()} (${classification.code ?? \"429\"})`,\n      );\n    } else if (classification.kind === \"entitlement\" && requestClass !== \"chat\") {\n      token.entitlementBlocks.set(requestClass, now + GROK_ENTITLEMENT_BLOCK_MS);\n    } else if (classification.kind === \"version_gate\" && requestClass === \"chat\") {\n      this.versionGate = { trippedAt: now, minClientVersion: classification.minClientVersion };\n      logger.error(\n        `grok chat proxy version gate tripped: ${GROK_BUILD_VERSION} < ${classification.minClientVersion ?? \"?\"}`,\n      );\n    }\n  }\n\n  classifyFailure(\n    token: GrokTokenState,\n    requestClass: GrokRequestClass,\n    cause: unknown,\n    presented: GrokCredentials | undefined,\n    refreshedThisRequest: boolean,\n    refreshBudgetLeft: boolean,\n  ): FailureAction {\n    if (cause instanceof GrokIdleTimeoutError) {\n      // Reached only before any event: no upstream execution was observed.\n      return requestClass === \"chat\"\n        ? { kind: \"failover\", error: cause, transient: true }\n        : { kind: \"fail\", error: cause };\n    }\n\n    if (cause instanceof GrokCredentialRefreshError) {\n      // Nothing reached upstream; another token can serve the request.\n      // Judged against the credentials this refresh started from: if a concurrent refresh or a\n      // subscriber update already replaced them, the failure says nothing about the new ones.\n      if (presented) {\n        if (cause.reauthRequired)\n          this.markReauthRequired(token, presented, reauthReasonCode(oauthErrorOf(cause.cause)));\n        else this.markRefreshFailed(token, presented, cause.cause);\n      }\n\n      return { kind: \"failover\", error: cause, transient: false };\n    }\n\n    if (!(cause instanceof GrokHttpError)) return { kind: \"fail\", error: cause };\n\n    if (requestClass === \"video\" && isGrokZdrVideoRejection(cause)) {\n      // The ZDR signal was stale or unknown. The 400 is a definite rejection (no job was created),\n      // so the start may move to another token under the media entitlement rules.\n      this.setZdr(token, true, \"upstream video 400\");\n      token.entitlementBlocks.set(\"video\", this.now() + GROK_ENTITLEMENT_BLOCK_MS);\n\n      return { kind: \"failover\", error: cause, transient: false };\n    }\n\n    this.applyHttpFailure(token, requestClass, cause);\n    const { classification } = cause;\n\n    if (classification.kind === \"version_gate\") {\n      return { kind: \"fail\", error: new GrokVersionGateError(classification.minClientVersion) };\n    }\n\n    if (classification.shouldRetry === false) return { kind: \"fail\", error: cause };\n\n    switch (classification.kind) {\n      case \"auth\":\n        if (!presented || !token.credentials) {\n          return { kind: \"failover\", error: cause, transient: false };\n        }\n\n        if (token.credentials.accessToken !== presented.accessToken) {\n          // Stale 401: a newer bearer was installed while this attempt was in flight. It says\n          // nothing about the current credentials, so neither refresh nor mark them; retry them.\n          return { kind: \"retry\", error: cause };\n        }\n\n        if (refreshedThisRequest) {\n          // A 401 with just-refreshed credentials: only a new login recovers.\n          this.markReauthRequired(token, presented, \"grok:unauthorized_after_refresh\");\n\n          return { kind: \"failover\", error: cause, transient: false };\n        }\n\n        if (refreshBudgetLeft) return { kind: \"refresh\", presented };\n\n        return { kind: \"failover\", error: cause, transient: false };\n      case \"rate_limited\":\n      case \"quota_exhausted\":\n        return { kind: \"failover\", error: cause, transient: false };\n      case \"entitlement\":\n        // Chat 403 is permanent for the request (grok-build rule); media fails over once.\n        return requestClass === \"chat\"\n          ? { kind: \"fail\", error: cause }\n          : { kind: \"failover\", error: cause, transient: false };\n      case \"transient\":\n        if (requestClass === \"chat\") return { kind: \"failover\", error: cause, transient: true };\n\n        // Media/voice POSTs are never replayed once the body may have been executed. The media\n        // and voice clients surface such failures as GrokMediaDeliveryError, GrokMediaTimeoutError\n        // or `shouldRetry: false` (all handled above); a status-0 GrokHttpError that reaches this\n        // point is a connect failure that provably happened before any byte was sent, so it fails\n        // over once (transient: GROK_MAX_TRANSIENT_FAILOVERS). An HTTP 5xx never fails over.\n        return cause.status === 0\n          ? { kind: \"failover\", error: cause, transient: true }\n          : { kind: \"fail\", error: cause };\n      default:\n        return { kind: \"fail\", error: cause };\n    }\n  }\n\n  /**\n   * Marks `token` dead in memory and, on the first transition, persists `tokens.reauth_required`.\n   * `credentials` are the ones the failed attempt presented; a token already holding newer ones\n   * (another bearer or refresh token) is left alone.\n   */\n  markReauthRequired(\n    token: GrokTokenState,\n    credentials: GrokCredentials,\n    reasonCode: string,\n  ): void {\n    if (this.tokens.get(token.id) !== token) return;\n\n    if (!sameCredentials(token.credentials, credentials)) return;\n\n    if (token.reauthRequired) return;\n    token.reauthRequired = true;\n    logger.warn(`grok token ${token.name}[${token.id}] requires re-authentication (${reasonCode})`);\n    void this.reportReauthRequired(\n      { id: token.id, name: token.name, credentials },\n      reasonCode,\n    ).catch((cause: unknown) => {\n      logger.warn(\n        `grok token ${token.name}[${token.id}] reauth_required persist failed: ${cause instanceof Error ? cause.name : \"unknown\"}`,\n      );\n    });\n  }\n\n  /**\n   * Runs `attempt` with the §5.1 attempt budget: one forced refresh, at most GROK_MAX_HOPS\n   * failovers (one of them transient). `canRetry` reports whether upstream execution may have\n   * started, in which case nothing is retried.\n   *\n   * The reservation is held from selection until the request leaves the token (failover) or ends,\n   * so a refresh and its same-token retry never step outside the in-flight cap. Whenever the\n   * attempt is about to present credentials other than the ones the token's gates were evaluated\n   * with (a refresh happened), the lookups and gates are re-run before anything is sent.\n   */\n  async withAttempts<T>(\n    requestClass: GrokRequestClass,\n    selection: MediaTokenSelection & { signal: AbortSignal; deadline?: number; ungated?: boolean },\n    attempt: (\n      token: GrokTokenState,\n      credentials: GrokCredentials,\n      state: AttemptState,\n    ) => Promise<T>,\n  ): Promise<T> {\n    const excluded = new Set<number>();\n    const refreshed = new Set<number>();\n    let refreshes = 0;\n    let hops = 0;\n    let transientFailovers = 0;\n    let attempts = 0;\n    let staleRetries = 0;\n    let reservation = await this.selectToken(requestClass, { ...selection, excluded });\n    // The credentials the current token's gates were last evaluated with.\n    let gated = reservation.token.credentials;\n\n    try {\n      for (;;) {\n        const token = reservation.token;\n\n        const state: AttemptState = {\n          upstreamStarted: false,\n          forwarded: false,\n          presented: token.credentials,\n        };\n\n        let action: FailureAction;\n        attempts++;\n\n        try {\n          let credentials: GrokCredentials;\n\n          try {\n            credentials = await this.freshCredentials(token, selection.signal);\n          } catch (error) {\n            if (selection.signal.aborted) throw error;\n            throw new GrokCredentialRefreshError(error);\n          }\n\n          state.presented = credentials;\n\n          const blocked =\n            credentials.accessToken === gated?.accessToken\n              ? undefined\n              : await this.regate(token, requestClass, selection.signal, selection.ungated);\n\n          gated = credentials;\n\n          if (blocked) action = { kind: \"failover\", error: blocked, transient: false };\n          else return await attempt(token, credentials, state);\n        } catch (error) {\n          if (selection.signal.aborted) throw abortReason(selection.signal);\n\n          if (state.forwarded || state.upstreamStarted) throw error;\n          action = this.classifyFailure(\n            token,\n            requestClass,\n            error,\n            state.presented,\n            refreshed.has(token.id),\n            refreshes < GROK_MAX_REFRESHES,\n          );\n        }\n\n        if (action.kind === \"fail\") throw action.error;\n\n        if (action.kind === \"retry\") {\n          // Same token, current credentials, reservation still held.\n          if (staleRetries++ < GROK_MAX_STALE_AUTH_RETRIES) continue;\n          // Allowance spent: this token must not be reselected by the failover below.\n          excluded.add(token.id);\n          action = { kind: \"failover\", error: action.error, transient: false };\n        }\n\n        if (action.kind === \"refresh\") {\n          refreshes++;\n          refreshed.add(token.id);\n          // The reservation stays held across the refresh: the retry is part of this attempt.\n          const next = await this.tryRefresh(token, action.presented, selection.signal);\n\n          if (next.kind === \"refreshed\") continue;\n          action = { kind: \"failover\", error: next.error, transient: false };\n        }\n\n        // Failover: never past an exact target, the hop budget, or one transient retry.\n        if (selection.requirePreferredToken) throw action.error;\n\n        if (action.transient && ++transientFailovers > GROK_MAX_TRANSIENT_FAILOVERS)\n          throw action.error;\n\n        if (++hops > GROK_MAX_HOPS)\n          throw new GrokAttemptBudgetExceededError(attempts, action.error);\n\n        // Rate-limit/quota/reauth state already excludes the token; failures that leave no state\n        // behind must not be retried on the same token within this request.\n        if (action.transient || action.error instanceof GrokCredentialRefreshError)\n          excluded.add(token.id);\n        token.failoverCount++;\n        logger.info(`grok failover from ${token.name}[${token.id}] (${requestClass})`, {\n          reason: action.error instanceof Error ? action.error.message : String(action.error),\n        });\n        reservation.release();\n\n        try {\n          reservation = await this.selectToken(requestClass, {\n            excluded,\n            signal: selection.signal,\n            deadline: selection.deadline,\n          });\n        } catch (selectionError) {\n          if (selectionError instanceof GrokNoWorkersError) throw action.error;\n          throw selectionError;\n        }\n\n        gated = reservation.token.credentials;\n      }\n    } finally {\n      reservation.release();\n    }\n  }\n\n  /**\n   * Re-runs the lookups and gates for a token whose credentials changed after selection. Returns\n   * the gate's error when the token is no longer eligible; the caller still holds one reservation.\n   */\n  private async regate(\n    token: GrokTokenState,\n    requestClass: GrokRequestClass,\n    signal: AbortSignal,\n    ungated?: boolean,\n  ): Promise<Error | undefined> {\n    await this.prefetch(token, signal);\n    signal.throwIfAborted();\n    const reason = this.ineligibility(token, requestClass, this.now(), 1, ungated);\n\n    return reason ? this.preferredError(token, reason) : undefined;\n  }\n\n  /**\n   * The one forced refresh after an upstream 401. A refreshed token is retried; otherwise the\n   * request fails over. Only a `reauth_required` answer marks the token dead — a thrown refresh\n   * failure is treated as transient and leaves the token alive.\n   */\n  private async tryRefresh(\n    token: GrokTokenState,\n    presented: GrokCredentials,\n    signal: AbortSignal,\n  ): Promise<{ kind: \"refreshed\" } | { kind: \"failover\"; error: GrokCredentialRefreshError }> {\n    let result: Awaited<ReturnType<GrokRefresher[\"refreshAfterUnauthorized\"]>>;\n\n    try {\n      result = await this.refresher.refreshAfterUnauthorized(\n        { tokenId: token.id, credentials: presented },\n        signal,\n      );\n    } catch (error) {\n      if (signal.aborted) throw abortReason(signal);\n\n      return { kind: \"failover\", error: new GrokCredentialRefreshError(error) };\n    }\n\n    if (result.status === \"refreshed\") {\n      this.storeCredentials(token, result.credentials);\n\n      return { kind: \"refreshed\" };\n    }\n\n    this.markReauthRequired(token, presented, reauthReasonCode(result.reason));\n\n    return { kind: \"failover\", error: GrokCredentialRefreshError.reauthRequired(result.reason) };\n  }\n\n  async freshCredentials(token: GrokTokenState, signal: AbortSignal): Promise<GrokCredentials> {\n    const current = token.credentials;\n\n    if (!current) throw new GrokNoWorkersError(`grok token ${token.id} has no valid credentials`);\n\n    const fresh = await this.refresher.ensureFresh(\n      { tokenId: token.id, credentials: current },\n      signal,\n    );\n\n    this.storeCredentials(token, fresh);\n\n    return fresh;\n  }\n\n  storeCredentials(token: GrokTokenState, credentials: GrokCredentials): void {\n    // A subscriber update may already have replaced the row; never overwrite newer credentials.\n    if (this.tokens.get(token.id) !== token) return;\n\n    if (token.credentials?.accessToken === credentials.accessToken) return;\n    token.credentials = credentials;\n    token.reauthRequired = false;\n    // Lookups cached (or in flight) under the old bearer may be fail-open lookup_failed results;\n    // a new generation makes the next selection re-read them with this bearer. The cached values\n    // still gate until then (same account), and the subscriber's echo of this row is a no-op.\n    token.generation++;\n    this.pendingBilling.delete(token.id);\n    this.pendingSettings.delete(token.id);\n    this.pendingSubscription.delete(token.id);\n  }\n\n  // ---- Chat ---------------------------------------------------------------\n\n  async generate(req: GenerateRequest): Promise<GenerateResult> {\n    return this.runChat(req);\n  }\n\n  async generateStream(req: GenerateRequest, cb: GenerateStreamCallbacks): Promise<void> {\n    try {\n      cb.onComplete(await this.runChat(req, cb.onDelta));\n    } catch (error) {\n      cb.onError(error instanceof Error ? error : new Error(String(error)));\n      throw error;\n    }\n  }\n\n  buildChatBody(req: GenerateRequest): GrokChatBody {\n    if (req.imageGeneration !== undefined && req.imageGeneration !== false) {\n      throw new GrokInvalidRequestError(\n        \"imageGeneration is not supported on grok chat models; use the Grok image endpoint\",\n      );\n    }\n\n    if (req.imageGenerationOptions !== undefined) {\n      throw new GrokInvalidRequestError(\n        \"imageGenerationOptions is not supported on grok chat models\",\n      );\n    }\n\n    if (req.serviceTier !== undefined) {\n      throw new GrokInvalidRequestError(\"serviceTier is not supported on grok chat models\");\n    }\n\n    // providerOptions.xai: the proxy's acceptance of these fields is unverified, so they are\n    // rejected rather than forwarded or silently dropped.\n    const xai = req.providerOptions?.xai;\n\n    if (isJsonObject(xai)) {\n      for (const key of [\"serviceTier\", \"parallelToolCalls\"] as const) {\n        if (xai[key] !== undefined && xai[key] !== null) {\n          throw new GrokInvalidRequestError(\n            `providerOptions.xai.${key} is not supported on grok chat models: the subscription proxy's handling is unverified`,\n          );\n        }\n      }\n    }\n\n    if (req.thinking === false) {\n      throw new ThinkingValidationError(\n        \"thinking:false is unavailable for Grok models: thinking-off support has not been verified on the subscription proxy\",\n      );\n    }\n\n    const model = this.catalog.resolve(req.model);\n\n    if (!model.known) {\n      // The proxy may serve another model for an unlisted id; the result's model shows which.\n      logger.info(`grok model \"${model.id}\" is not in the catalog; forwarding it unvalidated`);\n    }\n\n    let effort: GrokReasoningEffort = model.defaultEffort;\n\n    if (req.effort !== undefined) {\n      const validated = this.catalog.validateEffort(model.id, req.effort);\n\n      if (validated) effort = validated;\n      else logger.debug(`ignoring effort \"${req.effort}\" for grok/${model.id}`);\n    }\n\n    const history = historyItems(req.coldHistory);\n    const { convId, convGroupId } = grokConversationIds(req.promptCacheKey);\n\n    const turnIdx =\n      history.filter((item) => item.type === \"message\" && item.role === \"user\").length + 1;\n\n    const tools = grokTools(req.tools);\n\n    const body = buildGrokResponsesRequest({\n      model: model.id,\n      systemPrompt: req.systemPrompt,\n      history: [...history, userMessage(req)],\n      promptCacheKey: convId,\n      effort,\n      outputSchema: req.outputSchema === undefined ? undefined : { schema: req.outputSchema },\n      tools,\n    });\n\n    return { body, model, convId, convGroupId, turnIdx };\n  }\n\n  async runChat(req: GenerateRequest, onDelta?: (text: string) => void): Promise<GenerateResult> {\n    const { body, model, convId, convGroupId, turnIdx } = this.buildChatBody(req);\n    const timeoutMs = req.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;\n    const timeout = AbortSignal.timeout(timeoutMs);\n    const signal = req.abortSignal ? AbortSignal.any([req.abortSignal, timeout]) : timeout;\n    signal.throwIfAborted();\n    const deadline = this.now() + timeoutMs;\n\n    return this.withAttempts(\n      \"chat\",\n      {\n        preferredTokenId: req.preferredTokenId,\n        requirePreferredToken: req.requirePreferredToken,\n        signal,\n        deadline,\n      },\n      (token, credentials, state) =>\n        this.chatAttempt(token, credentials, state, {\n          req,\n          body,\n          model,\n          convId,\n          convGroupId,\n          turnIdx,\n          signal,\n          onDelta,\n        }),\n    );\n  }\n\n  async chatAttempt(\n    token: GrokTokenState,\n    credentials: GrokCredentials,\n    state: AttemptState,\n    context: {\n      req: GenerateRequest;\n      body: GrokResponsesRequest;\n      model: GrokResolvedModel;\n      convId: string;\n      convGroupId: string;\n      turnIdx: number;\n      signal: AbortSignal;\n      onDelta?: (text: string) => void;\n    },\n  ): Promise<GenerateResult> {\n    const { req, model } = context;\n    const startedAt = this.now();\n\n    const headers = buildGrokChatHeaders({\n      bearer: credentials.accessToken,\n      model: model.id,\n      convId: context.convId,\n      reqId: randomUUID(),\n      sessionId: credentials.sessionId,\n      agentId: credentials.agentId,\n      userId: credentials.userId,\n      convGroupId: context.convGroupId,\n      turnIdx: context.turnIdx,\n      zstd: true,\n    });\n\n    let stream: Awaited<ReturnType<GrokChatClient[\"stream\"]>>;\n\n    try {\n      stream = await this.client.stream({\n        body: context.body,\n        headers,\n        signal: context.signal,\n        idleTimeoutMs: this.idleTimeoutMs,\n      });\n    } catch (error) {\n      if (error instanceof GrokHttpError)\n        this.observeResponseHeaders(token, credentials, error.responseHeaders);\n      throw error;\n    }\n\n    this.observeResponseHeaders(token, credentials, stream.headers);\n    // A successful chat proves the client version is accepted again.\n    this.versionGate = undefined;\n\n    if (this.catalog.isStale(stream.headers.modelsEtag)) {\n      void this.catalog.refresh(credentials, { fetch: this.fetchImpl }).then((result) => {\n        if (result.kind === \"lookup_failed\")\n          logger.warn(`grok model catalog refresh failed: ${result.reason}`);\n      });\n    }\n\n    let text = \"\";\n    let firstDeltaAt: number | undefined;\n    let usage: GrokUsage | undefined;\n    let servingModel = model.id;\n    let outputMessageAccepted = false;\n    const toolCalls: ProviderToolCall[] = [];\n    let completed = false;\n\n    for await (const event of stream.events) {\n      state.upstreamStarted = true;\n\n      if (event.type === \"created\") {\n        if (event.model) servingModel = event.model;\n      } else if (event.type === \"text-delta\") {\n        if (outputMessageAccepted) continue;\n        firstDeltaAt ??= this.now();\n        text += event.text;\n\n        if (context.onDelta) {\n          state.forwarded = true;\n          context.onDelta(event.text);\n        }\n      } else if (event.type === \"output-item\" && event.completed) {\n        const item = event.item;\n\n        if (item.type === \"function_call\") {\n          const callId = jsonString(item.call_id);\n          const name = jsonString(item.name);\n          const args = jsonString(item.arguments);\n\n          if (callId !== undefined && name !== undefined && args !== undefined) {\n            toolCalls.push({ toolCallId: callId, toolName: name, input: args });\n          }\n        } else if (\n          item.type === \"message\" &&\n          req.stopAfterOutputMessage &&\n          !outputMessageAccepted &&\n          Array.isArray(item.content)\n        ) {\n          const messageText = item.content\n            .map((part) =>\n              isJsonObject(part) && part.type === \"output_text\"\n                ? (jsonString(part.text) ?? \"\")\n                : \"\",\n            )\n            .join(\"\");\n\n          if (messageText) outputMessageAccepted = req.stopAfterOutputMessage(messageText);\n        }\n      } else if (event.type === \"completed\") {\n        completed = true;\n\n        if (event.model) servingModel = event.model;\n        usage = event.usage;\n      } else if (event.type === \"incomplete\") {\n        throw new GrokIncompleteResponseError(event.reason);\n      } else if (event.type === \"error\") {\n        throw event.error;\n      }\n    }\n\n    if (!completed)\n      throw new GrokIncompleteResponseError(\"stream ended without response.completed\");\n\n    const ticks = usage?.costInUsdTicks;\n\n    const contextTokens =\n      usage?.contextInputTokens === undefined && usage?.contextOutputTokens === undefined\n        ? undefined\n        : (usage.contextInputTokens ?? 0) + (usage.contextOutputTokens ?? 0);\n\n    const contextWindow = stream.headers.contextWindow ?? model.contextWindow;\n\n    const resultUsage: GenerateResult[\"usage\"] = {\n      totalTokens: usage?.totalTokens ?? 0,\n      inputTokens: usage?.inputTokens ?? 0,\n      cachedInputTokens: usage?.cachedInputTokens ?? 0,\n      outputTokens: usage?.outputTokens ?? 0,\n      reasoningOutputTokens: usage?.reasoningTokens ?? 0,\n    };\n\n    if (contextTokens !== undefined) resultUsage.contextTokens = contextTokens;\n\n    const xai: XaiProviderMetadata = {};\n\n    if (ticks !== undefined) xai.costInUsdTicks = ticks;\n\n    if (contextWindow !== undefined) xai.contextWindow = contextWindow;\n\n    const result: GenerateResult = {\n      text,\n      tokenName: token.name,\n      usage: resultUsage,\n      durationMs: this.now() - startedAt,\n      ttftMs: firstDeltaAt === undefined ? null : firstDeltaAt - startedAt,\n      model: servingModel,\n      threadCoord: { workerId: token.id, threadId: req.promptCacheKey ?? \"\", epoch: -1 },\n      providerMetadata: { xai },\n    };\n\n    if (servingModel !== model.id) result.requestedModel = model.id;\n\n    if (ticks !== undefined) {\n      result.costUsd = grokTicksToUsd(ticks);\n      result.costSource = \"provider\";\n    }\n\n    if (toolCalls.length) result.toolCalls = toolCalls;\n\n    return result;\n  }\n\n  // ---- Media and voice (§5.7) --------------------------------------------\n\n  async runPort<T>(\n    requestClass: GrokRequestClass,\n    selection: MediaTokenSelection & { ungated?: boolean },\n    signal: AbortSignal | undefined,\n    call: (credentials: GrokCredentials) => Promise<T>,\n  ): Promise<MediaDispatchResult<T>> {\n    const active = signal ?? new AbortController().signal;\n\n    return this.withAttempts(\n      requestClass,\n      {\n        preferredTokenId: selection.preferredTokenId,\n        requirePreferredToken: selection.requirePreferredToken,\n        ungated: selection.ungated,\n        signal: active,\n      },\n      async (token, credentials) => ({\n        result: await call(credentials),\n        tokenId: token.id,\n        tokenName: token.name,\n      }),\n    );\n  }\n\n  requireMedia(): GrokMediaPort {\n    if (!this.media) throw new GrokCapabilityUnavailableError(\"media\");\n\n    return this.media;\n  }\n\n  requireVoice(): GrokVoicePort {\n    if (!this.voice) throw new GrokCapabilityUnavailableError(\"voice\");\n\n    return this.voice;\n  }\n\n  async generateImages(\n    request: GrokImageGenerateRequest & MediaTokenSelection,\n  ): Promise<MediaDispatchResult<GrokImageResponse>> {\n    const media = this.requireMedia();\n    const { preferredTokenId, requirePreferredToken, ...portRequest } = request;\n\n    return this.runPort(\n      \"image\",\n      { preferredTokenId, requirePreferredToken },\n      request.signal,\n      (credentials) => media.generateImages(mediaAuth(credentials), portRequest),\n    );\n  }\n\n  async editImages(\n    request: GrokImageEditRequest & MediaTokenSelection,\n  ): Promise<MediaDispatchResult<GrokImageResponse>> {\n    const media = this.requireMedia();\n    const { preferredTokenId, requirePreferredToken, ...portRequest } = request;\n\n    return this.runPort(\n      \"image\",\n      { preferredTokenId, requirePreferredToken },\n      request.signal,\n      (credentials) => media.editImages(mediaAuth(credentials), portRequest),\n    );\n  }\n\n  async startVideo(\n    request: GrokVideoStartRequest & MediaTokenSelection,\n  ): Promise<MediaDispatchResult<GrokVideoStart>> {\n    const media = this.requireMedia();\n    const { preferredTokenId, requirePreferredToken, ...portRequest } = request;\n\n    return this.runPort(\n      \"video\",\n      { preferredTokenId, requirePreferredToken },\n      request.signal,\n      (credentials) => media.startVideo(mediaAuth(credentials), portRequest),\n    );\n  }\n\n  /**\n   * Polls on the token that started the job; no selection, no failover. The job is already\n   * admitted (and billed), so quota, cooldown and capacity gates must not strand its result.\n   */\n  async getVideo(\n    tokenId: number,\n    requestId: string,\n    signal?: AbortSignal,\n  ): Promise<MediaDispatchResult<GrokVideoStatus>> {\n    const media = this.requireMedia();\n\n    return this.runPort(\n      \"video\",\n      { preferredTokenId: tokenId, requirePreferredToken: true, ungated: true },\n      signal,\n      (credentials) => media.getVideo(mediaAuth(credentials), requestId, signal),\n    );\n  }\n\n  async transcribe(\n    request: GrokTranscribeRequest & MediaTokenSelection,\n  ): Promise<MediaDispatchResult<GrokSttResponse>> {\n    const voice = this.requireVoice();\n    const { preferredTokenId, requirePreferredToken, ...portRequest } = request;\n\n    return this.runPort(\n      \"stt\",\n      { preferredTokenId, requirePreferredToken },\n      request.signal,\n      (credentials) => voice.transcribe(credentials.accessToken, portRequest),\n    );\n  }\n\n  async speak(\n    request: GrokTtsRequest & { signal?: AbortSignal } & MediaTokenSelection,\n  ): Promise<MediaDispatchResult<GrokSpeechResult>> {\n    const voice = this.requireVoice();\n    const { preferredTokenId, requirePreferredToken, ...portRequest } = request;\n\n    return this.runPort(\n      \"tts\",\n      { preferredTokenId, requirePreferredToken },\n      request.signal,\n      (credentials) => voice.speak(credentials.accessToken, portRequest),\n    );\n  }\n\n  // ---- Observability (§5.8) -----------------------------------------------\n\n  tokenStates(): GrokTokenStateSnapshot[] {\n    const now = this.now();\n\n    return [...this.tokens.values()]\n      .map((token): GrokTokenStateSnapshot => {\n        const billing = token.billing?.value;\n        const settings = token.settings?.value;\n\n        return {\n          id: token.id,\n          name: token.name,\n          weight: token.weight,\n          active: token.credentials !== undefined && token.invalidReason === undefined,\n          invalidReason: token.invalidReason ?? null,\n          inFlight: token.inFlight,\n          cooldownUntil: mapRecord(token.cooldowns, now),\n          quotaBlockedUntil: mapRecord(token.quotaBlocks, now),\n          entitlementBlocks: mapRecord(token.entitlementBlocks, now),\n          lastBilling:\n            billing?.kind === \"ok\"\n              ? {\n                  utilizationPct: billing.utilizationPct,\n                  periodType: billing.periodType,\n                  periodEnd: billing.periodEnd,\n                  fetchedAt: token.billing!.fetchedAt,\n                }\n              : null,\n          quotaThreshold: token.quotaThreshold,\n          overThreshold: token.overThreshold,\n          onDemandExcluded: settings?.kind === \"ok\" && settings.onDemandEnabled === true,\n          zdrVideoExcluded: token.zdr === true,\n          lastTier: token.lastTier ?? null,\n          reauthRequired: token.reauthRequired,\n          failoverCount: token.failoverCount,\n        };\n      })\n      .toSorted((a, b) => a.name.localeCompare(b.name));\n  }\n\n  /** Chat-proxy version gate state for the usage endpoint. */\n  versionGateState(): GrokVersionGateState {\n    return {\n      tripped: this.versionGate !== undefined,\n      minClientVersion: this.versionGate?.minClientVersion ?? null,\n      trippedAt: this.versionGate?.trippedAt ?? null,\n    };\n  }\n\n  /** Same shape as OpenAIDispatcher.getQuotaSnapshot; reads caches only. */\n  getQuotaSnapshot(): Array<{\n    name: string;\n    usedPercent: number | null;\n    threshold: number | null;\n    blocked: boolean;\n    resetsAt: number | null;\n    zdrVideoExcluded: boolean;\n  }> {\n    const now = this.now();\n\n    return [...this.tokens.values()]\n      .map((token) => {\n        const billing = token.billing?.value;\n\n        const fresh =\n          billing?.kind === \"ok\" &&\n          token.billing!.generation === token.generation &&\n          now - token.billing!.fetchedAt < GROK_LOOKUP_CACHE_TTL_MS;\n\n        return {\n          name: token.name,\n          usedPercent: fresh ? billing.utilizationPct : null,\n          threshold: token.quotaThreshold,\n          blocked:\n            token.overThreshold || [...token.quotaBlocks.values()].some((until) => until > now),\n          resetsAt: fresh ? billing.periodEndMs : null,\n          zdrVideoExcluded: token.zdr === true,\n        };\n      })\n      .toSorted((a, b) => a.name.localeCompare(b.name));\n  }\n}\n"],"mappings":"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"}