@cartanova/qgrid-cli 2.10.9 → 2.11.0

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

@@ -0,0 +1,118 @@
+import { GROK_BUILD_VERSION, GROK_CLIENT_IDENTIFIER, GROK_CLIENT_MODE, GROK_COMPACTION_AT, GROK_DOOM_LOOP_CHECK } from "./grok-constants.js";
+import { randomBytes } from "node:crypto";
+//#region src/utils/providers/grok/grok-headers.ts
+/** Maps Node platform/arch to the Rust `std::env::consts` names grok-build reports. */
+function grokPlatform(platform = process.platform, arch = process.arch) {
+	return {
+		os: platform === "darwin" ? "macos" : platform === "win32" ? "windows" : "linux",
+		arch: arch === "arm64" ? "aarch64" : "x86_64"
+	};
+}
+/** `grok-shell/<ver> (<os>; <arch>)` (grok-build 1.0.45 xai-grok-sampler/src/client.rs:457-463). */
+function grokShellUserAgent(platform = grokPlatform()) {
+	return `grok-shell/${GROK_BUILD_VERSION} (${platform.os}; ${platform.arch})`;
+}
+/** `xai-grok-build/<ver>` (grok-build 1.0.45 media_tool_config.rs:104). */
+function grokMediaUserAgent() {
+	return `xai-grok-build/${GROK_BUILD_VERSION}`;
+}
+const TRACEPARENT_PATTERN = /^00-(?!0{32})[0-9a-f]{32}-(?!0{16})[0-9a-f]{16}-01$/;
+/** W3C trace context `00-<trace-id>-<parent-id>-01` with non-zero random ids. */
+function generateTraceparent() {
+	for (;;) {
+		const traceparent = `00-${randomBytes(16).toString("hex")}-${randomBytes(8).toString("hex")}-01`;
+		if (TRACEPARENT_PATTERN.test(traceparent)) return traceparent;
+	}
+}
+function bearerValue(bearer) {
+	if (!bearer || /\s/.test(bearer)) throw new TypeError("Grok bearer token must be non-empty");
+	return `Bearer ${bearer}`;
+}
+function nonNegativeInteger(name, value) {
+	if (!Number.isSafeInteger(value) || value < 0) throw new TypeError(`${name} must be a non-negative integer`);
+	return String(value);
+}
+function requiredValue(name, value) {
+	if (!value || /[\r\n]/.test(value)) throw new TypeError(`${name} must be a non-empty header value`);
+	return value;
+}
+/** Headers for `POST {proxy}/responses`, in the order of the 1.0.60 golden capture. */
+function buildGrokChatHeaders(options) {
+	const traceparent = options.traceparent ?? generateTraceparent();
+	if (!TRACEPARENT_PATTERN.test(traceparent)) throw new TypeError("traceparent must be a W3C 00-<32hex>-<16hex>-01 value");
+	const headers = new Map(Object.entries({
+		"content-type": "application/json",
+		"user-agent": grokShellUserAgent(options.platform),
+		"x-grok-client-mode": GROK_CLIENT_MODE,
+		"x-xai-token-auth": "xai-grok-cli",
+		"x-authenticateresponse": "authenticate-response",
+		"x-compactions-remaining": nonNegativeInteger("compactionsRemaining", options.compactionsRemaining ?? 1),
+		"x-compaction-at": String(GROK_COMPACTION_AT),
+		"x-grok-client-version": GROK_BUILD_VERSION,
+		"x-grok-user-id": requiredValue("userId", options.userId),
+		"x-grok-conv-group-id": requiredValue("convGroupId", options.convGroupId),
+		"x-grok-client-identifier": GROK_CLIENT_IDENTIFIER,
+		authorization: bearerValue(options.bearer),
+		traceparent,
+		"x-grok-conv-id": requiredValue("convId", options.convId),
+		"x-grok-req-id": requiredValue("reqId", options.reqId),
+		"x-grok-model-override": requiredValue("model", options.model),
+		"x-grok-session-id": requiredValue("sessionId", options.sessionId),
+		"x-grok-agent-id": requiredValue("agentId", options.agentId),
+		"x-grok-turn-idx": nonNegativeInteger("turnIdx", options.turnIdx)
+	}));
+	if (options.transientRetry !== void 0) headers.set("x-grok-transient-retry", nonNegativeInteger("transientRetry", options.transientRetry));
+	headers.set("accept", "text/event-stream");
+	headers.set("x-grok-doom-loop-check", String(GROK_DOOM_LOOP_CHECK));
+	headers.set("x-grok-exact-repetition-check", String(64));
+	if (options.zstd) headers.set("content-encoding", "zstd");
+	return Object.fromEntries(headers);
+}
+/**
+* Headers for proxy GETs (`/settings`, `/models`, `/billing`, `/user`). Order follows the
+* 1.0.60 capture of `GET /settings`.
+*/
+function buildGrokProxyGetHeaders(options) {
+	const headers = /* @__PURE__ */ new Map([
+		["authorization", bearerValue(options.bearer)],
+		["x-xai-token-auth", "xai-grok-cli"],
+		["x-userid", requiredValue("userId", options.userId)],
+		["x-grok-client-version", GROK_BUILD_VERSION]
+	]);
+	if (options.email !== void 0) headers.set("x-email", requiredValue("email", options.email));
+	headers.set("x-grok-client-identifier", GROK_CLIENT_IDENTIFIER);
+	headers.set("x-grok-client-mode", GROK_CLIENT_MODE);
+	headers.set("accept", "*/*");
+	headers.set("user-agent", grokShellUserAgent(options.platform));
+	return Object.fromEntries(headers);
+}
+/**
+* Headers for `api.x.ai` image/video calls. The proxy auth trio is never attached.
+* `x-grok-session-id` is attached per request right after the bearer (grok-build xai-grok-tools
+* image_gen/mod.rs:199-213, video_gen/mod.rs:258-270).
+*/
+function buildGrokMediaHeaders(options) {
+	return {
+		"user-agent": grokMediaUserAgent(),
+		authorization: bearerValue(options.bearer),
+		"x-grok-session-id": requiredValue("sessionId", options.sessionId),
+		"x-grok-client-version": GROK_BUILD_VERSION,
+		"x-grok-client-identifier": GROK_CLIENT_IDENTIFIER
+	};
+}
+/**
+* Headers for `api.x.ai` STT/TTS calls (grok-build 1.0.45 xai-grok-pager client_identity.rs).
+* No session id: the voice client sends none (xai-grok-voice stt/streaming.rs:42-57).
+*/
+function buildGrokVoiceHeaders(options) {
+	return {
+		"user-agent": grokShellUserAgent(options.platform),
+		authorization: bearerValue(options.bearer),
+		"x-grok-client-version": GROK_BUILD_VERSION,
+		"x-grok-client-identifier": GROK_CLIENT_IDENTIFIER
+	};
+}
+//#endregion
+export { buildGrokChatHeaders, buildGrokMediaHeaders, buildGrokProxyGetHeaders, buildGrokVoiceHeaders, generateTraceparent, grokMediaUserAgent, grokPlatform, grokShellUserAgent };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"grok-headers.js","names":[],"sources":["../../../../src/utils/providers/grok/grok-headers.ts"],"sourcesContent":["import { randomBytes } from \"node:crypto\";\n\nimport {\n  GROK_BUILD_VERSION,\n  GROK_CLIENT_IDENTIFIER,\n  GROK_CLIENT_MODE,\n  GROK_COMPACTION_AT,\n  GROK_COMPACTIONS_REMAINING_DEFAULT,\n  GROK_DOOM_LOOP_CHECK,\n  GROK_EXACT_REPETITION_CHECK,\n} from \"./grok-constants\";\n\n// Builders return plain lowercase-key records whose insertion order is the wire order the\n// pinned grok-build emits. `host`, `content-length` and `accept-encoding` are left to the\n// transport. The three header families (chat proxy, proxy GET, api.x.ai) are never merged.\n\nexport interface GrokPlatform {\n  os: \"macos\" | \"windows\" | \"linux\";\n  arch: \"aarch64\" | \"x86_64\";\n}\n\n/** Maps Node platform/arch to the Rust `std::env::consts` names grok-build reports. */\nexport function grokPlatform(\n  platform: NodeJS.Platform = process.platform,\n  arch: NodeJS.Architecture = process.arch,\n): GrokPlatform {\n  // grok-build ships only these targets; anything else is reported as the nearest shipped one\n  // so the User-Agent never carries a value the real binary cannot emit.\n  const os = platform === \"darwin\" ? \"macos\" : platform === \"win32\" ? \"windows\" : \"linux\";\n\n  return { os, arch: arch === \"arm64\" ? \"aarch64\" : \"x86_64\" };\n}\n\n/** `grok-shell/<ver> (<os>; <arch>)` (grok-build 1.0.45 xai-grok-sampler/src/client.rs:457-463). */\nexport function grokShellUserAgent(platform: GrokPlatform = grokPlatform()): string {\n  return `grok-shell/${GROK_BUILD_VERSION} (${platform.os}; ${platform.arch})`;\n}\n\n/** `xai-grok-build/<ver>` (grok-build 1.0.45 media_tool_config.rs:104). */\nexport function grokMediaUserAgent(): string {\n  return `xai-grok-build/${GROK_BUILD_VERSION}`;\n}\n\nconst TRACEPARENT_PATTERN = /^00-(?!0{32})[0-9a-f]{32}-(?!0{16})[0-9a-f]{16}-01$/;\n\n/** W3C trace context `00-<trace-id>-<parent-id>-01` with non-zero random ids. */\nexport function generateTraceparent(): string {\n  for (;;) {\n    const traceparent = `00-${randomBytes(16).toString(\"hex\")}-${randomBytes(8).toString(\"hex\")}-01`;\n\n    if (TRACEPARENT_PATTERN.test(traceparent)) return traceparent;\n  }\n}\n\nfunction bearerValue(bearer: string): string {\n  if (!bearer || /\\s/.test(bearer)) throw new TypeError(\"Grok bearer token must be non-empty\");\n\n  return `Bearer ${bearer}`;\n}\n\nfunction nonNegativeInteger(name: string, value: number): string {\n  if (!Number.isSafeInteger(value) || value < 0)\n    throw new TypeError(`${name} must be a non-negative integer`);\n\n  return String(value);\n}\n\nfunction requiredValue(name: string, value: string): string {\n  if (!value || /[\\r\\n]/.test(value))\n    throw new TypeError(`${name} must be a non-empty header value`);\n\n  return value;\n}\n\nexport interface GrokChatHeaderOptions {\n  bearer: string;\n  model: string;\n  convId: string;\n  reqId: string;\n  sessionId: string;\n  agentId: string;\n  userId: string;\n  convGroupId: string;\n  turnIdx: number;\n  traceparent?: string;\n  transientRetry?: number;\n  compactionsRemaining?: number;\n  zstd: boolean;\n  platform?: GrokPlatform;\n}\n\n/** Headers for `POST {proxy}/responses`, in the order of the 1.0.60 golden capture. */\nexport function buildGrokChatHeaders(options: GrokChatHeaderOptions): Record<string, string> {\n  const traceparent = options.traceparent ?? generateTraceparent();\n\n  if (!TRACEPARENT_PATTERN.test(traceparent))\n    throw new TypeError(\"traceparent must be a W3C 00-<32hex>-<16hex>-01 value\");\n\n  // A Map keeps insertion order, which is the wire order of the golden capture.\n  const headers = new Map(\n    Object.entries({\n      \"content-type\": \"application/json\",\n      \"user-agent\": grokShellUserAgent(options.platform),\n      \"x-grok-client-mode\": GROK_CLIENT_MODE,\n      \"x-xai-token-auth\": \"xai-grok-cli\",\n      \"x-authenticateresponse\": \"authenticate-response\",\n      \"x-compactions-remaining\": nonNegativeInteger(\n        \"compactionsRemaining\",\n        options.compactionsRemaining ?? GROK_COMPACTIONS_REMAINING_DEFAULT,\n      ),\n      \"x-compaction-at\": String(GROK_COMPACTION_AT),\n      \"x-grok-client-version\": GROK_BUILD_VERSION,\n      \"x-grok-user-id\": requiredValue(\"userId\", options.userId),\n      \"x-grok-conv-group-id\": requiredValue(\"convGroupId\", options.convGroupId),\n      \"x-grok-client-identifier\": GROK_CLIENT_IDENTIFIER,\n      authorization: bearerValue(options.bearer),\n      traceparent,\n      \"x-grok-conv-id\": requiredValue(\"convId\", options.convId),\n      \"x-grok-req-id\": requiredValue(\"reqId\", options.reqId),\n      \"x-grok-model-override\": requiredValue(\"model\", options.model),\n      \"x-grok-session-id\": requiredValue(\"sessionId\", options.sessionId),\n      \"x-grok-agent-id\": requiredValue(\"agentId\", options.agentId),\n      \"x-grok-turn-idx\": nonNegativeInteger(\"turnIdx\", options.turnIdx),\n    }),\n  );\n\n  // Not present in the capture; grok-build 1.0.45 client.rs:560-605 sends it with the turn\n  // index group on retries only.\n  if (options.transientRetry !== undefined)\n    headers.set(\n      \"x-grok-transient-retry\",\n      nonNegativeInteger(\"transientRetry\", options.transientRetry),\n    );\n  headers.set(\"accept\", \"text/event-stream\");\n  headers.set(\"x-grok-doom-loop-check\", String(GROK_DOOM_LOOP_CHECK));\n  headers.set(\"x-grok-exact-repetition-check\", String(GROK_EXACT_REPETITION_CHECK));\n\n  if (options.zstd) headers.set(\"content-encoding\", \"zstd\");\n\n  return Object.fromEntries(headers);\n}\n\nexport interface GrokProxyGetHeaderOptions {\n  bearer: string;\n  userId: string;\n  email?: string;\n  platform?: GrokPlatform;\n}\n\n/**\n * Headers for proxy GETs (`/settings`, `/models`, `/billing`, `/user`). Order follows the\n * 1.0.60 capture of `GET /settings`.\n */\nexport function buildGrokProxyGetHeaders(\n  options: GrokProxyGetHeaderOptions,\n): Record<string, string> {\n  const headers = new Map([\n    [\"authorization\", bearerValue(options.bearer)],\n    [\"x-xai-token-auth\", \"xai-grok-cli\"],\n    [\"x-userid\", requiredValue(\"userId\", options.userId)],\n    [\"x-grok-client-version\", GROK_BUILD_VERSION],\n  ]);\n\n  if (options.email !== undefined) headers.set(\"x-email\", requiredValue(\"email\", options.email));\n  headers.set(\"x-grok-client-identifier\", GROK_CLIENT_IDENTIFIER);\n  headers.set(\"x-grok-client-mode\", GROK_CLIENT_MODE);\n  headers.set(\"accept\", \"*/*\");\n  headers.set(\"user-agent\", grokShellUserAgent(options.platform));\n\n  return Object.fromEntries(headers);\n}\n\n/**\n * Headers for `api.x.ai` image/video calls. The proxy auth trio is never attached.\n * `x-grok-session-id` is attached per request right after the bearer (grok-build xai-grok-tools\n * image_gen/mod.rs:199-213, video_gen/mod.rs:258-270).\n */\nexport function buildGrokMediaHeaders(options: { bearer: string; sessionId: string }) {\n  return {\n    \"user-agent\": grokMediaUserAgent(),\n    authorization: bearerValue(options.bearer),\n    \"x-grok-session-id\": requiredValue(\"sessionId\", options.sessionId),\n    \"x-grok-client-version\": GROK_BUILD_VERSION,\n    \"x-grok-client-identifier\": GROK_CLIENT_IDENTIFIER,\n  };\n}\n\n/**\n * Headers for `api.x.ai` STT/TTS calls (grok-build 1.0.45 xai-grok-pager client_identity.rs).\n * No session id: the voice client sends none (xai-grok-voice stt/streaming.rs:42-57).\n */\nexport function buildGrokVoiceHeaders(options: { bearer: string; platform?: GrokPlatform }) {\n  return {\n    \"user-agent\": grokShellUserAgent(options.platform),\n    authorization: bearerValue(options.bearer),\n    \"x-grok-client-version\": GROK_BUILD_VERSION,\n    \"x-grok-client-identifier\": GROK_CLIENT_IDENTIFIER,\n  };\n}\n"],"mappings":"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"}

package/bundle/dist/utils/providers/grok/grok-media-client.js

@@ -0,0 +1,420 @@
+import { GROK_IMAGE_DEFAULT_MODEL } from "./grok-constants.js";
+import { GrokProtocolError, classifyGrokHttpError, readGrokResponseHeaders } from "./grok-backend-protocol.js";
+import { GrokHttpError } from "./grok-direct-client.js";
+import { buildGrokMediaHeaders } from "./grok-headers.js";
+import { GrokImageResponse, GrokVideoStart, GrokVideoStatus, grokVideoUrl } from "./grok-types.js";
+import { GrokInvalidRequestError } from "./grok-dispatcher.js";
+import { z } from "zod";
+//#region src/utils/providers/grok/grok-media-client.ts
+const GROK_IMAGE_TOTAL_TIMEOUT_MS = 3e5;
+const GROK_IMAGE_READ_TIMEOUT_MS = 24e4;
+const GROK_VIDEO_START_TIMEOUT_MS = 6e4;
+const GROK_VIDEO_POLL_TIMEOUT_MS = 3e4;
+const GROK_IMAGE_MAX_PER_CALL = 3;
+const GROK_IMAGE_DEFAULT_RESOLUTION = "1k";
+const GROK_IMAGE_EDIT_DEFAULT_MODEL = GROK_IMAGE_DEFAULT_MODEL;
+const GROK_VIDEO_MAX_DURATION_SEC = 15;
+const MAX_IMAGE_RESPONSE_BYTES = 64 * 1024 * 1024;
+const MAX_JSON_RESPONSE_BYTES = 1024 * 1024;
+const MAX_ERROR_BODY_BYTES = 64 * 1024;
+const DEFAULT_TIMEOUTS = {
+	imageTotalMs: GROK_IMAGE_TOTAL_TIMEOUT_MS,
+	imageReadMs: GROK_IMAGE_READ_TIMEOUT_MS,
+	videoStartMs: GROK_VIDEO_START_TIMEOUT_MS,
+	videoPollMs: GROK_VIDEO_POLL_TIMEOUT_MS
+};
+/** Upstream flagged the output with `respect_moderation: false`. Never retried. */
+var GrokContentPolicyError = class extends Error {
+	constructor(kind) {
+		super(`${kind === "image" ? "Image" : "Video"} generation was blocked due to a content policy violation.`);
+		this.name = "GrokContentPolicyError";
+	}
+};
+/** A total or read timeout fired. For a POST, upstream may already be executing the job. */
+var GrokMediaTimeoutError = class extends Error {
+	phase;
+	timeoutMs;
+	constructor(phase, timeoutMs) {
+		super(`Grok media request ${phase === "total" ? "timed out" : "stalled"} after ${timeoutMs} ms`);
+		this.name = "GrokMediaTimeoutError";
+		this.phase = phase;
+		this.timeoutMs = timeoutMs;
+	}
+};
+/** A POST failed after it may have been written; replaying it could run the job twice. */
+var GrokMediaDeliveryError = class extends Error {
+	constructor(message, options) {
+		super(`Grok media request failed after it may have been sent: ${message}`, options);
+		this.name = "GrokMediaDeliveryError";
+	}
+};
+const PRE_SEND_ERROR_CODES = /* @__PURE__ */ new Set([
+	"ECONNREFUSED",
+	"ENOTFOUND",
+	"EAI_AGAIN",
+	"EAI_FAIL",
+	"EHOSTUNREACH",
+	"EHOSTDOWN",
+	"ENETUNREACH",
+	"ENETDOWN",
+	"UND_ERR_CONNECT_TIMEOUT",
+	"ERR_TLS_CERT_ALTNAME_INVALID",
+	"CERT_HAS_EXPIRED",
+	"DEPTH_ZERO_SELF_SIGNED_CERT",
+	"SELF_SIGNED_CERT_IN_CHAIN",
+	"UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
+	"UNABLE_TO_VERIFY_LEAF_SIGNATURE"
+]);
+const ErrorWithCode = z.looseObject({ code: z.string() });
+const ErrorWithCause = z.looseObject({ cause: z.unknown() });
+/** The first `code` along the `cause` chain (undici wraps socket errors in `TypeError`). */
+function errorCode(cause) {
+	let current = cause;
+	for (let depth = 0; depth < 5 && current !== void 0 && current !== null; depth++) {
+		const withCode = ErrorWithCode.safeParse(current);
+		if (withCode.success) return withCode.data.code;
+		const withCause = ErrorWithCause.safeParse(current);
+		current = withCause.success ? withCause.data.cause : void 0;
+	}
+}
+function errorMessage(cause) {
+	return cause instanceof Error ? cause.message : String(cause);
+}
+function abortReason(signal) {
+	const reason = signal.reason;
+	return reason instanceof Error ? reason : new DOMException("Aborted", "AbortError");
+}
+function connectFailure(cause) {
+	const code = errorCode(cause);
+	const message = `${errorMessage(cause)}${code ? ` (${code})` : ""}`;
+	return new GrokHttpError({
+		...classifyGrokHttpError(0, "", {}),
+		message
+	}, "", {}, { cause });
+}
+const BASE64 = /^[A-Za-z0-9+/]*={0,2}$/;
+function sniffImageMediaType(bytes) {
+	if (bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) return "image/jpeg";
+	if (bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) return "image/png";
+	if (bytes[0] === 71 && bytes[1] === 73 && bytes[2] === 70) return "image/gif";
+	const ascii = (from, to) => String.fromCharCode(...bytes.subarray(from, to));
+	if (ascii(0, 4) === "RIFF" && ascii(8, 12) === "WEBP") return "image/webp";
+}
+function assertImagesAllowed(response) {
+	if (response.data.some((image) => image.respect_moderation === false)) throw new GrokContentPolicyError("image");
+	for (const image of response.data) if (image.b64_json.length % 4 !== 0 || !BASE64.test(image.b64_json)) throw new GrokProtocolError("Grok image response carried invalid base64 data");
+}
+/** Decodes a validated image response. `mime_type` wins; otherwise the bytes are sniffed. */
+function decodeGrokImages(response) {
+	assertImagesAllowed(response);
+	const images = response.data.map((image) => {
+		const bytes = new Uint8Array(Buffer.from(image.b64_json, "base64"));
+		const decoded = {
+			bytes,
+			mediaType: image.mime_type?.startsWith("image/") ? image.mime_type : sniffImageMediaType(bytes) ?? "image/jpeg"
+		};
+		if (image.revised_prompt) decoded.revisedPrompt = image.revised_prompt;
+		if (image.respect_moderation !== void 0) decoded.respectModeration = image.respect_moderation;
+		return decoded;
+	});
+	const ticks = response.usage?.cost_in_usd_ticks;
+	const result = { images };
+	if (ticks !== void 0) result.costInUsdTicks = ticks;
+	return result;
+}
+const VideoStatusExtras = z.looseObject({
+	video: z.looseObject({ respect_moderation: z.boolean().nullish() }).nullish(),
+	error: z.looseObject({
+		code: z.string().nullish(),
+		message: z.string().nullish()
+	}).nullish()
+});
+/**
+* Collapses a poll response to the SDK's three outcomes. The URL is returned unchanged (D4);
+* `expired` and a `done` without a URL are failures (xai-video-model.ts:643-705).
+*/
+function summarizeGrokVideoStatus(status) {
+	const extras = VideoStatusExtras.parse(status);
+	if (extras.video?.respect_moderation === false) throw new GrokContentPolicyError("video");
+	const ticks = status.usage?.cost_in_usd_ticks;
+	const base = { mimeType: "video/mp4" };
+	if (ticks !== void 0) base.usageTicks = ticks;
+	if (status.status === "expired") return {
+		...base,
+		status: "failed",
+		error: "Video generation request expired."
+	};
+	if (status.status === "failed") {
+		const error = extras.error?.message ?? extras.error?.code ?? "Video generation failed.";
+		return {
+			...base,
+			status: "failed",
+			error
+		};
+	}
+	if (status.status === "done") {
+		const url = grokVideoUrl(status);
+		if (!url) return {
+			...base,
+			status: "failed",
+			error: "Video generation completed but no video URL was returned."
+		};
+		return {
+			...base,
+			status: "done",
+			url
+		};
+	}
+	return {
+		...base,
+		status: "pending"
+	};
+}
+var BodyLimitError = class extends Error {};
+var GrokMediaClient = class {
+	fetchImpl;
+	baseUrl;
+	timeouts;
+	constructor(options = {}) {
+		this.fetchImpl = options.fetch ?? fetch;
+		this.baseUrl = (options.baseUrl ?? "https://api.x.ai/v1").replace(/\/+$/, "");
+		this.timeouts = {
+			...DEFAULT_TIMEOUTS,
+			...options.timeouts
+		};
+	}
+	async generateImages(auth, request) {
+		const body = imageBody(request, request.model.trim() || "grok-imagine-image-quality");
+		return this.postImages("/images/generations", auth, body, request.signal);
+	}
+	async editImages(auth, request) {
+		if (request.images.length === 0) throw new GrokInvalidRequestError("Grok image edit needs at least one reference image");
+		const urls = request.images.map((url) => {
+			if (!url.trim()) throw new GrokInvalidRequestError("Grok image edit reference must be a non-empty URL");
+			return { url };
+		});
+		const body = imageBody(request, request.model.trim() || GROK_IMAGE_EDIT_DEFAULT_MODEL);
+		if (urls.length === 1) body.image = urls[0];
+		else body.images = urls;
+		return this.postImages("/images/edits", auth, body, request.signal);
+	}
+	async startVideo(auth, request) {
+		const body = videoBody(request);
+		const { text } = await this.call({
+			method: "POST",
+			path: "/videos/generations",
+			auth,
+			body,
+			totalMs: this.timeouts.videoStartMs,
+			readMs: this.timeouts.videoStartMs,
+			maxBytes: MAX_JSON_RESPONSE_BYTES,
+			signal: request.signal
+		});
+		return parseJson(GrokVideoStart, text, "video start");
+	}
+	async getVideo(auth, requestId, signal) {
+		if (!requestId.trim()) throw new TypeError("Grok video request id must be non-empty");
+		const { response, text } = await this.call({
+			method: "GET",
+			path: `/videos/${encodeURIComponent(requestId)}`,
+			auth,
+			totalMs: this.timeouts.videoPollMs,
+			readMs: this.timeouts.videoPollMs,
+			maxBytes: MAX_JSON_RESPONSE_BYTES,
+			signal
+		});
+		const status = parseVideoStatus(response.status, text);
+		if (VideoStatusExtras.parse(status).video?.respect_moderation === false) throw new GrokContentPolicyError("video");
+		return status;
+	}
+	async postImages(path, auth, body, signal) {
+		const { text } = await this.call({
+			method: "POST",
+			path,
+			auth,
+			body,
+			totalMs: this.timeouts.imageTotalMs,
+			readMs: this.timeouts.imageReadMs,
+			maxBytes: MAX_IMAGE_RESPONSE_BYTES,
+			signal
+		});
+		const response = parseJson(GrokImageResponse, text, "image");
+		assertImagesAllowed(response);
+		return response;
+	}
+	/** One HTTP exchange with total and read timeouts composed with the caller's signal. */
+	async call(call) {
+		const { signal } = call;
+		if (signal?.aborted) throw abortReason(signal);
+		const headers = {
+			"content-type": "application/json",
+			...buildGrokMediaHeaders({
+				bearer: call.auth.bearer,
+				sessionId: call.auth.sessionId
+			})
+		};
+		const controller = new AbortController();
+		let timeout;
+		const fire = (error) => {
+			if (timeout || controller.signal.aborted) return;
+			timeout = error;
+			controller.abort(error);
+		};
+		const totalTimer = setTimeout(() => fire(new GrokMediaTimeoutError("total", call.totalMs)), call.totalMs);
+		let readTimer;
+		const armRead = () => {
+			clearTimeout(readTimer);
+			readTimer = setTimeout(() => fire(new GrokMediaTimeoutError("read", call.readMs)), call.readMs);
+		};
+		const onAbort = () => controller.abort(signal?.reason);
+		signal?.addEventListener("abort", onAbort, { once: true });
+		const settle = (cause, responded) => {
+			if (signal?.aborted) return abortReason(signal);
+			if (timeout) return timeout;
+			if (cause instanceof GrokProtocolError || cause instanceof GrokHttpError) return cause;
+			if (call.method === "GET") return connectFailure(cause);
+			if (!responded && PRE_SEND_ERROR_CODES.has(errorCode(cause) ?? "")) return connectFailure(cause);
+			return new GrokMediaDeliveryError(errorMessage(cause), { cause });
+		};
+		try {
+			armRead();
+			let response;
+			try {
+				response = await this.fetchImpl(`${this.baseUrl}${call.path}`, {
+					method: call.method,
+					headers,
+					body: call.body === void 0 ? void 0 : JSON.stringify(call.body),
+					signal: controller.signal
+				});
+			} catch (error) {
+				throw settle(error, false);
+			}
+			armRead();
+			try {
+				if (!response.ok) {
+					const bodyText = await readBody(response, MAX_ERROR_BODY_BYTES, armRead, true);
+					throw new GrokHttpError(classifyGrokHttpError(response.status, bodyText, response.headers), bodyText, readGrokResponseHeaders(response.headers));
+				}
+				const text = await readBody(response, call.maxBytes, armRead, false);
+				return {
+					response,
+					text
+				};
+			} catch (error) {
+				if (error instanceof BodyLimitError) throw new GrokProtocolError(error.message);
+				throw settle(error, true);
+			}
+		} finally {
+			clearTimeout(totalTimer);
+			clearTimeout(readTimer);
+			signal?.removeEventListener("abort", onAbort);
+		}
+	}
+};
+function imageBody(request, model) {
+	const n = request.n ?? 1;
+	if (!Number.isSafeInteger(n) || n < 1 || n > 3) throw new RangeError(`Grok image count must be an integer from 1 to 3`);
+	return {
+		model,
+		prompt: request.prompt,
+		n,
+		aspect_ratio: request.aspectRatio,
+		resolution: request.resolution ?? GROK_IMAGE_DEFAULT_RESOLUTION,
+		response_format: "b64_json",
+		quality: request.quality,
+		output_format: request.outputFormat
+	};
+}
+function videoBody(request) {
+	const references = request.referenceImages ?? [];
+	if (request.mode === "reference-to-video" && references.length === 0) throw new GrokInvalidRequestError("Grok reference-to-video needs at least one reference image");
+	const { duration } = request;
+	if (duration !== void 0 && (!Number.isSafeInteger(duration) || duration < 1 || duration > GROK_VIDEO_MAX_DURATION_SEC)) throw new GrokInvalidRequestError(`Grok video duration must be an integer from 1 to ${GROK_VIDEO_MAX_DURATION_SEC}`);
+	return {
+		model: request.model.trim() || "grok-imagine-video-1.5",
+		prompt: request.prompt,
+		image: request.image === void 0 ? void 0 : { url: request.image },
+		duration,
+		aspect_ratio: request.aspectRatio,
+		resolution: request.resolution,
+		reference_images: references.length === 0 ? void 0 : references.map((url) => ({ url })),
+		last_frame: request.lastFrame === void 0 ? void 0 : { url: request.lastFrame }
+	};
+}
+function parseJsonText(text, what) {
+	try {
+		return JSON.parse(text);
+	} catch {
+		throw new GrokProtocolError(`Grok ${what} response is not JSON`);
+	}
+}
+function parseJson(schema, text, what) {
+	const parsed = schema.safeParse(parseJsonText(text, what));
+	if (!parsed.success) throw new GrokProtocolError(`Grok ${what} response has an unexpected shape`);
+	return parsed.data;
+}
+const JsonObject = z.record(z.string(), z.unknown());
+const LooseVideoStatus = z.looseObject({
+	status: z.string().nullish(),
+	video: z.looseObject({ url: z.string().nullish() }).nullish()
+});
+/**
+* 202 means pending, possibly with an empty or partial body (xai-video-model.ts:876-894;
+* grok-build video_gen/mod.rs:442 accepts it too). A 200 without `status` but with a video URL
+* is done (xai-video-model.ts:673-676).
+*/
+function parseVideoStatus(httpStatus, text) {
+	if (httpStatus === 202) {
+		if (!text.trim()) return { status: "pending" };
+		let json;
+		try {
+			json = JSON.parse(text);
+		} catch {
+			return { status: "pending" };
+		}
+		const object = JsonObject.safeParse(json);
+		const loose = LooseVideoStatus.safeParse(json);
+		if (!object.success || !loose.success) return { status: "pending" };
+		const parsed = GrokVideoStatus.safeParse({
+			...object.data,
+			status: loose.data.status ?? "pending"
+		});
+		return parsed.success ? parsed.data : { status: "pending" };
+	}
+	const json = parseJsonText(text, "video status");
+	const object = JsonObject.safeParse(json);
+	const loose = LooseVideoStatus.safeParse(json);
+	if (!object.success || !loose.success) throw new GrokProtocolError("Grok video status response has an unexpected shape");
+	const status = loose.data.status ?? (loose.data.video?.url ? "done" : "pending");
+	const parsed = GrokVideoStatus.safeParse({
+		...object.data,
+		status
+	});
+	if (!parsed.success) throw new GrokProtocolError("Grok video status response has an unexpected shape");
+	return parsed.data;
+}
+/** Reads the body, re-arming the read timer per chunk. `truncate` caps instead of failing. */
+async function readBody(response, maxBytes, onChunk, truncate) {
+	if (!response.body) return "";
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let text = "";
+	let total = 0;
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		onChunk();
+		total += value.byteLength;
+		if (total > maxBytes) {
+			await reader.cancel().catch(() => void 0);
+			if (truncate) return text + decoder.decode(value.subarray(0, maxBytes - (total - value.byteLength)));
+			throw new BodyLimitError(`Grok media response exceeded ${maxBytes} bytes`);
+		}
+		text += decoder.decode(value, { stream: true });
+	}
+	return text + decoder.decode();
+}
+//#endregion
+export { GROK_IMAGE_MAX_PER_CALL, GROK_IMAGE_READ_TIMEOUT_MS, GROK_IMAGE_TOTAL_TIMEOUT_MS, GROK_VIDEO_POLL_TIMEOUT_MS, GROK_VIDEO_START_TIMEOUT_MS, GrokContentPolicyError, GrokMediaClient, GrokMediaDeliveryError, GrokMediaTimeoutError, decodeGrokImages, summarizeGrokVideoStatus };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"grok-media-client.js","names":[],"sources":["../../../../src/utils/providers/grok/grok-media-client.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { type JsonValue } from \"../common/provider-types\";\nimport {\n  classifyGrokHttpError,\n  GrokProtocolError,\n  readGrokResponseHeaders,\n} from \"./grok-backend-protocol\";\nimport {\n  GROK_IMAGE_DEFAULT_MODEL,\n  GROK_PUBLIC_API_URL,\n  GROK_VIDEO_DEFAULT_MODEL,\n} from \"./grok-constants\";\nimport { GrokHttpError } from \"./grok-direct-client\";\nimport { GrokInvalidRequestError } from \"./grok-dispatcher\";\nimport { buildGrokMediaHeaders } from \"./grok-headers\";\nimport {\n  GrokImageResponse,\n  GrokVideoStart,\n  GrokVideoStatus,\n  grokVideoUrl,\n  type GrokImageEditRequest,\n  type GrokImageGenerateRequest,\n  type GrokMediaAuth,\n  type GrokMediaPort,\n  type GrokVideoStartRequest,\n} from \"./grok-types\";\n\n// api.x.ai Imagine client (images + video). Bodies are plain JSON: grok-build sends them with\n// reqwest `.json(payload)` and no content-encoding (1.0.45 xai-grok-tools image_gen/mod.rs:199-214,\n// image_edit/mod.rs:398, video_gen/mod.rs:364-367). Every request carries `content-type:\n// application/json` because grok-build installs it as a client default header, GET included\n// (image_gen/mod.rs:104-105, video_gen/mod.rs:185-186).\n//\n// Retry safety (plan §5.5): this client never retries. A POST that may have reached upstream\n// fails with GrokMediaDeliveryError or GrokMediaTimeoutError, which the dispatcher cannot\n// classify and therefore never replays. Only a connect failure that provably happened before\n// the request was written becomes a transient GrokHttpError (status 0); the dispatcher fails\n// over on exactly that error once. GETs (video polls) also map every transport failure to\n// status 0: they are idempotent, and the dispatcher pins polls to their token.\n\n// image_gen/mod.rs:37-38 (the proxy buffers the whole image before the first byte)\nexport const GROK_IMAGE_TOTAL_TIMEOUT_MS = 300_000;\nexport const GROK_IMAGE_READ_TIMEOUT_MS = 240_000;\n\n// video_gen/mod.rs:37,40\nexport const GROK_VIDEO_START_TIMEOUT_MS = 60_000;\nexport const GROK_VIDEO_POLL_TIMEOUT_MS = 30_000;\n\n// @ai-sdk/xai xai-image-model.ts maxImagesPerCall\nexport const GROK_IMAGE_MAX_PER_CALL = 3;\n\n// grok-build image_gen/mod.rs:236 and image_edit/mod.rs:367 always send \"1k\"\nconst GROK_IMAGE_DEFAULT_RESOLUTION = \"1k\";\n\n// image_edit/mod.rs:28 (XAI_IMAGINE_EDIT_MODEL equals the generation default)\nconst GROK_IMAGE_EDIT_DEFAULT_MODEL = GROK_IMAGE_DEFAULT_MODEL;\n\n// @ai-sdk/xai video duration range 1-15 s (plan §3.6)\nconst GROK_VIDEO_MAX_DURATION_SEC = 15;\n\nconst MAX_IMAGE_RESPONSE_BYTES = 64 * 1024 * 1024;\nconst MAX_JSON_RESPONSE_BYTES = 1024 * 1024;\nconst MAX_ERROR_BODY_BYTES = 64 * 1024;\n\nexport interface GrokMediaTimeouts {\n  imageTotalMs: number;\n  imageReadMs: number;\n  videoStartMs: number;\n  videoPollMs: number;\n}\n\nconst DEFAULT_TIMEOUTS: GrokMediaTimeouts = {\n  imageTotalMs: GROK_IMAGE_TOTAL_TIMEOUT_MS,\n  imageReadMs: GROK_IMAGE_READ_TIMEOUT_MS,\n  videoStartMs: GROK_VIDEO_START_TIMEOUT_MS,\n  videoPollMs: GROK_VIDEO_POLL_TIMEOUT_MS,\n};\n\n/** Upstream flagged the output with `respect_moderation: false`. Never retried. */\nexport class GrokContentPolicyError extends Error {\n  constructor(kind: \"image\" | \"video\") {\n    super(\n      `${kind === \"image\" ? \"Image\" : \"Video\"} generation was blocked due to a content policy violation.`,\n    );\n    this.name = \"GrokContentPolicyError\";\n  }\n}\n\n/** A total or read timeout fired. For a POST, upstream may already be executing the job. */\nexport class GrokMediaTimeoutError extends Error {\n  readonly phase: \"total\" | \"read\";\n  readonly timeoutMs: number;\n\n  constructor(phase: \"total\" | \"read\", timeoutMs: number) {\n    super(\n      `Grok media request ${phase === \"total\" ? \"timed out\" : \"stalled\"} after ${timeoutMs} ms`,\n    );\n    this.name = \"GrokMediaTimeoutError\";\n    this.phase = phase;\n    this.timeoutMs = timeoutMs;\n  }\n}\n\n/** A POST failed after it may have been written; replaying it could run the job twice. */\nexport class GrokMediaDeliveryError extends Error {\n  constructor(message: string, options?: ErrorOptions) {\n    super(`Grok media request failed after it may have been sent: ${message}`, options);\n    this.name = \"GrokMediaDeliveryError\";\n  }\n}\n\nexport interface GrokMediaClientOptions {\n  fetch?: typeof fetch;\n  baseUrl?: string;\n  timeouts?: Partial<GrokMediaTimeouts>;\n}\n\n// Error codes raised while resolving or connecting, i.e. before any request byte was written.\nconst PRE_SEND_ERROR_CODES = new Set([\n  \"ECONNREFUSED\",\n  \"ENOTFOUND\",\n  \"EAI_AGAIN\",\n  \"EAI_FAIL\",\n  \"EHOSTUNREACH\",\n  \"EHOSTDOWN\",\n  \"ENETUNREACH\",\n  \"ENETDOWN\",\n  \"UND_ERR_CONNECT_TIMEOUT\",\n  \"ERR_TLS_CERT_ALTNAME_INVALID\",\n  \"CERT_HAS_EXPIRED\",\n  \"DEPTH_ZERO_SELF_SIGNED_CERT\",\n  \"SELF_SIGNED_CERT_IN_CHAIN\",\n  \"UNABLE_TO_GET_ISSUER_CERT_LOCALLY\",\n  \"UNABLE_TO_VERIFY_LEAF_SIGNATURE\",\n]);\n\nconst ErrorWithCode = z.looseObject({ code: z.string() });\nconst ErrorWithCause = z.looseObject({ cause: z.unknown() });\n\n/** The first `code` along the `cause` chain (undici wraps socket errors in `TypeError`). */\nfunction errorCode(cause: unknown): string | undefined {\n  let current: unknown = cause;\n\n  for (let depth = 0; depth < 5 && current !== undefined && current !== null; depth++) {\n    const withCode = ErrorWithCode.safeParse(current);\n\n    if (withCode.success) return withCode.data.code;\n    const withCause = ErrorWithCause.safeParse(current);\n    current = withCause.success ? withCause.data.cause : undefined;\n  }\n\n  return undefined;\n}\n\nfunction errorMessage(cause: unknown): string {\n  return cause instanceof Error ? cause.message : String(cause);\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\nfunction connectFailure(cause: unknown): GrokHttpError {\n  const code = errorCode(cause);\n  const message = `${errorMessage(cause)}${code ? ` (${code})` : \"\"}`;\n\n  return new GrokHttpError({ ...classifyGrokHttpError(0, \"\", {}), message }, \"\", {}, { cause });\n}\n\nconst BASE64 = /^[A-Za-z0-9+/]*={0,2}$/;\n\nfunction sniffImageMediaType(bytes: Uint8Array): string | undefined {\n  if (bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) return \"image/jpeg\";\n\n  if (bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47)\n    return \"image/png\";\n\n  if (bytes[0] === 0x47 && bytes[1] === 0x49 && bytes[2] === 0x46) return \"image/gif\";\n  const ascii = (from: number, to: number) => String.fromCharCode(...bytes.subarray(from, to));\n\n  if (ascii(0, 4) === \"RIFF\" && ascii(8, 12) === \"WEBP\") return \"image/webp\";\n\n  return undefined;\n}\n\nexport interface GrokDecodedImage {\n  bytes: Uint8Array;\n  mediaType: string;\n  revisedPrompt?: string;\n  respectModeration?: boolean;\n}\n\nexport interface GrokDecodedImages {\n  images: GrokDecodedImage[];\n  costInUsdTicks?: number;\n}\n\nfunction assertImagesAllowed(response: GrokImageResponse): void {\n  if (response.data.some((image) => image.respect_moderation === false))\n    throw new GrokContentPolicyError(\"image\");\n\n  for (const image of response.data) {\n    if (image.b64_json.length % 4 !== 0 || !BASE64.test(image.b64_json))\n      throw new GrokProtocolError(\"Grok image response carried invalid base64 data\");\n  }\n}\n\n/** Decodes a validated image response. `mime_type` wins; otherwise the bytes are sniffed. */\nexport function decodeGrokImages(response: GrokImageResponse): GrokDecodedImages {\n  assertImagesAllowed(response);\n\n  const images = response.data.map((image): GrokDecodedImage => {\n    const bytes = new Uint8Array(Buffer.from(image.b64_json, \"base64\"));\n\n    const mediaType = image.mime_type?.startsWith(\"image/\")\n      ? image.mime_type\n      : (sniffImageMediaType(bytes) ?? \"image/jpeg\");\n\n    const decoded: GrokDecodedImage = { bytes, mediaType };\n\n    if (image.revised_prompt) decoded.revisedPrompt = image.revised_prompt;\n\n    if (image.respect_moderation !== undefined) {\n      decoded.respectModeration = image.respect_moderation;\n    }\n\n    return decoded;\n  });\n\n  const ticks = response.usage?.cost_in_usd_ticks;\n  const result: GrokDecodedImages = { images };\n\n  if (ticks !== undefined) result.costInUsdTicks = ticks;\n\n  return result;\n}\n\n// Fields @ai-sdk/xai reads that grok-types' GrokVideoStatus leaves loose\n// (xai-video-model.ts:782-812): `respect_moderation` nests under `video`.\nconst VideoStatusExtras = z.looseObject({\n  video: z.looseObject({ respect_moderation: z.boolean().nullish() }).nullish(),\n  error: z.looseObject({ code: z.string().nullish(), message: z.string().nullish() }).nullish(),\n});\n\nexport interface GrokVideoSummary {\n  status: \"pending\" | \"done\" | \"failed\";\n  url?: string;\n  mimeType: \"video/mp4\";\n  usageTicks?: number;\n  error?: string;\n}\n\n/**\n * Collapses a poll response to the SDK's three outcomes. The URL is returned unchanged (D4);\n * `expired` and a `done` without a URL are failures (xai-video-model.ts:643-705).\n */\nexport function summarizeGrokVideoStatus(status: GrokVideoStatus): GrokVideoSummary {\n  const extras = VideoStatusExtras.parse(status);\n\n  if (extras.video?.respect_moderation === false) throw new GrokContentPolicyError(\"video\");\n  const ticks = status.usage?.cost_in_usd_ticks;\n\n  const base: Omit<GrokVideoSummary, \"status\"> = { mimeType: \"video/mp4\" };\n\n  if (ticks !== undefined) base.usageTicks = ticks;\n\n  if (status.status === \"expired\")\n    return { ...base, status: \"failed\", error: \"Video generation request expired.\" };\n\n  if (status.status === \"failed\") {\n    const error = extras.error?.message ?? extras.error?.code ?? \"Video generation failed.\";\n\n    return { ...base, status: \"failed\", error };\n  }\n\n  if (status.status === \"done\") {\n    const url = grokVideoUrl(status);\n\n    if (!url)\n      return {\n        ...base,\n        status: \"failed\",\n        error: \"Video generation completed but no video URL was returned.\",\n      };\n\n    return { ...base, status: \"done\", url };\n  }\n\n  return { ...base, status: \"pending\" };\n}\n\ninterface MediaCall {\n  method: \"GET\" | \"POST\";\n  path: string;\n  auth: GrokMediaAuth;\n  body?: GrokImageBody | GrokVideoBody;\n  totalMs: number;\n  readMs: number;\n  maxBytes: number;\n  signal: AbortSignal | undefined;\n}\n\ninterface MediaReply {\n  response: Response;\n  text: string;\n}\n\nclass BodyLimitError extends Error {}\n\nexport class GrokMediaClient implements GrokMediaPort {\n  readonly fetchImpl: typeof fetch;\n  readonly baseUrl: string;\n  readonly timeouts: GrokMediaTimeouts;\n\n  constructor(options: GrokMediaClientOptions = {}) {\n    this.fetchImpl = options.fetch ?? fetch;\n    this.baseUrl = (options.baseUrl ?? GROK_PUBLIC_API_URL).replace(/\\/+$/, \"\");\n    this.timeouts = { ...DEFAULT_TIMEOUTS, ...options.timeouts };\n  }\n\n  async generateImages(\n    auth: GrokMediaAuth,\n    request: GrokImageGenerateRequest,\n  ): Promise<GrokImageResponse> {\n    const body = imageBody(request, request.model.trim() || GROK_IMAGE_DEFAULT_MODEL);\n\n    return this.postImages(\"/images/generations\", auth, body, request.signal);\n  }\n\n  async editImages(auth: GrokMediaAuth, request: GrokImageEditRequest): Promise<GrokImageResponse> {\n    if (request.images.length === 0)\n      throw new GrokInvalidRequestError(\"Grok image edit needs at least one reference image\");\n\n    const urls = request.images.map((url) => {\n      if (!url.trim())\n        throw new GrokInvalidRequestError(\"Grok image edit reference must be a non-empty URL\");\n\n      return { url };\n    });\n\n    const body = imageBody(request, request.model.trim() || GROK_IMAGE_EDIT_DEFAULT_MODEL);\n\n    // image_edit/mod.rs:371-396: one reference is `image: {url}`, several are `images: [{url}]`.\n    if (urls.length === 1) body.image = urls[0];\n    else body.images = urls;\n\n    return this.postImages(\"/images/edits\", auth, body, request.signal);\n  }\n\n  async startVideo(auth: GrokMediaAuth, request: GrokVideoStartRequest): Promise<GrokVideoStart> {\n    const body = videoBody(request);\n\n    const { text } = await this.call({\n      method: \"POST\",\n      path: \"/videos/generations\",\n      auth,\n      body,\n      totalMs: this.timeouts.videoStartMs,\n      readMs: this.timeouts.videoStartMs,\n      maxBytes: MAX_JSON_RESPONSE_BYTES,\n      signal: request.signal,\n    });\n\n    return parseJson(GrokVideoStart, text, \"video start\");\n  }\n\n  async getVideo(\n    auth: GrokMediaAuth,\n    requestId: string,\n    signal?: AbortSignal,\n  ): Promise<GrokVideoStatus> {\n    if (!requestId.trim()) throw new TypeError(\"Grok video request id must be non-empty\");\n\n    const { response, text } = await this.call({\n      method: \"GET\",\n      path: `/videos/${encodeURIComponent(requestId)}`,\n      auth,\n      totalMs: this.timeouts.videoPollMs,\n      readMs: this.timeouts.videoPollMs,\n      maxBytes: MAX_JSON_RESPONSE_BYTES,\n      signal,\n    });\n\n    const status = parseVideoStatus(response.status, text);\n\n    if (VideoStatusExtras.parse(status).video?.respect_moderation === false)\n      throw new GrokContentPolicyError(\"video\");\n\n    return status;\n  }\n\n  async postImages(\n    path: string,\n    auth: GrokMediaAuth,\n    body: GrokImageBody,\n    signal: AbortSignal | undefined,\n  ): Promise<GrokImageResponse> {\n    const { text } = await this.call({\n      method: \"POST\",\n      path,\n      auth,\n      body,\n      totalMs: this.timeouts.imageTotalMs,\n      readMs: this.timeouts.imageReadMs,\n      maxBytes: MAX_IMAGE_RESPONSE_BYTES,\n      signal,\n    });\n\n    const response = parseJson(GrokImageResponse, text, \"image\");\n    assertImagesAllowed(response);\n\n    return response;\n  }\n\n  /** One HTTP exchange with total and read timeouts composed with the caller's signal. */\n  async call(call: MediaCall): Promise<MediaReply> {\n    const { signal } = call;\n\n    if (signal?.aborted) throw abortReason(signal);\n\n    const headers = {\n      \"content-type\": \"application/json\",\n      ...buildGrokMediaHeaders({ bearer: call.auth.bearer, sessionId: call.auth.sessionId }),\n    };\n\n    const controller = new AbortController();\n    let timeout: GrokMediaTimeoutError | undefined;\n\n    const fire = (error: GrokMediaTimeoutError) => {\n      if (timeout || controller.signal.aborted) return;\n      timeout = error;\n      controller.abort(error);\n    };\n\n    const totalTimer = setTimeout(\n      () => fire(new GrokMediaTimeoutError(\"total\", call.totalMs)),\n      call.totalMs,\n    );\n\n    let readTimer: ReturnType<typeof setTimeout> | undefined;\n\n    const armRead = () => {\n      clearTimeout(readTimer);\n      readTimer = setTimeout(\n        () => fire(new GrokMediaTimeoutError(\"read\", call.readMs)),\n        call.readMs,\n      );\n    };\n\n    const onAbort = () => controller.abort(signal?.reason);\n    signal?.addEventListener(\"abort\", onAbort, { once: true });\n\n    // Called for every failure: a caller abort or a timeout wins over the transport error.\n    const settle = (cause: unknown, responded: boolean): Error => {\n      if (signal?.aborted) return abortReason(signal);\n\n      if (timeout) return timeout;\n\n      if (cause instanceof GrokProtocolError || cause instanceof GrokHttpError) return cause;\n\n      if (call.method === \"GET\") return connectFailure(cause);\n\n      if (!responded && PRE_SEND_ERROR_CODES.has(errorCode(cause) ?? \"\"))\n        return connectFailure(cause);\n\n      return new GrokMediaDeliveryError(errorMessage(cause), { cause });\n    };\n\n    try {\n      armRead();\n      let response: Response;\n\n      try {\n        response = await this.fetchImpl(`${this.baseUrl}${call.path}`, {\n          method: call.method,\n          headers,\n          body: call.body === undefined ? undefined : JSON.stringify(call.body),\n          signal: controller.signal,\n        });\n      } catch (error) {\n        throw settle(error, false);\n      }\n\n      armRead();\n\n      try {\n        if (!response.ok) {\n          const bodyText = await readBody(response, MAX_ERROR_BODY_BYTES, armRead, true);\n          throw new GrokHttpError(\n            classifyGrokHttpError(response.status, bodyText, response.headers),\n            bodyText,\n            readGrokResponseHeaders(response.headers),\n          );\n        }\n\n        const text = await readBody(response, call.maxBytes, armRead, false);\n\n        return { response, text };\n      } catch (error) {\n        if (error instanceof BodyLimitError) throw new GrokProtocolError(error.message);\n        throw settle(error, true);\n      }\n    } finally {\n      clearTimeout(totalTimer);\n      clearTimeout(readTimer);\n      signal?.removeEventListener(\"abort\", onAbort);\n    }\n  }\n}\n\n/**\n * Image request body. Optional members are left `undefined`, which JSON.stringify omits, so the\n * serialized key order stays that of the verified request.\n */\ninterface GrokImageBody {\n  model: string;\n  prompt: string;\n  n: number;\n  aspect_ratio?: GrokImageGenerateRequest[\"aspectRatio\"];\n  resolution: NonNullable<GrokImageGenerateRequest[\"resolution\"]>;\n  response_format: \"b64_json\";\n  quality?: GrokImageGenerateRequest[\"quality\"];\n  output_format?: GrokImageGenerateRequest[\"outputFormat\"];\n  image?: { url: string };\n  images?: Array<{ url: string }>;\n}\n\n/** Video request body; `undefined` members are omitted from the serialized JSON. */\ninterface GrokVideoBody {\n  model: string;\n  prompt: string;\n  image?: { url: string };\n  duration?: number;\n  aspect_ratio?: GrokVideoStartRequest[\"aspectRatio\"];\n  resolution?: GrokVideoStartRequest[\"resolution\"];\n  reference_images?: Array<{ url: string }>;\n  last_frame?: { url: string };\n}\n\nfunction imageBody(request: GrokImageGenerateRequest, model: string): GrokImageBody {\n  const n = request.n ?? 1;\n\n  if (!Number.isSafeInteger(n) || n < 1 || n > GROK_IMAGE_MAX_PER_CALL)\n    throw new RangeError(\n      `Grok image count must be an integer from 1 to ${GROK_IMAGE_MAX_PER_CALL}`,\n    );\n\n  // Key order of the U0-verified request (image_gen/mod.rs:231-238); SDK options follow.\n  const body: GrokImageBody = {\n    model,\n    prompt: request.prompt,\n    n,\n    aspect_ratio: request.aspectRatio,\n    resolution: request.resolution ?? GROK_IMAGE_DEFAULT_RESOLUTION,\n    response_format: \"b64_json\",\n    quality: request.quality,\n    output_format: request.outputFormat,\n  };\n\n  return body;\n}\n\nfunction videoBody(request: GrokVideoStartRequest): GrokVideoBody {\n  // `edit-video` / `extend-video` are not in the port type: they post to /videos/edits and\n  // /videos/extensions with a source `video: {url}` (xai-video-model.ts:586-593, 391-396), and the\n  // port request carries no video URL.\n  const references = request.referenceImages ?? [];\n\n  if (request.mode === \"reference-to-video\" && references.length === 0)\n    throw new GrokInvalidRequestError(\"Grok reference-to-video needs at least one reference image\");\n  const { duration } = request;\n\n  if (\n    duration !== undefined &&\n    (!Number.isSafeInteger(duration) || duration < 1 || duration > GROK_VIDEO_MAX_DURATION_SEC)\n  )\n    throw new GrokInvalidRequestError(\n      `Grok video duration must be an integer from 1 to ${GROK_VIDEO_MAX_DURATION_SEC}`,\n    );\n\n  // Field order of grok-build GenerateVideoPayload (video_gen/mod.rs:811-827). `mode` selects the\n  // endpoint in @ai-sdk/xai and is never a body field; reference-to-video is inferred upstream\n  // from `reference_images` (xai-video-model.ts:169-194).\n  const body: GrokVideoBody = {\n    model: request.model.trim() || GROK_VIDEO_DEFAULT_MODEL,\n    prompt: request.prompt,\n    image: request.image === undefined ? undefined : { url: request.image },\n    duration,\n    aspect_ratio: request.aspectRatio,\n    resolution: request.resolution,\n    reference_images: references.length === 0 ? undefined : references.map((url) => ({ url })),\n    last_frame: request.lastFrame === undefined ? undefined : { url: request.lastFrame },\n  };\n\n  return body;\n}\n\nfunction parseJsonText(text: string, what: string): JsonValue {\n  try {\n    // JSON.parse without a reviver yields only JSON values.\n    const json: JsonValue = JSON.parse(text);\n\n    return json;\n  } catch {\n    throw new GrokProtocolError(`Grok ${what} response is not JSON`);\n  }\n}\n\nfunction parseJson<T>(schema: z.ZodType<T>, text: string, what: string): T {\n  const parsed = schema.safeParse(parseJsonText(text, what));\n\n  if (!parsed.success) throw new GrokProtocolError(`Grok ${what} response has an unexpected shape`);\n\n  return parsed.data;\n}\n\nconst JsonObject = z.record(z.string(), z.unknown());\n\nconst LooseVideoStatus = z.looseObject({\n  status: z.string().nullish(),\n  video: z.looseObject({ url: z.string().nullish() }).nullish(),\n});\n\n/**\n * 202 means pending, possibly with an empty or partial body (xai-video-model.ts:876-894;\n * grok-build video_gen/mod.rs:442 accepts it too). A 200 without `status` but with a video URL\n * is done (xai-video-model.ts:673-676).\n */\nfunction parseVideoStatus(httpStatus: number, text: string): GrokVideoStatus {\n  if (httpStatus === 202) {\n    if (!text.trim()) return { status: \"pending\" };\n    let json: unknown;\n\n    try {\n      json = JSON.parse(text);\n    } catch {\n      return { status: \"pending\" };\n    }\n\n    const object = JsonObject.safeParse(json);\n    const loose = LooseVideoStatus.safeParse(json);\n\n    if (!object.success || !loose.success) return { status: \"pending\" };\n\n    const parsed = GrokVideoStatus.safeParse({\n      ...object.data,\n      status: loose.data.status ?? \"pending\",\n    });\n\n    return parsed.success ? parsed.data : { status: \"pending\" };\n  }\n\n  const json = parseJsonText(text, \"video status\");\n  const object = JsonObject.safeParse(json);\n  const loose = LooseVideoStatus.safeParse(json);\n\n  if (!object.success || !loose.success)\n    throw new GrokProtocolError(\"Grok video status response has an unexpected shape\");\n  const status = loose.data.status ?? (loose.data.video?.url ? \"done\" : \"pending\");\n  const parsed = GrokVideoStatus.safeParse({ ...object.data, status });\n\n  if (!parsed.success)\n    throw new GrokProtocolError(\"Grok video status response has an unexpected shape\");\n\n  return parsed.data;\n}\n\n/** Reads the body, re-arming the read timer per chunk. `truncate` caps instead of failing. */\nasync function readBody(\n  response: Response,\n  maxBytes: number,\n  onChunk: () => void,\n  truncate: boolean,\n): Promise<string> {\n  if (!response.body) return \"\";\n  const reader = response.body.getReader();\n  const decoder = new TextDecoder();\n  let text = \"\";\n  let total = 0;\n\n  for (;;) {\n    const { done, value } = await reader.read();\n\n    if (done) break;\n    onChunk();\n    total += value.byteLength;\n\n    if (total > maxBytes) {\n      await reader.cancel().catch(() => undefined);\n\n      if (truncate)\n        return text + decoder.decode(value.subarray(0, maxBytes - (total - value.byteLength)));\n      throw new BodyLimitError(`Grok media response exceeded ${maxBytes} bytes`);\n    }\n\n    text += decoder.decode(value, { stream: true });\n  }\n\n  return text + decoder.decode();\n}\n"],"mappings":"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"}