@cartanova/qgrid-cli 2.10.9 → 2.11.0

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

@@ -0,0 +1,119 @@
+import { grokProxyGet } from "./grok-direct-client.js";
+import { buildGrokProxyGetHeaders } from "./grok-headers.js";
+import { GrokBillingConfig, GrokSettings, GrokUserSubscription } from "./grok-types.js";
+//#region src/utils/providers/grok/grok-quota.ts
+function reasonOf(cause) {
+	return cause instanceof Error ? cause.message : String(cause);
+}
+function proxyHeaders(credentials) {
+	return buildGrokProxyGetHeaders({
+		bearer: credentials.accessToken,
+		userId: credentials.userId
+	});
+}
+function numberOrNull(value) {
+	if (value === void 0) return null;
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : null;
+}
+/** `GET {proxy}/billing?format=credits` (camelCase; U0 item 3). */
+async function readGrokBilling(credentials, options = {}) {
+	try {
+		const { json } = await grokProxyGet("/billing?format=credits", {
+			headers: proxyHeaders(credentials),
+			...options
+		});
+		const parsed = GrokBillingConfig.safeParse(json);
+		if (!parsed.success) return {
+			kind: "lookup_failed",
+			reason: `unexpected billing shape: ${parsed.error.message}`
+		};
+		const config = parsed.data.config;
+		if (!Number.isFinite(config.creditUsagePercent)) return {
+			kind: "lookup_failed",
+			reason: "creditUsagePercent unavailable"
+		};
+		const start = Date.parse(config.currentPeriod.start);
+		const end = Date.parse(config.currentPeriod.end);
+		const endMs = Number.isNaN(end) ? null : end;
+		return {
+			kind: "ok",
+			utilizationPct: config.creditUsagePercent,
+			cacheAgeMs: 0,
+			windowDurationMins: endMs !== null && !Number.isNaN(start) && endMs > start ? Math.round((endMs - start) / 6e4) : null,
+			resetsAt: endMs === null ? null : Math.floor(endMs / 1e3),
+			limitId: config.currentPeriod.type,
+			periodType: config.currentPeriod.type,
+			periodStart: config.currentPeriod.start,
+			periodEnd: config.currentPeriod.end,
+			periodEndMs: endMs,
+			prepaidBalance: numberOrNull(config.prepaidBalance?.val),
+			raw: parsed.data
+		};
+	} catch (error) {
+		return {
+			kind: "lookup_failed",
+			reason: reasonOf(error)
+		};
+	}
+}
+/** `GET {proxy}/settings`. */
+async function readGrokSettings(credentials, options = {}) {
+	try {
+		const { json } = await grokProxyGet("/settings", {
+			headers: proxyHeaders(credentials),
+			...options
+		});
+		const parsed = GrokSettings.safeParse(json);
+		if (!parsed.success) return {
+			kind: "lookup_failed",
+			reason: `unexpected settings shape: ${parsed.error.message}`
+		};
+		const settings = parsed.data;
+		return {
+			kind: "ok",
+			onDemandEnabled: settings.on_demand_enabled ?? null,
+			minClientVersion: settings.min_client_version ?? null,
+			defaultModel: settings.default_model ?? null,
+			subscriptionTierDisplay: settings.subscription_tier_display ?? null,
+			imageGenEnabled: settings.image_gen_enabled ?? null,
+			videoGenEnabled: settings.video_gen_enabled ?? null,
+			voiceModeEnabled: settings.voice_mode_enabled ?? null
+		};
+	} catch (error) {
+		return {
+			kind: "lookup_failed",
+			reason: reasonOf(error)
+		};
+	}
+}
+/** `GET {proxy}/user?include=subscription`. */
+async function readGrokSubscription(credentials, options = {}) {
+	try {
+		const { json } = await grokProxyGet("/user?include=subscription", {
+			headers: proxyHeaders(credentials),
+			...options
+		});
+		const parsed = GrokUserSubscription.safeParse(json);
+		if (!parsed.success) return {
+			kind: "lookup_failed",
+			reason: `unexpected user shape: ${parsed.error.message}`
+		};
+		return {
+			kind: "ok",
+			userId: parsed.data.userId,
+			tier: parsed.data.subscriptionTier ?? null,
+			hasGrokCodeAccess: parsed.data.hasGrokCodeAccess ?? null,
+			dataRetentionOptOut: parsed.data.codingDataRetentionOptOut ?? null
+		};
+	} catch (error) {
+		return {
+			kind: "lookup_failed",
+			reason: reasonOf(error)
+		};
+	}
+}
+//#endregion
+export { readGrokBilling, readGrokSettings, readGrokSubscription };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"grok-quota.js","names":[],"sources":["../../../../src/utils/providers/grok/grok-quota.ts"],"sourcesContent":["import { grokProxyGet } from \"./grok-direct-client\";\nimport { buildGrokProxyGetHeaders } from \"./grok-headers\";\nimport {\n  GrokBillingConfig,\n  GrokSettings,\n  GrokUserSubscription,\n  type GrokCredentials,\n} from \"./grok-types\";\n\n// Chat-proxy reads for the quota gate (§5.3). Every reader returns a result union and never\n// throws, so callers can fail open. The `ok` billing shape carries the same fields as\n// OpenAIQuotaUsageResult so usage views can treat both providers alike.\n\nexport interface GrokProxyReadOptions {\n  fetch?: typeof fetch;\n  signal?: AbortSignal;\n  baseUrl?: string;\n  now?: () => number;\n}\n\ntype ProxyCredentials = Pick<GrokCredentials, \"accessToken\" | \"userId\">;\n\nexport type GrokQuotaUsageResult =\n  | {\n      kind: \"ok\";\n      // Same names as OpenAIQuotaUsageResult.\n      utilizationPct: number;\n      cacheAgeMs: number;\n      windowDurationMins: number | null;\n      /** Unix seconds, like the OpenAI wham `resetsAt`. */\n      resetsAt: number | null;\n      limitId: string | null;\n      // Grok specifics.\n      periodType: string;\n      periodStart: string;\n      periodEnd: string;\n      /** Epoch ms of periodEnd, or null when the timestamp is unparseable. */\n      periodEndMs: number | null;\n      prepaidBalance: number | null;\n      raw: GrokBillingConfig;\n    }\n  | { kind: \"lookup_failed\"; reason: string };\n\nfunction reasonOf(cause: unknown): string {\n  return cause instanceof Error ? cause.message : String(cause);\n}\n\nfunction proxyHeaders(credentials: ProxyCredentials): Record<string, string> {\n  return buildGrokProxyGetHeaders({ bearer: credentials.accessToken, userId: credentials.userId });\n}\n\nfunction numberOrNull(value: number | string | undefined): number | null {\n  if (value === undefined) return null;\n  // Number() returns a number argument unchanged and parses a numeric string.\n  const parsed = Number(value);\n\n  return Number.isFinite(parsed) ? parsed : null;\n}\n\n/** `GET {proxy}/billing?format=credits` (camelCase; U0 item 3). */\nexport async function readGrokBilling(\n  credentials: ProxyCredentials,\n  options: GrokProxyReadOptions = {},\n): Promise<GrokQuotaUsageResult> {\n  try {\n    const { json } = await grokProxyGet(\"/billing?format=credits\", {\n      headers: proxyHeaders(credentials),\n      ...options,\n    });\n\n    const parsed = GrokBillingConfig.safeParse(json);\n\n    if (!parsed.success) {\n      return { kind: \"lookup_failed\", reason: `unexpected billing shape: ${parsed.error.message}` };\n    }\n\n    const config = parsed.data.config;\n\n    if (!Number.isFinite(config.creditUsagePercent)) {\n      return { kind: \"lookup_failed\", reason: \"creditUsagePercent unavailable\" };\n    }\n\n    const start = Date.parse(config.currentPeriod.start);\n    const end = Date.parse(config.currentPeriod.end);\n    const endMs = Number.isNaN(end) ? null : end;\n\n    return {\n      kind: \"ok\",\n      utilizationPct: config.creditUsagePercent,\n      cacheAgeMs: 0,\n      windowDurationMins:\n        endMs !== null && !Number.isNaN(start) && endMs > start\n          ? Math.round((endMs - start) / 60_000)\n          : null,\n      resetsAt: endMs === null ? null : Math.floor(endMs / 1000),\n      limitId: config.currentPeriod.type,\n      periodType: config.currentPeriod.type,\n      periodStart: config.currentPeriod.start,\n      periodEnd: config.currentPeriod.end,\n      periodEndMs: endMs,\n      prepaidBalance: numberOrNull(config.prepaidBalance?.val),\n      raw: parsed.data,\n    };\n  } catch (error) {\n    return { kind: \"lookup_failed\", reason: reasonOf(error) };\n  }\n}\n\nexport type GrokSettingsResult =\n  | {\n      kind: \"ok\";\n      /** D6: `true` excludes the token; null/false/absent allows it. */\n      onDemandEnabled: boolean | null;\n      minClientVersion: string | null;\n      defaultModel: string | null;\n      subscriptionTierDisplay: string | null;\n      imageGenEnabled: boolean | null;\n      videoGenEnabled: boolean | null;\n      voiceModeEnabled: boolean | null;\n    }\n  | { kind: \"lookup_failed\"; reason: string };\n\n/** `GET {proxy}/settings`. */\nexport async function readGrokSettings(\n  credentials: ProxyCredentials,\n  options: GrokProxyReadOptions = {},\n): Promise<GrokSettingsResult> {\n  try {\n    const { json } = await grokProxyGet(\"/settings\", {\n      headers: proxyHeaders(credentials),\n      ...options,\n    });\n\n    const parsed = GrokSettings.safeParse(json);\n\n    if (!parsed.success) {\n      return {\n        kind: \"lookup_failed\",\n        reason: `unexpected settings shape: ${parsed.error.message}`,\n      };\n    }\n\n    const settings = parsed.data;\n\n    return {\n      kind: \"ok\",\n      onDemandEnabled: settings.on_demand_enabled ?? null,\n      minClientVersion: settings.min_client_version ?? null,\n      defaultModel: settings.default_model ?? null,\n      subscriptionTierDisplay: settings.subscription_tier_display ?? null,\n      imageGenEnabled: settings.image_gen_enabled ?? null,\n      videoGenEnabled: settings.video_gen_enabled ?? null,\n      voiceModeEnabled: settings.voice_mode_enabled ?? null,\n    };\n  } catch (error) {\n    return { kind: \"lookup_failed\", reason: reasonOf(error) };\n  }\n}\n\nexport type GrokSubscriptionResult =\n  | {\n      kind: \"ok\";\n      userId: string;\n      tier: string | null;\n      hasGrokCodeAccess: boolean | null;\n      /** `codingDataRetentionOptOut`: true means Zero Data Retention is on; null when absent. */\n      dataRetentionOptOut: boolean | null;\n    }\n  | { kind: \"lookup_failed\"; reason: string };\n\n/** `GET {proxy}/user?include=subscription`. */\nexport async function readGrokSubscription(\n  credentials: ProxyCredentials,\n  options: GrokProxyReadOptions = {},\n): Promise<GrokSubscriptionResult> {\n  try {\n    const { json } = await grokProxyGet(\"/user?include=subscription\", {\n      headers: proxyHeaders(credentials),\n      ...options,\n    });\n\n    const parsed = GrokUserSubscription.safeParse(json);\n\n    if (!parsed.success) {\n      return { kind: \"lookup_failed\", reason: `unexpected user shape: ${parsed.error.message}` };\n    }\n\n    return {\n      kind: \"ok\",\n      userId: parsed.data.userId,\n      tier: parsed.data.subscriptionTier ?? null,\n      hasGrokCodeAccess: parsed.data.hasGrokCodeAccess ?? null,\n      dataRetentionOptOut: parsed.data.codingDataRetentionOptOut ?? null,\n    };\n  } catch (error) {\n    return { kind: \"lookup_failed\", reason: reasonOf(error) };\n  }\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,192 @@
+import { grokShellUserAgent } from "./grok-headers.js";
+import { GrokCredentials, decodeGrokJwt } from "./grok-types.js";
+import { GrokTokenResponse, getGrokOAuthEndpoints, readGrokOAuthErrorCode } from "./grok-oauth.js";
+import { getLogger } from "@logtape/logtape";
+import { createHash } from "node:crypto";
+//#region src/utils/providers/grok/grok-refresh.ts
+const logger = getLogger(["qgrid", "grok-refresh"]);
+/** model.rs:9 DEFAULT_EARLY_INVALIDATION_SECS. */
+const GROK_REFRESH_MARGIN_MS = 3e5;
+/** Upper bound of the per-account jitter added to the margin (inclusive). */
+const GROK_REFRESH_JITTER_MAX_MS = 6e4;
+const REFRESH_TIMEOUT_MS = 15e3;
+/** oidc/refresh.rs:21-27: the only codes that end a refresh token's life. */
+const TERMINAL_ERROR_CODES = /* @__PURE__ */ new Set(["invalid_grant", "invalid_client"]);
+/** The refresh token is dead; only a new login recovers. Never retry. */
+var GrokReauthRequiredError = class extends Error {
+	oauthError;
+	status;
+	name = "GrokReauthRequiredError";
+	constructor(oauthError, status) {
+		super(`Grok refresh rejected: HTTP ${status} ${oauthError}`);
+		this.oauthError = oauthError;
+		this.status = status;
+	}
+};
+/** Network failure, timeout, 5xx, 429, or an unrecognized error; the refresh token still lives. */
+var GrokRefreshTransientError = class extends Error {
+	status;
+	oauthError;
+	name = "GrokRefreshTransientError";
+	constructor(message, status, oauthError) {
+		super(message);
+		this.status = status;
+		this.oauthError = oauthError;
+	}
+};
+/** Stable jitter in [0, 60 s] derived from a per-account seed. */
+function grokRefreshJitterMs(seed) {
+	return createHash("sha256").update(`grok-refresh:${seed}`).digest().readUInt32BE(0) % 60001;
+}
+/** True once `expiresAt - 300 s - jitter(userId)` is at or before `now`. */
+function grokNeedsRefresh(credentials, now = Date.now()) {
+	const expiresAt = Date.parse(credentials.expiresAt);
+	if (!Number.isFinite(expiresAt)) return true;
+	return expiresAt - GROK_REFRESH_MARGIN_MS - grokRefreshJitterMs(credentials.userId) <= now;
+}
+function abortable(promise, signal) {
+	if (!signal) return promise;
+	if (signal.aborted) return Promise.reject(signal.reason);
+	return new Promise((resolve, reject) => {
+		const onAbort = () => reject(signal.reason);
+		signal.addEventListener("abort", onAbort, { once: true });
+		promise.then((value) => {
+			signal.removeEventListener("abort", onAbort);
+			resolve(value);
+		}, (cause) => {
+			signal.removeEventListener("abort", onAbort);
+			reject(cause);
+		});
+	});
+}
+var GrokRefreshCoordinator = class {
+	fetchImpl;
+	now;
+	persistPort;
+	inflight = /* @__PURE__ */ new Map();
+	latest = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		this.fetchImpl = options.fetch ?? globalThis.fetch;
+		this.now = options.now ?? Date.now;
+		this.persistPort = options.persist;
+	}
+	needsRefresh(credentials, now = this.now()) {
+		return grokNeedsRefresh(credentials, now);
+	}
+	/**
+	* Refreshes `tokenId`, coalescing concurrent calls into one HTTP request. Resolves only after
+	* `persist` has stored the new credentials.
+	*/
+	refresh(tokenId, credentials, persist) {
+		const existing = this.inflight.get(tokenId);
+		if (existing) return existing;
+		const promise = this.doRefresh(tokenId, this.newest(tokenId, credentials), persist).finally(() => this.inflight.delete(tokenId));
+		this.inflight.set(tokenId, promise);
+		return promise;
+	}
+	async ensureFresh(token, signal) {
+		const current = this.newest(token.tokenId, token.credentials);
+		if (!this.needsRefresh(current)) return current;
+		return abortable(this.refresh(token.tokenId, current, this.portPersist(token.tokenId)), signal);
+	}
+	async refreshAfterUnauthorized(token, signal) {
+		const inflight = this.inflight.get(token.tokenId);
+		const latest = this.latest.get(token.tokenId);
+		if (!inflight && latest && latest.accessToken !== token.credentials.accessToken && !this.needsRefresh(latest)) return {
+			status: "refreshed",
+			credentials: latest
+		};
+		try {
+			return {
+				status: "refreshed",
+				credentials: await abortable(this.refresh(token.tokenId, token.credentials, this.portPersist(token.tokenId)), signal)
+			};
+		} catch (error) {
+			if (error instanceof GrokReauthRequiredError) return {
+				status: "reauth_required",
+				reason: error.oauthError
+			};
+			throw error;
+		}
+	}
+	portPersist(tokenId) {
+		const persist = this.persistPort;
+		if (!persist) return () => Promise.reject(/* @__PURE__ */ new Error("GrokRefreshCoordinator was created without a persist port"));
+		return (next) => persist(tokenId, next);
+	}
+	newest(tokenId, credentials) {
+		const latest = this.latest.get(tokenId);
+		if (!latest || latest.userId !== credentials.userId) return credentials;
+		return Date.parse(latest.expiresAt) > Date.parse(credentials.expiresAt) ? latest : credentials;
+	}
+	async doRefresh(tokenId, credentials, persist) {
+		const { tokenEndpoint } = await getGrokOAuthEndpoints({
+			fetch: this.fetchImpl,
+			now: this.now
+		});
+		let response;
+		try {
+			response = await this.fetchImpl(tokenEndpoint, {
+				method: "POST",
+				headers: {
+					"user-agent": grokShellUserAgent(),
+					"content-type": "application/x-www-form-urlencoded",
+					accept: "application/json"
+				},
+				body: new URLSearchParams([
+					["grant_type", "refresh_token"],
+					["refresh_token", credentials.refreshToken],
+					["client_id", credentials.clientId]
+				]),
+				signal: AbortSignal.timeout(REFRESH_TIMEOUT_MS)
+			});
+		} catch (error) {
+			const reason = error instanceof Error ? error.name : "unknown";
+			logger.warn(`grok refresh network failure token=${tokenId} reason=${reason}`);
+			throw new GrokRefreshTransientError(`Grok refresh request failed (${reason})`);
+		}
+		if (!response.ok) {
+			const oauthError = await readGrokOAuthErrorCode(response);
+			logger.warn(`grok refresh failed token=${tokenId} status=${response.status} code=${oauthError ?? "unknown"}`);
+			if (response.status < 500 && response.status !== 429 && oauthError !== void 0 && TERMINAL_ERROR_CODES.has(oauthError)) throw new GrokReauthRequiredError(oauthError, response.status);
+			throw new GrokRefreshTransientError(`Grok refresh failed: HTTP ${response.status} ${oauthError ?? "unknown"}`, response.status, oauthError);
+		}
+		let body;
+		try {
+			body = await response.json();
+		} catch {
+			throw new GrokRefreshTransientError("Grok refresh response is not JSON", response.status);
+		}
+		const tokens = GrokTokenResponse.safeParse(body);
+		if (!tokens.success) throw new GrokRefreshTransientError("Grok refresh response failed validation", response.status);
+		const rotated = Boolean(tokens.data.refresh_token);
+		const exp = decodeGrokJwt(tokens.data.access_token)?.payload.exp;
+		const expiresIn = tokens.data.expires_in;
+		const expiresAtMs = expiresIn !== void 0 && expiresIn !== null ? this.now() + expiresIn * 1e3 : exp !== void 0 ? exp * 1e3 : void 0;
+		if (expiresAtMs === void 0 || !Number.isFinite(expiresAtMs)) throw new GrokRefreshTransientError("Grok refresh response has no expiry", response.status);
+		const next = GrokCredentials.safeParse({
+			...credentials,
+			accessToken: tokens.data.access_token,
+			refreshToken: tokens.data.refresh_token ?? credentials.refreshToken,
+			expiresAt: new Date(expiresAtMs).toISOString()
+		});
+		if (!next.success) {
+			logger.error(`grok refresh returned unusable credentials token=${tokenId} rotated=${rotated}`);
+			throw new GrokRefreshTransientError("Grok refresh returned an access token that is not an auth.x.ai at+jwt", response.status);
+		}
+		try {
+			await persist(next.data);
+		} catch (error) {
+			if (rotated) this.latest.set(tokenId, next.data);
+			logger.error(`grok refresh persist FAILED token=${tokenId} rotated=${rotated} err=${error instanceof Error ? error.name : "unknown"}`);
+			throw error;
+		}
+		this.latest.set(tokenId, next.data);
+		logger.info(`grok token ${tokenId} refreshed (rotated=${rotated})`);
+		return next.data;
+	}
+};
+//#endregion
+export { GROK_REFRESH_JITTER_MAX_MS, GROK_REFRESH_MARGIN_MS, GrokReauthRequiredError, GrokRefreshCoordinator, GrokRefreshTransientError, grokNeedsRefresh, grokRefreshJitterMs };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"grok-refresh.js","names":[],"sources":["../../../../src/utils/providers/grok/grok-refresh.ts"],"sourcesContent":["// Grok (xAI) token refresh: single-flight per token, early refresh with a stable per-account\n// jitter, refresh-token retention when the IdP does not rotate, persist-before-resolve.\n// Mechanism follows grok-build 1.0.45 xai-grok-login/src (oidc/protocol.rs:413-520,\n// oidc/refresh.rs:21-27,260-264, model.rs:9). grok-build retries transient failures in place\n// (3 attempts); qgrid does not, because the dispatcher owns the per-request attempt budget.\nimport { createHash } from \"node:crypto\";\n\nimport { getLogger } from \"@logtape/logtape\";\n\nimport { grokShellUserAgent } from \"./grok-headers\";\nimport {\n  type GrokFetch,\n  GrokTokenResponse,\n  getGrokOAuthEndpoints,\n  readGrokOAuthErrorCode,\n} from \"./grok-oauth\";\nimport {\n  GrokCredentials,\n  type GrokRefreshResult,\n  type GrokRefresher,\n  type GrokTokenRef,\n  decodeGrokJwt,\n} from \"./grok-types\";\n\nconst logger = getLogger([\"qgrid\", \"grok-refresh\"]);\n\n/** model.rs:9 DEFAULT_EARLY_INVALIDATION_SECS. */\nexport const GROK_REFRESH_MARGIN_MS = 300_000;\n\n/** Upper bound of the per-account jitter added to the margin (inclusive). */\nexport const GROK_REFRESH_JITTER_MAX_MS = 60_000;\nconst REFRESH_TIMEOUT_MS = 15_000;\n\n/** oidc/refresh.rs:21-27: the only codes that end a refresh token's life. */\nconst TERMINAL_ERROR_CODES = new Set([\"invalid_grant\", \"invalid_client\"]);\n\n/** The refresh token is dead; only a new login recovers. Never retry. */\nexport class GrokReauthRequiredError extends Error {\n  override readonly name = \"GrokReauthRequiredError\";\n  constructor(\n    readonly oauthError: string,\n    readonly status: number,\n  ) {\n    super(`Grok refresh rejected: HTTP ${status} ${oauthError}`);\n  }\n}\n\n/** Network failure, timeout, 5xx, 429, or an unrecognized error; the refresh token still lives. */\nexport class GrokRefreshTransientError extends Error {\n  override readonly name = \"GrokRefreshTransientError\";\n  constructor(\n    message: string,\n    readonly status?: number,\n    readonly oauthError?: string,\n  ) {\n    super(message);\n  }\n}\n\n/** Stable jitter in [0, 60 s] derived from a per-account seed. */\nexport function grokRefreshJitterMs(seed: string): number {\n  const digest = createHash(\"sha256\").update(`grok-refresh:${seed}`).digest();\n\n  return digest.readUInt32BE(0) % (GROK_REFRESH_JITTER_MAX_MS + 1);\n}\n\n/** True once `expiresAt - 300 s - jitter(userId)` is at or before `now`. */\nexport function grokNeedsRefresh(credentials: GrokCredentials, now: number = Date.now()): boolean {\n  const expiresAt = Date.parse(credentials.expiresAt);\n\n  if (!Number.isFinite(expiresAt)) return true;\n\n  return expiresAt - GROK_REFRESH_MARGIN_MS - grokRefreshJitterMs(credentials.userId) <= now;\n}\n\nfunction abortable<T>(promise: Promise<T>, signal: AbortSignal | undefined): Promise<T> {\n  if (!signal) return promise;\n\n  if (signal.aborted) return Promise.reject(signal.reason);\n\n  return new Promise<T>((resolve, reject) => {\n    const onAbort = (): void => reject(signal.reason);\n    signal.addEventListener(\"abort\", onAbort, { once: true });\n    promise.then(\n      (value) => {\n        signal.removeEventListener(\"abort\", onAbort);\n        resolve(value);\n      },\n      (cause: unknown) => {\n        signal.removeEventListener(\"abort\", onAbort);\n        reject(cause);\n      },\n    );\n  });\n}\n\nexport type GrokPersistCredentials = (next: GrokCredentials) => Promise<void>;\n\nexport interface GrokRefreshCoordinatorOptions {\n  fetch?: GrokFetch;\n  now?: () => number;\n  /** Persistence used by the `GrokRefresher` port methods (`ensureFresh`, `refreshAfterUnauthorized`). */\n  persist?: (tokenId: number, next: GrokCredentials) => Promise<void>;\n}\n\nexport class GrokRefreshCoordinator implements GrokRefresher {\n  private readonly fetchImpl: GrokFetch;\n  private readonly now: () => number;\n  private readonly persistPort: GrokRefreshCoordinatorOptions[\"persist\"];\n  private readonly inflight = new Map<number, Promise<GrokCredentials>>();\n  // Last credentials this process persisted per token. A caller holding an older snapshot must not\n  // present a refresh token the IdP has already rotated away (that reads as invalid_grant).\n  private readonly latest = new Map<number, GrokCredentials>();\n\n  constructor(options: GrokRefreshCoordinatorOptions = {}) {\n    this.fetchImpl = options.fetch ?? globalThis.fetch;\n    this.now = options.now ?? Date.now;\n    this.persistPort = options.persist;\n  }\n\n  needsRefresh(credentials: GrokCredentials, now: number = this.now()): boolean {\n    return grokNeedsRefresh(credentials, now);\n  }\n\n  /**\n   * Refreshes `tokenId`, coalescing concurrent calls into one HTTP request. Resolves only after\n   * `persist` has stored the new credentials.\n   */\n  refresh(\n    tokenId: number,\n    credentials: GrokCredentials,\n    persist: GrokPersistCredentials,\n  ): Promise<GrokCredentials> {\n    const existing = this.inflight.get(tokenId);\n\n    if (existing) return existing;\n\n    const promise = this.doRefresh(tokenId, this.newest(tokenId, credentials), persist).finally(\n      () => this.inflight.delete(tokenId),\n    );\n\n    this.inflight.set(tokenId, promise);\n\n    return promise;\n  }\n\n  async ensureFresh(token: GrokTokenRef, signal?: AbortSignal): Promise<GrokCredentials> {\n    const current = this.newest(token.tokenId, token.credentials);\n\n    if (!this.needsRefresh(current)) return current;\n\n    return abortable(this.refresh(token.tokenId, current, this.portPersist(token.tokenId)), signal);\n  }\n\n  async refreshAfterUnauthorized(\n    token: GrokTokenRef,\n    signal?: AbortSignal,\n  ): Promise<GrokRefreshResult> {\n    const inflight = this.inflight.get(token.tokenId);\n    const latest = this.latest.get(token.tokenId);\n\n    // Another caller already replaced the rejected access token: reuse it instead of refreshing.\n    if (\n      !inflight &&\n      latest &&\n      latest.accessToken !== token.credentials.accessToken &&\n      !this.needsRefresh(latest)\n    )\n      return { status: \"refreshed\", credentials: latest };\n\n    try {\n      const credentials = await abortable(\n        this.refresh(token.tokenId, token.credentials, this.portPersist(token.tokenId)),\n        signal,\n      );\n\n      return { status: \"refreshed\", credentials };\n    } catch (error) {\n      if (error instanceof GrokReauthRequiredError)\n        return { status: \"reauth_required\", reason: error.oauthError };\n      throw error;\n    }\n  }\n\n  private portPersist(tokenId: number): GrokPersistCredentials {\n    const persist = this.persistPort;\n\n    if (!persist)\n      return () =>\n        Promise.reject(new Error(\"GrokRefreshCoordinator was created without a persist port\"));\n\n    return (next) => persist(tokenId, next);\n  }\n\n  private newest(tokenId: number, credentials: GrokCredentials): GrokCredentials {\n    const latest = this.latest.get(tokenId);\n\n    if (!latest || latest.userId !== credentials.userId) return credentials;\n\n    return Date.parse(latest.expiresAt) > Date.parse(credentials.expiresAt) ? latest : credentials;\n  }\n\n  private async doRefresh(\n    tokenId: number,\n    credentials: GrokCredentials,\n    persist: GrokPersistCredentials,\n  ): Promise<GrokCredentials> {\n    const { tokenEndpoint } = await getGrokOAuthEndpoints({\n      fetch: this.fetchImpl,\n      now: this.now,\n    });\n\n    let response: Response;\n\n    try {\n      response = await this.fetchImpl(tokenEndpoint, {\n        method: \"POST\",\n        // oidc/protocol.rs:493-512: form body only; the shared client contributes the UA.\n        headers: {\n          \"user-agent\": grokShellUserAgent(),\n          \"content-type\": \"application/x-www-form-urlencoded\",\n          accept: \"application/json\",\n        },\n        body: new URLSearchParams([\n          [\"grant_type\", \"refresh_token\"],\n          [\"refresh_token\", credentials.refreshToken],\n          [\"client_id\", credentials.clientId],\n        ]),\n        signal: AbortSignal.timeout(REFRESH_TIMEOUT_MS),\n      });\n    } catch (error) {\n      const reason = error instanceof Error ? error.name : \"unknown\";\n      logger.warn(`grok refresh network failure token=${tokenId} reason=${reason}`);\n      throw new GrokRefreshTransientError(`Grok refresh request failed (${reason})`);\n    }\n\n    if (!response.ok) {\n      const oauthError = await readGrokOAuthErrorCode(response);\n      logger.warn(\n        `grok refresh failed token=${tokenId} status=${response.status} code=${oauthError ?? \"unknown\"}`,\n      );\n\n      // oidc/protocol.rs:413-430: 5xx and 429 are always transient; otherwise only a terminal code\n      // ends the token.\n      if (\n        response.status < 500 &&\n        response.status !== 429 &&\n        oauthError !== undefined &&\n        TERMINAL_ERROR_CODES.has(oauthError)\n      )\n        throw new GrokReauthRequiredError(oauthError, response.status);\n      throw new GrokRefreshTransientError(\n        `Grok refresh failed: HTTP ${response.status} ${oauthError ?? \"unknown\"}`,\n        response.status,\n        oauthError,\n      );\n    }\n\n    let body: unknown;\n\n    try {\n      body = await response.json();\n    } catch {\n      throw new GrokRefreshTransientError(\"Grok refresh response is not JSON\", response.status);\n    }\n\n    const tokens = GrokTokenResponse.safeParse(body);\n\n    if (!tokens.success)\n      throw new GrokRefreshTransientError(\n        \"Grok refresh response failed validation\",\n        response.status,\n      );\n\n    const rotated = Boolean(tokens.data.refresh_token);\n    const exp = decodeGrokJwt(tokens.data.access_token)?.payload.exp;\n\n    const expiresIn = tokens.data.expires_in;\n\n    const expiresAtMs =\n      expiresIn !== undefined && expiresIn !== null\n        ? this.now() + expiresIn * 1000\n        : exp !== undefined\n          ? exp * 1000\n          : undefined;\n\n    if (expiresAtMs === undefined || !Number.isFinite(expiresAtMs))\n      throw new GrokRefreshTransientError(\"Grok refresh response has no expiry\", response.status);\n\n    const next = GrokCredentials.safeParse({\n      ...credentials,\n      accessToken: tokens.data.access_token,\n      // oidc/refresh.rs:260-264: keep the old refresh token when the IdP did not rotate it.\n      refreshToken: tokens.data.refresh_token ?? credentials.refreshToken,\n      expiresAt: new Date(expiresAtMs).toISOString(),\n    });\n\n    if (!next.success) {\n      logger.error(\n        `grok refresh returned unusable credentials token=${tokenId} rotated=${rotated}`,\n      );\n      throw new GrokRefreshTransientError(\n        \"Grok refresh returned an access token that is not an auth.x.ai at+jwt\",\n        response.status,\n      );\n    }\n\n    try {\n      await persist(next.data);\n    } catch (error) {\n      // A rotated refresh token that is not persisted is lost: the next refresh with the old one\n      // fails with invalid_grant. Keep it in memory so this process can still use it.\n      if (rotated) this.latest.set(tokenId, next.data);\n      logger.error(\n        `grok refresh persist FAILED token=${tokenId} rotated=${rotated} err=${error instanceof Error ? error.name : \"unknown\"}`,\n      );\n      throw error;\n    }\n\n    this.latest.set(tokenId, next.data);\n    logger.info(`grok token ${tokenId} refreshed (rotated=${rotated})`);\n\n    return next.data;\n  }\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,186 @@
+import { GROK_AUTH_ISSUER } from "./grok-constants.js";
+import { z } from "zod";
+//#region src/utils/providers/grok/grok-types.ts
+const JwtHeader = z.looseObject({
+	typ: z.string(),
+	alg: z.string().optional()
+});
+const JwtPayload = z.looseObject({
+	iss: z.string(),
+	sub: z.string().optional(),
+	exp: z.number().optional()
+});
+const BASE64URL_SEGMENT = /^[A-Za-z0-9_-]+$/;
+function decodeSegment(segment) {
+	if (!BASE64URL_SEGMENT.test(segment)) return void 0;
+	try {
+		return JSON.parse(Buffer.from(segment, "base64url").toString("utf8"));
+	} catch {
+		return;
+	}
+}
+/** Decodes a compact JWT's header and payload. The signature is never verified. */
+function decodeGrokJwt(token) {
+	const parts = token.split(".");
+	if (parts.length !== 3 || !parts[0] || !parts[1] || !parts[2]) return void 0;
+	const header = JwtHeader.safeParse(decodeSegment(parts[0]));
+	const payload = JwtPayload.safeParse(decodeSegment(parts[1]));
+	if (!header.success || !payload.success) return void 0;
+	return {
+		header: header.data,
+		payload: payload.data
+	};
+}
+/** An RFC 9068 access token (`typ: at+jwt`) issued by auth.x.ai. API keys are rejected. */
+function isGrokAccessToken(token) {
+	const decoded = decodeGrokJwt(token);
+	if (!decoded) return false;
+	const typ = decoded.header.typ.toLowerCase();
+	return (typ === "at+jwt" || typ === "application/at+jwt") && decoded.payload.iss === "https://auth.x.ai";
+}
+const GrokId = z.guid();
+const GrokCredentials = z.object({
+	authMode: z.literal("oauth"),
+	accessToken: z.string().refine(isGrokAccessToken, { message: "accessToken must be an at+jwt access token issued by https://auth.x.ai" }),
+	refreshToken: z.string().min(1),
+	expiresAt: z.iso.datetime({ offset: true }),
+	issuer: z.literal(GROK_AUTH_ISSUER),
+	clientId: z.string().min(1),
+	scopes: z.array(z.string().min(1)),
+	userId: GrokId,
+	sessionId: GrokId,
+	agentId: GrokId,
+	subscriptionTier: z.string().optional()
+});
+/** `GET /billing?format=credits` (camelCase, no on-demand field; U0 item 3). */
+const GrokBillingConfig = z.looseObject({ config: z.looseObject({
+	creditUsagePercent: z.number(),
+	currentPeriod: z.looseObject({
+		type: z.string(),
+		start: z.string(),
+		end: z.string()
+	}),
+	prepaidBalance: z.looseObject({ val: z.union([z.number(), z.string()]) }).optional(),
+	isUnifiedBillingUser: z.boolean().optional(),
+	productUsage: z.array(z.looseObject({
+		product: z.string(),
+		usagePercent: z.number()
+	})).optional()
+}) });
+/** `GET /settings`. `on_demand_enabled: true` excludes the token (D6); null/absent allows. */
+const GrokSettings = z.looseObject({
+	min_client_version: z.string().optional(),
+	force_update: z.boolean().nullish(),
+	default_model: z.string().nullish(),
+	subscription_tier_display: z.string().nullish(),
+	on_demand_enabled: z.boolean().nullish(),
+	image_gen_enabled: z.boolean().nullish(),
+	video_gen_enabled: z.boolean().nullish(),
+	voice_mode_enabled: z.boolean().nullish(),
+	accept_request_encodings: z.array(z.string()).nullish()
+});
+/** `GET /user?include=subscription`. `userId` is the account identity key. */
+const GrokUserSubscription = z.looseObject({
+	userId: GrokId,
+	email: z.string().optional(),
+	subscriptionTier: z.string().nullish(),
+	hasGrokCodeAccess: z.boolean().optional(),
+	/** Zero Data Retention opt-out; `true` was observed while ZDR was on (plan §11). */
+	codingDataRetentionOptOut: z.boolean().nullish()
+});
+const GrokModelReasoningEffort = z.looseObject({
+	id: z.string(),
+	value: z.string(),
+	label: z.string().optional(),
+	default: z.boolean().optional()
+});
+const GrokProxyModel = z.looseObject({
+	id: z.string(),
+	context_window: z.number().int().positive(),
+	context_windows: z.array(z.number().int().positive()).optional(),
+	api_backend: z.string(),
+	reasoning_effort: z.string().nullish(),
+	reasoning_efforts: z.array(GrokModelReasoningEffort).optional(),
+	supports_reasoning_effort: z.boolean().optional()
+});
+/** `GET /models` on the proxy (`{object: "list", data: [...]}`). */
+const GrokModelsResponse = z.looseObject({
+	object: z.string().optional(),
+	data: z.array(GrokProxyModel)
+});
+const ticks = z.number().nonnegative();
+const GrokApiLanguageModel = z.looseObject({
+	id: z.string(),
+	aliases: z.array(z.string()).optional(),
+	context_length: z.number().int().positive().optional(),
+	prompt_text_token_price: ticks,
+	cached_prompt_text_token_price: ticks.optional(),
+	completion_text_token_price: ticks,
+	prompt_image_token_price: ticks.optional(),
+	prompt_text_token_price_long_context: ticks.optional(),
+	cached_prompt_text_token_price_long_context: ticks.optional(),
+	completion_text_token_price_long_context: ticks.optional(),
+	long_context_threshold: z.number().int().positive().optional()
+});
+const GrokApiLanguageModelCatalog = z.union([z.looseObject({ models: z.array(GrokApiLanguageModel) }), z.looseObject({ data: z.array(GrokApiLanguageModel) })]);
+const GrokApiImageModel = z.looseObject({
+	id: z.string(),
+	aliases: z.array(z.string()).optional(),
+	image_price: ticks.optional(),
+	pricing: z.array(z.looseObject({
+		quality: z.string().optional(),
+		resolution: z.string().optional(),
+		price_per_image: ticks
+	})).optional()
+});
+const GrokApiImageModelCatalog = z.union([z.looseObject({ models: z.array(GrokApiImageModel) }), z.looseObject({ data: z.array(GrokApiImageModel) })]);
+/** Model list of either catalog, whichever envelope key the API used. */
+function grokCatalogModels(catalog) {
+	return "models" in catalog ? catalog.models : catalog.data;
+}
+const ticksUsage = z.looseObject({ cost_in_usd_ticks: z.number().int().nonnegative().optional() });
+/** `POST /images/generations` and `/images/edits` with `response_format: "b64_json"`. */
+const GrokImageResponse = z.looseObject({
+	data: z.array(z.looseObject({
+		b64_json: z.string().min(1),
+		mime_type: z.string().optional(),
+		revised_prompt: z.string().nullish(),
+		respect_moderation: z.boolean().optional()
+	})).min(1),
+	usage: ticksUsage.optional()
+});
+/** `POST /videos/generations`. */
+const GrokVideoStart = z.looseObject({ request_id: z.string().min(1) });
+/**
+* `GET /videos/{request_id}`. The result is a URL: `video.url`, else
+* `video.file_output.public_url` (@ai-sdk/xai xai-video-model.ts:693-694, 782-799).
+*/
+const GrokVideoStatus = z.looseObject({
+	status: z.string(),
+	video: z.looseObject({
+		url: z.string().nullish(),
+		duration: z.number().nullish(),
+		file_output: z.looseObject({ public_url: z.string().nullish() }).nullish()
+	}).nullish(),
+	usage: ticksUsage.nullish()
+});
+function grokVideoUrl(status) {
+	return status.video?.url ?? status.video?.file_output?.public_url ?? void 0;
+}
+/** `POST /stt` (multipart). */
+const GrokSttResponse = z.looseObject({
+	text: z.string(),
+	language: z.string().optional(),
+	duration: z.number().nonnegative().optional()
+});
+/** `POST /tts` body; the API answers 422 without `language` (U0). */
+const GrokTtsRequest = z.object({
+	text: z.string().min(1),
+	voice: z.string().min(1),
+	language: z.string().min(1),
+	format: z.string().min(1)
+});
+//#endregion
+export { GrokApiImageModel, GrokApiImageModelCatalog, GrokApiLanguageModel, GrokApiLanguageModelCatalog, GrokBillingConfig, GrokCredentials, GrokImageResponse, GrokModelReasoningEffort, GrokModelsResponse, GrokProxyModel, GrokSettings, GrokSttResponse, GrokTtsRequest, GrokUserSubscription, GrokVideoStart, GrokVideoStatus, decodeGrokJwt, grokCatalogModels, grokVideoUrl, isGrokAccessToken };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"grok-types.js","names":[],"sources":["../../../../src/utils/providers/grok/grok-types.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { type JsonValue } from \"../common/provider-types\";\nimport { GROK_AUTH_ISSUER } from \"./grok-constants\";\n\n// External data (stored credentials, proxy and api.x.ai JSON) is validated with these schemas,\n// never cast. Response schemas are loose: unknown keys pass through so the proxy can add\n// fields without breaking qgrid.\n\n// ---------------------------------------------------------------------------\n// Credentials\n// ---------------------------------------------------------------------------\n\nconst JwtHeader = z.looseObject({ typ: z.string(), alg: z.string().optional() });\n\nconst JwtPayload = z.looseObject({\n  iss: z.string(),\n  sub: z.string().optional(),\n  exp: z.number().optional(),\n});\n\nexport interface DecodedGrokJwt {\n  header: z.infer<typeof JwtHeader>;\n  payload: z.infer<typeof JwtPayload>;\n}\n\nconst BASE64URL_SEGMENT = /^[A-Za-z0-9_-]+$/;\n\nfunction decodeSegment(segment: string): JsonValue | undefined {\n  if (!BASE64URL_SEGMENT.test(segment)) return undefined;\n\n  try {\n    // JSON.parse without a reviver yields only JSON values.\n    const decoded: JsonValue = JSON.parse(Buffer.from(segment, \"base64url\").toString(\"utf8\"));\n\n    return decoded;\n  } catch {\n    return undefined;\n  }\n}\n\n/** Decodes a compact JWT's header and payload. The signature is never verified. */\nexport function decodeGrokJwt(token: string): DecodedGrokJwt | undefined {\n  const parts = token.split(\".\");\n\n  if (parts.length !== 3 || !parts[0] || !parts[1] || !parts[2]) return undefined;\n  const header = JwtHeader.safeParse(decodeSegment(parts[0]));\n  const payload = JwtPayload.safeParse(decodeSegment(parts[1]));\n\n  if (!header.success || !payload.success) return undefined;\n\n  return { header: header.data, payload: payload.data };\n}\n\n/** An RFC 9068 access token (`typ: at+jwt`) issued by auth.x.ai. API keys are rejected. */\nexport function isGrokAccessToken(token: string): boolean {\n  const decoded = decodeGrokJwt(token);\n\n  if (!decoded) return false;\n  const typ = decoded.header.typ.toLowerCase();\n\n  return (\n    (typ === \"at+jwt\" || typ === \"application/at+jwt\") && decoded.payload.iss === GROK_AUTH_ISSUER\n  );\n}\n\n// xAI ids do not always carry RFC 9562 version/variant bits (observed x-request-id\n// `19bfa1b2-a163-9e0c-...`), so ids are checked for the 8-4-4-4-12 hex shape only.\nconst GrokId = z.guid();\n\nexport const GrokCredentials = z.object({\n  authMode: z.literal(\"oauth\"),\n  accessToken: z.string().refine(isGrokAccessToken, {\n    message: \"accessToken must be an at+jwt access token issued by https://auth.x.ai\",\n  }),\n  refreshToken: z.string().min(1),\n  expiresAt: z.iso.datetime({ offset: true }),\n  issuer: z.literal(GROK_AUTH_ISSUER),\n  clientId: z.string().min(1),\n  scopes: z.array(z.string().min(1)),\n  userId: GrokId,\n  sessionId: GrokId,\n  agentId: GrokId,\n  subscriptionTier: z.string().optional(),\n});\n\nexport type GrokCredentials = z.infer<typeof GrokCredentials>;\n\n// ---------------------------------------------------------------------------\n// Chat proxy JSON (cli-chat-proxy.grok.com/v1)\n// ---------------------------------------------------------------------------\n\n/** `GET /billing?format=credits` (camelCase, no on-demand field; U0 item 3). */\nexport const GrokBillingConfig = z.looseObject({\n  config: z.looseObject({\n    creditUsagePercent: z.number(),\n    currentPeriod: z.looseObject({\n      type: z.string(),\n      start: z.string(),\n      end: z.string(),\n    }),\n    prepaidBalance: z.looseObject({ val: z.union([z.number(), z.string()]) }).optional(),\n    isUnifiedBillingUser: z.boolean().optional(),\n    productUsage: z\n      .array(z.looseObject({ product: z.string(), usagePercent: z.number() }))\n      .optional(),\n  }),\n});\n\nexport type GrokBillingConfig = z.infer<typeof GrokBillingConfig>;\n\n/** `GET /settings`. `on_demand_enabled: true` excludes the token (D6); null/absent allows. */\nexport const GrokSettings = z.looseObject({\n  min_client_version: z.string().optional(),\n  force_update: z.boolean().nullish(),\n  default_model: z.string().nullish(),\n  subscription_tier_display: z.string().nullish(),\n  on_demand_enabled: z.boolean().nullish(),\n  image_gen_enabled: z.boolean().nullish(),\n  video_gen_enabled: z.boolean().nullish(),\n  voice_mode_enabled: z.boolean().nullish(),\n  accept_request_encodings: z.array(z.string()).nullish(),\n});\n\nexport type GrokSettings = z.infer<typeof GrokSettings>;\n\n/** `GET /user?include=subscription`. `userId` is the account identity key. */\nexport const GrokUserSubscription = z.looseObject({\n  userId: GrokId,\n  email: z.string().optional(),\n  subscriptionTier: z.string().nullish(),\n  hasGrokCodeAccess: z.boolean().optional(),\n  /** Zero Data Retention opt-out; `true` was observed while ZDR was on (plan §11). */\n  codingDataRetentionOptOut: z.boolean().nullish(),\n});\n\nexport type GrokUserSubscription = z.infer<typeof GrokUserSubscription>;\n\nexport const GrokModelReasoningEffort = z.looseObject({\n  id: z.string(),\n  value: z.string(),\n  label: z.string().optional(),\n  default: z.boolean().optional(),\n});\n\nexport const GrokProxyModel = z.looseObject({\n  id: z.string(),\n  context_window: z.number().int().positive(),\n  context_windows: z.array(z.number().int().positive()).optional(),\n  api_backend: z.string(),\n  reasoning_effort: z.string().nullish(),\n  reasoning_efforts: z.array(GrokModelReasoningEffort).optional(),\n  supports_reasoning_effort: z.boolean().optional(),\n});\n\nexport type GrokProxyModel = z.infer<typeof GrokProxyModel>;\n\n/** `GET /models` on the proxy (`{object: \"list\", data: [...]}`). */\nexport const GrokModelsResponse = z.looseObject({\n  object: z.string().optional(),\n  data: z.array(GrokProxyModel),\n});\n\nexport type GrokModelsResponse = z.infer<typeof GrokModelsResponse>;\n\n// ---------------------------------------------------------------------------\n// Public API JSON (api.x.ai/v1). Prices are ticks (1e-10 USD) per token or per image.\n// ---------------------------------------------------------------------------\n\nconst ticks = z.number().nonnegative();\n\nexport const GrokApiLanguageModel = z.looseObject({\n  id: z.string(),\n  aliases: z.array(z.string()).optional(),\n  context_length: z.number().int().positive().optional(),\n  prompt_text_token_price: ticks,\n  cached_prompt_text_token_price: ticks.optional(),\n  completion_text_token_price: ticks,\n  prompt_image_token_price: ticks.optional(),\n  prompt_text_token_price_long_context: ticks.optional(),\n  cached_prompt_text_token_price_long_context: ticks.optional(),\n  completion_text_token_price_long_context: ticks.optional(),\n  long_context_threshold: z.number().int().positive().optional(),\n});\n\nexport type GrokApiLanguageModel = z.infer<typeof GrokApiLanguageModel>;\n\n// The live envelope of /language-models was not captured; accept either list key.\nexport const GrokApiLanguageModelCatalog = z.union([\n  z.looseObject({ models: z.array(GrokApiLanguageModel) }),\n  z.looseObject({ data: z.array(GrokApiLanguageModel) }),\n]);\n\nexport type GrokApiLanguageModelCatalog = z.infer<typeof GrokApiLanguageModelCatalog>;\n\nexport const GrokApiImageModel = z.looseObject({\n  id: z.string(),\n  aliases: z.array(z.string()).optional(),\n  image_price: ticks.optional(),\n  pricing: z\n    .array(\n      z.looseObject({\n        quality: z.string().optional(),\n        resolution: z.string().optional(),\n        price_per_image: ticks,\n      }),\n    )\n    .optional(),\n});\n\nexport type GrokApiImageModel = z.infer<typeof GrokApiImageModel>;\n\nexport const GrokApiImageModelCatalog = z.union([\n  z.looseObject({ models: z.array(GrokApiImageModel) }),\n  z.looseObject({ data: z.array(GrokApiImageModel) }),\n]);\n\nexport type GrokApiImageModelCatalog = z.infer<typeof GrokApiImageModelCatalog>;\n\n/** Model list of either catalog, whichever envelope key the API used. */\nexport function grokCatalogModels<T>(catalog: { models: T[] } | { data: T[] }): T[] {\n  return \"models\" in catalog ? catalog.models : catalog.data;\n}\n\nconst ticksUsage = z.looseObject({ cost_in_usd_ticks: z.number().int().nonnegative().optional() });\n\n/** `POST /images/generations` and `/images/edits` with `response_format: \"b64_json\"`. */\nexport const GrokImageResponse = z.looseObject({\n  data: z\n    .array(\n      z.looseObject({\n        b64_json: z.string().min(1),\n        mime_type: z.string().optional(),\n        revised_prompt: z.string().nullish(),\n        respect_moderation: z.boolean().optional(),\n      }),\n    )\n    .min(1),\n  usage: ticksUsage.optional(),\n});\n\nexport type GrokImageResponse = z.infer<typeof GrokImageResponse>;\n\n/** `POST /videos/generations`. */\nexport const GrokVideoStart = z.looseObject({ request_id: z.string().min(1) });\n\nexport type GrokVideoStart = z.infer<typeof GrokVideoStart>;\n\n/**\n * `GET /videos/{request_id}`. The result is a URL: `video.url`, else\n * `video.file_output.public_url` (@ai-sdk/xai xai-video-model.ts:693-694, 782-799).\n */\nexport const GrokVideoStatus = z.looseObject({\n  status: z.string(),\n  video: z\n    .looseObject({\n      url: z.string().nullish(),\n      duration: z.number().nullish(),\n      file_output: z.looseObject({ public_url: z.string().nullish() }).nullish(),\n    })\n    .nullish(),\n  usage: ticksUsage.nullish(),\n});\n\nexport type GrokVideoStatus = z.infer<typeof GrokVideoStatus>;\n\nexport function grokVideoUrl(status: GrokVideoStatus): string | undefined {\n  return status.video?.url ?? status.video?.file_output?.public_url ?? undefined;\n}\n\n/** `POST /stt` (multipart). */\nexport const GrokSttResponse = z.looseObject({\n  text: z.string(),\n  language: z.string().optional(),\n  duration: z.number().nonnegative().optional(),\n});\n\nexport type GrokSttResponse = z.infer<typeof GrokSttResponse>;\n\n/** `POST /tts` body; the API answers 422 without `language` (U0). */\nexport const GrokTtsRequest = z.object({\n  text: z.string().min(1),\n  voice: z.string().min(1),\n  language: z.string().min(1),\n  format: z.string().min(1),\n});\n\nexport type GrokTtsRequest = z.infer<typeof GrokTtsRequest>;\n\n// ---------------------------------------------------------------------------\n// Ports (implemented by grok-refresh, grok-media-client, grok-voice-client)\n// ---------------------------------------------------------------------------\n\nexport interface GrokTokenRef {\n  tokenId: number;\n  credentials: GrokCredentials;\n}\n\nexport type GrokRefreshResult =\n  | { status: \"refreshed\"; credentials: GrokCredentials }\n  | { status: \"reauth_required\"; reason: string };\n\nexport interface GrokRefresher {\n  /** Single-flight per token; returns credentials still valid for at least the refresh margin. */\n  ensureFresh(token: GrokTokenRef, signal?: AbortSignal): Promise<GrokCredentials>;\n  /** Forced refresh after a 401; never reuses the rejected access token. */\n  refreshAfterUnauthorized(token: GrokTokenRef, signal?: AbortSignal): Promise<GrokRefreshResult>;\n}\n\nexport interface GrokImageGenerateRequest {\n  model: string;\n  prompt: string;\n  n?: number;\n  aspectRatio?: string;\n  resolution?: string;\n  quality?: string;\n  outputFormat?: string;\n  signal?: AbortSignal;\n}\n\nexport interface GrokImageEditRequest extends GrokImageGenerateRequest {\n  /** Data URLs or https URLs of the reference images. */\n  images: string[];\n}\n\nexport interface GrokVideoStartRequest {\n  model: string;\n  prompt: string;\n  duration?: number;\n  aspectRatio?: string;\n  resolution?: \"480p\" | \"720p\" | \"1080p\";\n  image?: string;\n  lastFrame?: string;\n  referenceImages?: string[];\n  mode?: \"reference-to-video\";\n  signal?: AbortSignal;\n}\n\n/** Per-request identity for api.x.ai Imagine calls: the bearer and the `x-grok-session-id`. */\nexport interface GrokMediaAuth {\n  bearer: string;\n  sessionId: string;\n}\n\nexport interface GrokMediaPort {\n  generateImages(\n    auth: GrokMediaAuth,\n    request: GrokImageGenerateRequest,\n  ): Promise<GrokImageResponse>;\n  editImages(auth: GrokMediaAuth, request: GrokImageEditRequest): Promise<GrokImageResponse>;\n  startVideo(auth: GrokMediaAuth, request: GrokVideoStartRequest): Promise<GrokVideoStart>;\n  getVideo(auth: GrokMediaAuth, requestId: string, signal?: AbortSignal): Promise<GrokVideoStatus>;\n}\n\nexport interface GrokTranscribeRequest {\n  audio: Uint8Array;\n  mediaType: string;\n  model?: string;\n  language?: string;\n  signal?: AbortSignal;\n}\n\nexport interface GrokSpeechResult {\n  audio: Uint8Array;\n  mediaType: string;\n}\n\nexport interface GrokVoicePort {\n  transcribe(bearer: string, request: GrokTranscribeRequest): Promise<GrokSttResponse>;\n  speak(\n    bearer: string,\n    request: GrokTtsRequest & { signal?: AbortSignal },\n  ): Promise<GrokSpeechResult>;\n}\n"],"mappings":"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"}