@jeffreycao/copilot-api 2.7.15 → 2.7.17

package/dist/{server-CeyKV5sQ.js → server-04fZfBz1.js}

@@ -1,9 +1,9 @@
 import { D as state, E as isGitHubCopilotEnabled, O as HTTPError, S as PATHS, a as getAnthropicApiKey, c as getConfig, d as getUpstreamTransportConfig, g as isResponsesApiWebSocketEnabled, h as isResponsesApiWebSearchEnabled, i as getAlphaSearchModel, j as forwardError, l as getMessageApiWebSearchModel, m as isMessagesApiEnabled, o as getClaudeAutoModel, p as isAlphaSearchCodexPriorityEnabled, s as getClaudeTokenMultiplier, u as getOpencodeModelContextWindow, w as GITHUB_COPILOT_PROVIDER, y as reloadConfig } from "./config-store-CC5TNG7V.js";
 import { A as resolveMappedModel, C as getModelResponsesApiCompactThreshold$1, D as isContextManagementEnabledForMessages, E as getSmallModelForProvider, O as isContextManagementEnabledForResponses, S as getModelMappings, T as getSmallModel, _ as getModelsDevModelMaxOutputTokens, d as isProviderModelVisible, f as resolveProviderModelsDevId, g as getModelsDevModel, h as getBuiltinProviderModelRecords, i as listEnabledProviders, j as setModelMappings, k as isGpt56OrAbove, l as getLocalProviderModelRecords, m as builtinProviderModelRegistry, n as getRawProviderConfig, o as resolveEffectiveProviderType, p as usesModelsDevModelCatalog, s as resolveProviderConfigForModel, t as getProviderConfig, u as getProviderModelConfig, v as getModelsDevModelPricing, w as getReasoningEffortForModel, x as getExtraPromptForModel } from "./config-BKA4Y1t8.js";
-import { $ as resolveTraceId$1, C as isOpencodeOauthApp, E as prepareMessageProxyHeaders, G as XAI_API_BASE_URL, J as CODEX_API_BASE_URL, L as getXaiAccessToken, M as compactTextOnlyGuard, N as createAuthMiddleware, O as compactAutoContinuePromptStarts, P as getConfiguredAdminApiKeys, Q as requestContext, S as copilotWebSocketHeaders, T as prepareInteractionHeaders, U as readGitHubToken, W as readGitHubTokenFromEnv, X as forwardCodexResponses, Y as buildCodexRequestHeaders, Z as generateTraceId, _ as parseUserIdMetadata, at as createPooledWebSocketStream, b as copilotHeaders, ct as stripInternalRequestHeaders, d as generateRequestIdFromPayload, et as fetchUpstreamWithLifecycle, f as getRootSessionId, g as isResponsesStream, h as isNullish, it as getResponsesStreamTerminalDisposition, j as compactSystemPromptStarts, k as compactMessageSections, m as isAsyncIterable, n as invalidateCodexRuntime, nt as createResponsesSafeStream, ot as createWebSocketUrl, p as getUUID, rt as encodePoolKeyPart, s as setupCodexToken, tt as createResponsesHttpEventStream, u as stopCopilotRefreshLoop, v as getCopilotUsage, w as prepareForCompact, y as copilotBaseUrl } from "./token-BdwhXP3l.js";
+import { $ as resolveTraceId$1, C as isOpencodeOauthApp, E as prepareMessageProxyHeaders, G as XAI_API_BASE_URL, J as CODEX_API_BASE_URL, L as getXaiAccessToken, M as compactTextOnlyGuard, N as createAuthMiddleware, O as compactAutoContinuePromptStarts, P as getConfiguredAdminApiKeys, Q as requestContext, S as copilotWebSocketHeaders, T as prepareInteractionHeaders, U as readGitHubToken, W as readGitHubTokenFromEnv, X as forwardCodexResponses, Y as buildCodexRequestHeaders, Z as generateTraceId, _ as parseUserIdMetadata, at as createPooledWebSocketStream, b as copilotHeaders, ct as stripInternalRequestHeaders, d as generateRequestIdFromPayload, et as fetchUpstreamWithLifecycle, f as getRootSessionId, g as isResponsesStream, h as isNullish, it as getResponsesStreamTerminalDisposition, j as compactSystemPromptStarts, k as compactMessageSections, m as isAsyncIterable, n as invalidateCodexRuntime, nt as createResponsesSafeStream, ot as createWebSocketUrl, p as getUUID, rt as encodePoolKeyPart, s as setupCodexToken, tt as createResponsesHttpEventStream, u as stopCopilotRefreshLoop, v as getCopilotUsage, w as prepareForCompact, y as copilotBaseUrl } from "./token-CWFRUUIv.js";
 import { a as isDeferredToolName, c as parseMcpToolSearchSentinel, d as shouldEnableResponsesToolSearch, i as isBridgeToolSearchName, l as resolveBridgeToolSearchName, o as listDeferredToolNames, r as formatToolSearchBridgeArguments, s as normalizeToolSearchBridgeArguments, t as BRIDGE_TOOL_SEARCH_NAME, u as selectDeferredToolsByNames } from "./tool-search-CcvaqM03.js";
 import { n as isProviderAgentModelVisible, t as getProviderAgentModels } from "./provider-management-CBrc2nDg.js";
-import { n as stopModelsRefreshLoop, t as setupCopilotRuntime } from "./copilot-runtime-CW4zUahm.js";
+import { n as stopModelsRefreshLoop, t as setupCopilotRuntime } from "./copilot-runtime-XKDhY-sV.js";
 import consola from "consola";
 import { createHash, randomUUID } from "node:crypto";
 import fs, { createWriteStream, readFileSync, rmSync } from "node:fs";
@@ -2131,7 +2131,7 @@ async function forwardProviderImages(providerConfig, request, operation) {
 		headers,
 		body: request.body,
 		duplex: "half",
-		signal: AbortSignal.timeout(PROVIDER_IMAGES_TIMEOUT_MS)
+		signal: AbortSignal.any([request.signal, AbortSignal.timeout(PROVIDER_IMAGES_TIMEOUT_MS)])
 	};
 	const upstreamUrl = resolveProviderRequestUrl(providerConfig, request.url, `/v1/images/${operation}`);
 	if (typeof Bun !== "undefined") return await fetch(upstreamUrl, init);
@@ -3256,6 +3256,36 @@ embeddingRoutes.post("/", async (c) => {
 	}
 });
 //#endregion
+//#region src/lib/xai-image-model.ts
+/**
+* Resolves one image-route model setting. Empty values keep the OpenAI
+* protocol. Only an xai/model alias selects the xAI Imagine API.
+*/
+function resolveConfiguredXaiImageModel(configured, settingName) {
+	if (configured === void 0 || configured === null) return { status: "disabled" };
+	if (typeof configured !== "string") return {
+		message: `${settingName} must be an xai/model alias`,
+		status: "invalid"
+	};
+	const trimmed = configured.trim();
+	if (!trimmed) return { status: "disabled" };
+	const alias = parseProviderModelAlias(trimmed);
+	if (alias?.provider.toLowerCase() !== "xai") return {
+		message: `${settingName} only supports an xai/model alias, received '${trimmed}'`,
+		status: "invalid"
+	};
+	return {
+		model: alias.model,
+		status: "xai"
+	};
+}
+function getImageGenerationModel() {
+	return resolveConfiguredXaiImageModel(getConfig().imageGenerationModel, "imageGenerationModel");
+}
+function getImageEditModel() {
+	return resolveConfiguredXaiImageModel(getConfig().imageEditModel, "imageEditModel");
+}
+//#endregion
 //#region src/routes/images/forward-provider-images.ts
 /**
 * Forwards an images request to a configured provider with debug logging.
@@ -3313,6 +3343,8 @@ async function forwardCodexImages(request, operation) {
 const logger$14 = createHandlerLogger("images-handler");
 const imageRouteDependencies = {
 	debugJsonAsync,
+	getImageEditModel,
+	getImageGenerationModel,
 	resolveMappedModel,
 	resolveProviderConfig
 };
@@ -3395,6 +3427,517 @@ async function routeImagesRequest(c, operation, parsed) {
 	return await handleCodexImages(c, operation, void 0, parsed.createRequest(mappedModel));
 }
 //#endregion
+//#region src/services/xai/images.ts
+const XAI_ASPECT_RATIOS = [
+	{
+		label: "1:1",
+		width: 1,
+		height: 1
+	},
+	{
+		label: "16:9",
+		width: 16,
+		height: 9
+	},
+	{
+		label: "9:16",
+		width: 9,
+		height: 16
+	},
+	{
+		label: "4:3",
+		width: 4,
+		height: 3
+	},
+	{
+		label: "3:4",
+		width: 3,
+		height: 4
+	},
+	{
+		label: "3:2",
+		width: 3,
+		height: 2
+	},
+	{
+		label: "2:3",
+		width: 2,
+		height: 3
+	},
+	{
+		label: "2:1",
+		width: 2,
+		height: 1
+	},
+	{
+		label: "1:2",
+		width: 1,
+		height: 2
+	},
+	{
+		label: "19.5:9",
+		width: 19.5,
+		height: 9
+	},
+	{
+		label: "9:19.5",
+		width: 9,
+		height: 19.5
+	},
+	{
+		label: "20:9",
+		width: 20,
+		height: 9
+	},
+	{
+		label: "9:20",
+		width: 9,
+		height: 20
+	}
+];
+const XAI_ASPECT_RATIO_LABELS = /* @__PURE__ */ new Set([...XAI_ASPECT_RATIOS.map((ratio) => ratio.label), "auto"]);
+const XAI_RESPONSE_FORMATS = /* @__PURE__ */ new Set(["url", "b64_json"]);
+const XAI_RESOLUTIONS = /* @__PURE__ */ new Set(["1k", "2k"]);
+const IMAGE_FIELD_NAMES = /* @__PURE__ */ new Set([
+	"image",
+	"image[]",
+	"images",
+	"images[]"
+]);
+const MAX_EDIT_IMAGES = 5;
+const MAX_IMAGE_COUNT = 10;
+const HIGH_RESOLUTION_EDGE = 1536;
+var XaiImagesRequestError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "XaiImagesRequestError";
+	}
+};
+function isRecord$3(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readPrompt(value) {
+	if (typeof value !== "string" || value.trim() === "") throw new XaiImagesRequestError("prompt is required");
+	return value;
+}
+function assertNotStreaming(value) {
+	if (value === true || value === "true") throw new XaiImagesRequestError("xAI image requests do not support streaming");
+}
+function readCount(value) {
+	if (value === void 0 || value === null) return void 0;
+	const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value.trim()) : NaN;
+	if (!Number.isInteger(parsed) || parsed < 1 || parsed > MAX_IMAGE_COUNT) throw new XaiImagesRequestError(`n must be an integer from 1 to ${MAX_IMAGE_COUNT}`);
+	return parsed;
+}
+function readQuality(value) {
+	if (typeof value !== "string") return void 0;
+	switch (value.trim().toLowerCase()) {
+		case "low": return "low";
+		case "medium":
+		case "standard":
+		case "high":
+		case "hd": return "medium";
+		case "auto": return "auto";
+		default: return;
+	}
+}
+function readChoice(value, allowed, name, normalize = (item) => item) {
+	if (value === void 0 || value === null) return void 0;
+	if (typeof value !== "string") throw new XaiImagesRequestError(`${name} is invalid`);
+	const trimmed = value.trim();
+	if (!trimmed) return void 0;
+	const normalized = normalize(trimmed);
+	if (!allowed.has(normalized)) throw new XaiImagesRequestError(`${name} must be one of ${Array.from(allowed).join(", ")}`);
+	return normalized;
+}
+function readAspectRatio(value) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "string") throw new XaiImagesRequestError("aspect_ratio is invalid");
+	const trimmed = value.trim();
+	if (!trimmed) return void 0;
+	const normalized = trimmed.toLowerCase() === "auto" ? "auto" : trimmed;
+	if (!XAI_ASPECT_RATIO_LABELS.has(normalized)) throw new XaiImagesRequestError("aspect_ratio must be a supported xAI ratio such as 1:1, 16:9, 9:16, or auto");
+	return normalized;
+}
+function readSize(value) {
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim().toLowerCase();
+	if (!trimmed) return void 0;
+	if (trimmed === "auto") return "auto";
+	const match = /^(\d+)x(\d+)$/u.exec(trimmed);
+	if (!match?.[1] || !match[2]) return void 0;
+	const width = Number(match[1]);
+	const height = Number(match[2]);
+	if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height) || width <= 0 || height <= 0) return;
+	return {
+		height,
+		width
+	};
+}
+function aspectRatioFromSize(size) {
+	if (!size) return void 0;
+	if (size === "auto") return "auto";
+	let best = XAI_ASPECT_RATIOS[0].label;
+	let bestDistance = Number.POSITIVE_INFINITY;
+	const ratio = Math.log(size.width / size.height);
+	for (const candidate of XAI_ASPECT_RATIOS) {
+		const distance = Math.abs(ratio - Math.log(candidate.width / candidate.height));
+		if (distance < bestDistance) {
+			best = candidate.label;
+			bestDistance = distance;
+		}
+	}
+	return best;
+}
+function resolutionFromSize(size) {
+	if (!size || size === "auto") return void 0;
+	return Math.max(size.width, size.height) >= HIGH_RESOLUTION_EDGE ? "2k" : "1k";
+}
+function applyCommonImageFields(target, source) {
+	assertNotStreaming(source.stream);
+	const count = readCount(source.n);
+	const quality = readQuality(source.quality);
+	const responseFormat = readChoice(source.response_format, XAI_RESPONSE_FORMATS, "response_format");
+	const aspectRatio = readAspectRatio(source.aspect_ratio) ?? aspectRatioFromSize(readSize(source.size));
+	const resolution = readChoice(source.resolution, XAI_RESOLUTIONS, "resolution", (value) => value.toLowerCase()) ?? resolutionFromSize(readSize(source.size));
+	if (count !== void 0) target.n = count;
+	if (quality && target.model === "grok-imagine-image-2.0") target.quality = quality;
+	target.response_format = responseFormat ?? "b64_json";
+	if (aspectRatio) target.aspect_ratio = aspectRatio;
+	if (resolution) target.resolution = resolution;
+}
+function normalizeImageUrl(value) {
+	const trimmed = value.trim();
+	if (/^https?:\/\//iu.test(trimmed) || /^data:image\/[a-z0-9.+-]+;base64,/iu.test(trimmed)) return trimmed;
+	throw new XaiImagesRequestError("image must be an http(s) URL or a base64 data URL");
+}
+function base64ToDataUrl(value, mime) {
+	const compact = value.trim().replaceAll(/\s+/gu, "");
+	if (compact.startsWith("data:image/")) return normalizeImageUrl(compact);
+	if (!/^[a-z0-9+/]+={0,2}$/iu.test(compact)) throw new XaiImagesRequestError("image b64_json is not valid base64");
+	return `data:${typeof mime === "string" && mime.trim().toLowerCase().startsWith("image/") ? mime.trim().toLowerCase() : "image/png"};base64,${compact}`;
+}
+function readImageReference(value) {
+	if (typeof value === "string") return {
+		type: "image_url",
+		url: normalizeImageUrl(value)
+	};
+	if (!isRecord$3(value)) throw new XaiImagesRequestError("image must be a URL or an image object");
+	if (typeof value.url === "string") return {
+		type: "image_url",
+		url: normalizeImageUrl(value.url)
+	};
+	if (typeof value.image_url === "string") return {
+		type: "image_url",
+		url: normalizeImageUrl(value.image_url)
+	};
+	if (typeof value.b64_json === "string") return {
+		type: "image_url",
+		url: base64ToDataUrl(value.b64_json, value.mime_type ?? value.media_type)
+	};
+	if (value.file_id !== void 0) throw new XaiImagesRequestError("file_id is not supported for xAI image edits; provide an image_url instead");
+	throw new XaiImagesRequestError("image must include a url, image_url, or b64_json");
+}
+function detectImageMime(bytes, fileName) {
+	if (bytes.length >= 8 && bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) return "image/png";
+	if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216) return "image/jpeg";
+	if (bytes.length >= 12 && bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70 && bytes[8] === 87 && bytes[9] === 69 && bytes[10] === 66 && bytes[11] === 80) return "image/webp";
+	if (bytes.length >= 6 && bytes[0] === 71 && bytes[1] === 73 && bytes[2] === 70) return "image/gif";
+	const extension = fileName?.split(".").pop()?.toLowerCase();
+	if (extension === "jpg" || extension === "jpeg") return "image/jpeg";
+	if (extension === "webp") return "image/webp";
+	if (extension === "gif") return "image/gif";
+	return "image/png";
+}
+async function blobToImageReference(blob) {
+	const bytes = new Uint8Array(await blob.arrayBuffer());
+	if (bytes.byteLength === 0) throw new XaiImagesRequestError("image is empty");
+	const fileName = blob instanceof File ? blob.name : void 0;
+	const declared = blob.type.trim().toLowerCase();
+	return {
+		type: "image_url",
+		url: `data:${declared.startsWith("image/") ? declared : detectImageMime(bytes, fileName)};base64,${Buffer.from(bytes).toString("base64")}`
+	};
+}
+async function formValueToImageReference(value) {
+	if (typeof value === "string") return readImageReference(value);
+	if (!(value instanceof Blob)) throw new XaiImagesRequestError("image must be a file or a URL");
+	return await blobToImageReference(value);
+}
+function collectJsonImages(payload) {
+	const values = [];
+	if (isUnknownArray(payload.image)) values.push(...payload.image);
+	else if (payload.image !== void 0) values.push(payload.image);
+	if (isUnknownArray(payload.images)) values.push(...payload.images);
+	if (payload.image_url !== void 0) values.push(payload.image_url);
+	return values;
+}
+function isUnknownArray(value) {
+	return Array.isArray(value);
+}
+function buildEditPayload(model, prompt, images, source) {
+	if (source.mask !== void 0) throw new XaiImagesRequestError("xAI image edits do not support mask");
+	if (images.length === 0) throw new XaiImagesRequestError("image is required");
+	if (images.length > MAX_EDIT_IMAGES) throw new XaiImagesRequestError(`xAI image edits accept at most ${MAX_EDIT_IMAGES} images`);
+	const payload = {
+		model,
+		prompt
+	};
+	applyCommonImageFields(payload, source);
+	if (images.length === 1) payload.image = images[0];
+	else payload.images = images;
+	return payload;
+}
+function formOptions(formData) {
+	const source = {};
+	for (const key of [
+		"n",
+		"quality",
+		"response_format",
+		"aspect_ratio",
+		"resolution",
+		"size",
+		"stream",
+		"mask"
+	]) {
+		const value = formData.get(key);
+		if (typeof value === "string") source[key] = value;
+	}
+	if (formData.get("mask") !== null || formData.get("mask[]") !== null) source.mask = true;
+	return source;
+}
+/**
+* Translates an OpenAI image generation body into an xAI Imagine generation
+* request. The configured model replaces the client model.
+*/
+function translateXaiImageGeneration(payload, model) {
+	if (!isRecord$3(payload)) throw new XaiImagesRequestError("Image generation body must be a JSON object");
+	const translated = {
+		model,
+		prompt: readPrompt(payload.prompt)
+	};
+	applyCommonImageFields(translated, payload);
+	return translated;
+}
+/**
+* Translates an OpenAI JSON image edit body into an xAI Imagine edit request.
+*/
+function translateXaiImageEditJson(payload, model) {
+	if (!isRecord$3(payload)) throw new XaiImagesRequestError("Image edit body must be a JSON object");
+	return buildEditPayload(model, readPrompt(payload.prompt), collectJsonImages(payload).map((image) => readImageReference(image)), payload);
+}
+/**
+* Translates an OpenAI multipart image edit into an xAI Imagine edit request.
+* File parts become base64 data URLs. A mask cannot be represented and is
+* rejected.
+*/
+async function translateXaiImageEditForm(formData, model) {
+	const images = [];
+	for (const [name, value] of formData.entries()) {
+		if (!IMAGE_FIELD_NAMES.has(name)) continue;
+		images.push(await formValueToImageReference(value));
+	}
+	return buildEditPayload(model, readPrompt(formData.get("prompt")), images, formOptions(formData));
+}
+const MAX_RESPONSE_IMAGE_BYTES = 33554432;
+function responseHasB64Json(value) {
+	return typeof value === "string" && value.trim() !== "";
+}
+function imageCreatedTimestamp(value) {
+	if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.trunc(value);
+	return Math.floor(Date.now() / 1e3);
+}
+function trustedImageUrl(value) {
+	if (typeof value !== "string" || !value.trim()) return null;
+	try {
+		const url = new URL(value.trim());
+		if (url.protocol !== "https:" || url.hostname !== "imgen.x.ai" || url.port || url.username || url.password) return null;
+		return url.toString();
+	} catch {
+		return null;
+	}
+}
+async function readImageBytes(response) {
+	const declaredLength = Number(response.headers.get("content-length"));
+	if (Number.isFinite(declaredLength) && declaredLength > MAX_RESPONSE_IMAGE_BYTES) {
+		await response.body?.cancel().catch(() => {});
+		return null;
+	}
+	if (!response.body) return null;
+	const reader = response.body.getReader();
+	const chunks = [];
+	let length = 0;
+	let complete = false;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) {
+				complete = true;
+				return length > 0 ? Buffer.concat(chunks, length) : null;
+			}
+			length += value.byteLength;
+			if (length > MAX_RESPONSE_IMAGE_BYTES) return null;
+			chunks.push(value);
+		}
+	} finally {
+		if (!complete) await reader.cancel().catch(() => {});
+		reader.releaseLock();
+	}
+}
+function imageDownloadErrorResponse() {
+	return Response.json({ error: {
+		message: "Failed to retrieve xAI image output as b64_json",
+		type: "upstream_error"
+	} }, { status: 502 });
+}
+function imageOutputUrlForLog(value) {
+	if (typeof value !== "string" || !value.trim()) return null;
+	try {
+		const url = new URL(value.trim());
+		if (url.protocol !== "https:" && url.protocol !== "http:") return null;
+		url.username = "";
+		url.password = "";
+		for (const key of url.searchParams.keys()) if (/token|secret|signature|credential|password|authorization|api[_-]?key|^key$|^sig$/iu.test(key)) url.searchParams.set(key, "[REDACTED]");
+		return url.toString();
+	} catch {
+		return null;
+	}
+}
+function rebuildJsonResponse(response, body) {
+	const headers = new Headers(response.headers);
+	headers.delete("content-length");
+	if (!headers.get("content-type")) headers.set("content-type", "application/json");
+	return new Response(body, {
+		headers,
+		status: response.status,
+		statusText: response.statusText
+	});
+}
+/**
+* Adapts an xAI image body to the OpenAI Images response.
+* Generation returns created: null, and edits omit created. OpenAI clients
+* require a unix timestamp. When b64_json is requested, a URL-only result
+* is downloaded from the xAI CDN with redirects disabled and a byte limit.
+*/
+async function ensureImageResponseB64Json(response, fetchImage = globalThis.fetch, { clientSignal, onImageUrl, responseFormat = "b64_json" } = {}) {
+	if (!response.ok) return response;
+	clientSignal?.throwIfAborted();
+	const body = await response.text();
+	let payload;
+	try {
+		payload = JSON.parse(body);
+	} catch {
+		return rebuildJsonResponse(response, body);
+	}
+	if (!isRecord$3(payload) || !Array.isArray(payload.data)) return rebuildJsonResponse(response, body);
+	let changed = false;
+	const data = [];
+	for (const item of payload.data) {
+		if (isRecord$3(item) && onImageUrl) {
+			const outputUrl = imageOutputUrlForLog(item.url);
+			if (outputUrl) onImageUrl(outputUrl);
+		}
+		if (!isRecord$3(item) || responseFormat === "url" || responseHasB64Json(item.b64_json)) {
+			data.push(item);
+			continue;
+		}
+		const url = trustedImageUrl(item.url);
+		if (!url) return imageDownloadErrorResponse();
+		try {
+			clientSignal?.throwIfAborted();
+			const timeoutSignal = AbortSignal.timeout(6e4);
+			const imageResponse = await fetchImage(url, {
+				method: "GET",
+				redirect: "error",
+				signal: clientSignal ? AbortSignal.any([clientSignal, timeoutSignal]) : timeoutSignal
+			});
+			if (!imageResponse.ok) {
+				await imageResponse.body?.cancel().catch(() => {});
+				return imageDownloadErrorResponse();
+			}
+			const bytes = await readImageBytes(imageResponse);
+			if (!bytes) return imageDownloadErrorResponse();
+			data.push({
+				...item,
+				b64_json: bytes.toString("base64")
+			});
+			changed = true;
+		} catch {
+			clientSignal?.throwIfAborted();
+			return imageDownloadErrorResponse();
+		}
+	}
+	const created = imageCreatedTimestamp(payload.created);
+	if (!changed && payload.created === created) return rebuildJsonResponse(response, body);
+	return rebuildJsonResponse(response, JSON.stringify({
+		...payload,
+		created,
+		data
+	}));
+}
+//#endregion
+//#region src/routes/images/xai-handler.ts
+function xaiImagesRequestErrorResponse(c, error) {
+	if (!(error instanceof XaiImagesRequestError)) return null;
+	return c.json({ error: {
+		message: error.message,
+		type: "invalid_request_error"
+	} }, 400);
+}
+async function readJsonBody(request, message) {
+	try {
+		const body = new TextDecoder("utf-8", { fatal: true }).decode(new Uint8Array(await request.arrayBuffer()));
+		return JSON.parse(body);
+	} catch {
+		throw new XaiImagesRequestError(message);
+	}
+}
+async function forwardTranslatedXaiImages(c, operation, payload) {
+	const providerConfig = await imageRouteDependencies.resolveProviderConfig("xai");
+	if (!providerConfig) return c.json({ error: {
+		message: "Provider 'xai' not found or disabled",
+		type: "invalid_request_error"
+	} }, 404);
+	return await forwardXaiImages(providerConfig, c.req.raw, operation, payload);
+}
+async function forwardXaiImages(providerConfig, request, operation, payload) {
+	return await ensureImageResponseB64Json(await forwardProviderImagesWithLogging(providerConfig, new Request(request.url, {
+		body: JSON.stringify(payload),
+		headers: {
+			accept: "application/json",
+			"content-type": "application/json"
+		},
+		method: "POST",
+		signal: request.signal
+	}), operation, {
+		logger: logger$14,
+		provider: "xai"
+	}), void 0, {
+		clientSignal: request.signal,
+		onImageUrl: (url) => {
+			logger$14.info("images.xai.output.url", JSON.stringify({
+				operation,
+				url
+			}));
+		},
+		responseFormat: payload.response_format === "url" ? "url" : "b64_json"
+	});
+}
+async function handleXaiImageGeneration(c, model) {
+	return await forwardTranslatedXaiImages(c, "generations", translateXaiImageGeneration(await readJsonBody(c.req.raw, "Image generation body must be JSON"), model));
+}
+async function handleXaiImageEdit(c, model, parsed) {
+	if (parsed instanceof Request) return await forwardTranslatedXaiImages(c, "edits", translateXaiImageEditJson(await readJsonBody(parsed, "Image edit body must be JSON"), model));
+	const { staged } = parsed;
+	let payload;
+	try {
+		payload = await translateXaiImageEditForm(staged.formData, model);
+	} finally {
+		await staged.cleanup();
+	}
+	return await forwardTranslatedXaiImages(c, "edits", payload);
+}
+//#endregion
 //#region src/routes/images/temp-form-data.ts
 const logger$13 = createHandlerLogger("images-temp-form-data");
 const multipartStagingDependencies = { createWriteStream };
@@ -3664,7 +4207,13 @@ async function parseEditsRequest(request) {
 }
 async function handleImagesEdits(c) {
 	try {
+		const configuredModel = imageRouteDependencies.getImageEditModel();
+		if (configuredModel.status === "invalid") return c.json({ error: {
+			message: configuredModel.message,
+			type: "invalid_request_error"
+		} }, 400);
 		const parsed = await parseEditsRequest(c.req.raw);
+		if (configuredModel.status === "xai") return await handleXaiImageEdit(c, configuredModel.model, parsed);
 		if (parsed instanceof Request) return await handleCodexImages(c, "edits", void 0, parsed);
 		const { model, requestHeaders, staged } = parsed;
 		try {
@@ -3683,6 +4232,8 @@ async function handleImagesEdits(c) {
 			message: error.message,
 			type: "invalid_request_error"
 		} }, error instanceof MultipartBodyTooLargeError ? 413 : 400);
+		const invalidRequest = xaiImagesRequestErrorResponse(c, error);
+		if (invalidRequest) return invalidRequest;
 		logger$14.error("images.edits.error", { error });
 		return await forwardError(c, error);
 	}
@@ -3723,10 +4274,18 @@ async function parseGenerationsRequest(request) {
 }
 async function handleImagesGenerations(c) {
 	try {
+		const configuredModel = imageRouteDependencies.getImageGenerationModel();
+		if (configuredModel.status === "invalid") return c.json({ error: {
+			message: configuredModel.message,
+			type: "invalid_request_error"
+		} }, 400);
+		if (configuredModel.status === "xai") return await handleXaiImageGeneration(c, configuredModel.model);
 		const parsed = await parseGenerationsRequest(c.req.raw);
 		if (parsed instanceof Request) return await handleCodexImages(c, "generations", void 0, parsed);
 		return await routeImagesRequest(c, "generations", parsed);
 	} catch (error) {
+		const invalidRequest = xaiImagesRequestErrorResponse(c, error);
+		if (invalidRequest) return invalidRequest;
 		logger$14.error("images.generations.error", { error });
 		return await forwardError(c, error);
 	}
@@ -13074,4 +13633,4 @@ createServer();
 //#endregion
 export { createServer };
 
-//# sourceMappingURL=server-CeyKV5sQ.js.map
+//# sourceMappingURL=server-04fZfBz1.js.map