@jeffreycao/copilot-api 2.8.1 → 2.8.3

package/dist/{server-CwSW3Oz8.js → server-Cw9qn5Gt.js}

@@ -1,14 +1,14 @@
-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-BLr5xjym.js";
-import { A as isOutputEncryptedContentDisabled, C as getModelResponsesApiCompactThreshold$1, D as isContextManagementEnabledForMessages, E as getSmallModelForProvider, M as setModelMappings, O as isContextManagementEnabledForResponses, S as getModelMappings, T as getSmallModel, _ as getModelsDevModelMaxOutputTokens, a as normalizeProviderBaseUrl, d as isProviderModelVisible, f as resolveProviderModelsDevId, g as getModelsDevModel, h as getBuiltinProviderModelRecords, i as listEnabledProviders, j as resolveMappedModel, 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-BvACNGIp.js";
-import { $ as buildCodexRequestHeaders, B as getXaiAccessToken, C as copilotHeaders, D as prepareForCompact, E as isOpencodeOauthApp, F as compactTextOnlyGuard, I as createAuthMiddleware, J as readGitHubTokenFromEnv, L as getConfiguredAdminApiKeys, M as compactMessageSections, O as prepareInteractionHeaders, P as compactSystemPromptStarts, Q as CODEX_API_BASE_URL, S as copilotBaseUrl, T as copilotWebSocketHeaders, U as readXaiCredentials, Y as XAI_API_BASE_URL, _ as isAsyncIterable, at as fetchUpstreamWithLifecycle, b as parseUserIdMetadata, ct as encodePoolKeyPart, d as generateRequestIdFromPayload, dt as createWebSocketUrl, et as forwardCodexResponses, f as getPromptCacheKey, g as getUUID, h as getSessionAffinityFromHeaders, it as setPluginRequestActualModel, j as compactAutoContinuePromptStarts, k as prepareMessageProxyHeaders, lt as getResponsesStreamTerminalDisposition, m as getRootSessionIdFromHeaders, n as invalidateCodexRuntime, nt as requestContext, ot as createResponsesHttpEventStream, p as getRootSessionId, pt as stripInternalRequestHeaders, q as readGitHubToken, rt as resolveTraceId$1, s as setupCodexToken, st as createResponsesSafeStream, tt as generateTraceId, u as stopCopilotRefreshLoop, ut as createPooledWebSocketStream, v as isNullish, x as getCopilotUsage, y as isResponsesStream } from "./token-D3nRiw9B.js";
+import { D as isGitHubCopilotEnabled, E as isGitHubCopilotAvailable, M as forwardError, O as state, S as PATHS, T as assertGitHubCopilotEnabled, a as getAnthropicApiKey, c as getConfig, d as getUpstreamTransportConfig, g as isResponsesApiWebSocketEnabled, h as isResponsesApiWebSearchEnabled, i as getAlphaSearchModel, k as HTTPError, 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-DFcv4AY0.js";
+import { A as getSmallModelForProvider, D as getModelResponsesApiCompactThreshold$1, E as getModelMappings, F as resolveMappedModel, I as setModelMappings, M as isContextManagementEnabledForResponses, N as isGpt56OrAbove, O as getReasoningEffortForModel, P as isOutputEncryptedContentDisabled, S as getModelsDevModelPricing, T as getExtraPromptForModel, _ as DEFAULT_IMAGE_MODELS, a as normalizeProviderBaseUrl, b as getModelsDevModel, d as isProviderModelVisible, f as resolveProviderModelsDevId, g as getBuiltinProviderModelRecords, h as getBuiltinProviderImageModelRecords, i as listEnabledProviders, j as isContextManagementEnabledForMessages, k as getSmallModel, 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 IMAGE_PROVIDER_PRIORITY, x as getModelsDevModelMaxOutputTokens, y as getDefaultImageModel } from "./config-B55PwJzQ.js";
+import { $ as buildCodexRequestHeaders, B as getXaiAccessToken, C as copilotHeaders, D as prepareForCompact, E as isOpencodeOauthApp, F as compactTextOnlyGuard, I as createAuthMiddleware, J as readGitHubTokenFromEnv, L as getConfiguredAdminApiKeys, M as compactMessageSections, O as prepareInteractionHeaders, P as compactSystemPromptStarts, Q as CODEX_API_BASE_URL, S as copilotBaseUrl, T as copilotWebSocketHeaders, U as readXaiCredentials, Y as XAI_API_BASE_URL, _ as isAsyncIterable, at as setPluginRequestActualModel, b as parseUserIdMetadata, ct as createResponsesSafeStream, d as generateRequestIdFromPayload, dt as createPooledWebSocketStream, et as forwardCodexResponses, f as getPromptCacheKey, ft as createWebSocketUrl, g as getUUID, h as getSessionAffinityFromHeaders, it as resolveTraceId$1, j as compactAutoContinuePromptStarts, k as prepareMessageProxyHeaders, lt as encodePoolKeyPart, m as getRootSessionIdFromHeaders, mt as stripInternalRequestHeaders, n as invalidateCodexRuntime, nt as generateTraceId, ot as fetchUpstreamWithLifecycle, p as getRootSessionId, q as readGitHubToken, rt as requestContext, s as setupCodexToken, st as createResponsesHttpEventStream, tt as formatPluginActualModel, u as stopCopilotRefreshLoop, ut as getResponsesStreamTerminalDisposition, v as isNullish, x as getCopilotUsage, y as isResponsesStream } from "./token-DFlvOMh2.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-DzipwtCX.js";
-import { n as isProviderAgentModelVisible, t as getProviderAgentModels } from "./provider-management-C8AWr-Gk.js";
-import { i as registerProcessCleanup, n as stopModelsRefreshLoop, r as EventBus, t as setupCopilotRuntime } from "./copilot-runtime-DvmA6ALD.js";
+import { n as isProviderAgentModelVisible, t as getProviderAgentModels } from "./provider-management-C6ZgkTJ7.js";
+import { i as registerProcessCleanup, n as stopModelsRefreshLoop, r as EventBus, t as setupCopilotRuntime } from "./copilot-runtime-DNKNavLK.js";
 import consola from "consola";
-import { createHash, randomUUID } from "node:crypto";
-import fs, { createWriteStream, readFileSync, rmSync } from "node:fs";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import fs, { createReadStream, createWriteStream, readFileSync, rmSync } from "node:fs";
 import path, { join } from "node:path";
-import fs$1, { mkdtemp, rm } from "node:fs/promises";
+import fs$1, { mkdtemp, open, rm } from "node:fs/promises";
 import os, { tmpdir } from "node:os";
 import { fetch as fetch$1, getGlobalDispatcher } from "undici";
 import { events } from "fetch-event-stream";
@@ -21,6 +21,9 @@ import { streamSSE } from "hono/streaming";
 import { Busboy } from "@fastify/busboy";
 import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
+import { none } from "stream-chain/core";
+import { jsonParser } from "stream-json/core/parser.js";
+import stringer from "stream-json/core/stringer.js";
 import { decompress } from "fzstd";
 // src/lib/trace.ts
 const traceIdMiddleware = async (c, next) => {
@@ -175,10 +178,15 @@ function initializeTokenUsageDb(db) {
 	ensureColumn(db, "total_cost_nanos", "INTEGER");
 	ensureColumn(db, "cost_source", "TEXT");
 	ensureColumn(db, "request_id", "TEXT");
+	ensureColumn(db, "upstream_request_id", "TEXT");
 	ensureColumn(db, "first_token_ms", "REAL");
 	ensureColumn(db, "duration_ms", "REAL");
 	ensureColumn(db, "request_outcome", "TEXT");
 	db.exec(`
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_token_usage_events_upstream_request
+    ON token_usage_events(source, provider_name, endpoint, upstream_request_id)
+  `);
+	db.exec(`
     CREATE INDEX IF NOT EXISTS idx_token_usage_events_request_id
     ON token_usage_events(request_id)
   `);
@@ -243,12 +251,14 @@ async function writeTokenUsageEvent(event) {
         total_cost_nanos,
         cost_source,
         request_id,
+        upstream_request_id,
         first_token_ms,
         duration_ms,
         request_outcome,
         user_agent
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(event.created_at_ms, event.created_at_utc, event.trace_id, event.session_id, event.user_id, event.source, event.endpoint, event.provider_name, event.model, event.input_tokens, event.output_tokens, event.cache_read_input_tokens, event.cache_creation_input_tokens, event.total_tokens, event.total_nano_aiu, event.cost_currency, event.total_cost_nanos, event.cost_source, event.request_id, event.first_token_ms, event.duration_ms, event.request_outcome, event.user_agent);
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(source, provider_name, endpoint, upstream_request_id) DO NOTHING
+    `).run(event.created_at_ms, event.created_at_utc, event.trace_id, event.session_id, event.user_id, event.source, event.endpoint, event.provider_name, event.model, event.input_tokens, event.output_tokens, event.cache_read_input_tokens, event.cache_creation_input_tokens, event.total_tokens, event.total_nano_aiu, event.cost_currency, event.total_cost_nanos, event.cost_source, event.request_id, event.upstream_request_id ?? null, event.first_token_ms, event.duration_ms, event.request_outcome, event.user_agent);
 }
 function enqueueTokenUsageWrite(event) {
 	if (!isTokenUsageStorageEnabled()) return;
@@ -906,14 +916,17 @@ async function closeUsageStore() {
 registerProcessCleanup(closeUsageStore);
 // src/lib/request-events.ts
 const TRACKED = /\/(chat\/completions|responses|messages|alpha\/search)$/;
+const IMAGE_REQUEST = /\/images\/(generations|edits)$/u;
 function setPluginRequestModel(model) {
 	requestContext.getStore()?.pluginRequest?.setModel(model);
 }
 function requestEventsMiddleware(plugins, port) {
 	return async (c, next) => {
-		if (c.req.method !== "POST" || !TRACKED.test(c.req.path)) return await next();
+		const isImageRequest = IMAGE_REQUEST.test(c.req.path);
+		if (c.req.method !== "POST" || !TRACKED.test(c.req.path) && !isImageRequest) return await next();
 		const store = requestContext.getStore();
 		if (!store) return await next();
+		const requestPlugins = isImageRequest ? void 0 : plugins;
 		const started = performance.now();
 		const info = {
 			id: randomUUID(),
@@ -937,7 +950,7 @@ function requestEventsMiddleware(plugins, port) {
 			recordFirstToken: () => {
 				if (finished || timing.firstTokenMs !== null) return;
 				timing.firstTokenMs = performance.now() - started;
-				plugins?.publish("request.first_token", {
+				requestPlugins?.publish("request.first_token", {
 					...info,
 					firstTokenMs: timing.firstTokenMs
 				});
@@ -951,7 +964,7 @@ function requestEventsMiddleware(plugins, port) {
 			timing.durationMs = performance.now() - started;
 			timing.outcome = outcome;
 			if (timing.hasUsage) enqueueTokenUsageTiming(timing);
-			plugins?.publish("request.end", {
+			requestPlugins?.publish("request.end", {
 				...info,
 				durationMs: timing.durationMs,
 				firstTokenMs: timing.firstTokenMs,
@@ -961,33 +974,33 @@ function requestEventsMiddleware(plugins, port) {
 			signal.removeEventListener("abort", abort);
 		};
 		const abort = () => finish("cancelled");
-		if (plugins?.enabled) store.pluginRequest = {
+		if (requestPlugins?.enabled) store.pluginRequest = {
 			id: info.id,
 			setModel: (model) => {
 				if (finished || typeof model !== "string" || !model || info.model === model) return;
 				info.model = model;
-				plugins.publish("request.model", info);
+				requestPlugins.publish("request.model", info);
 			},
 			setActualModel: (model) => {
 				if (finished || typeof model !== "string" || !model || info.actualModel === model) return;
 				info.actualModel = model;
-				plugins.publish("request.actual_model", info);
+				requestPlugins.publish("request.actual_model", info);
 			},
 			setSessionId: (sessionId) => {
 				if (!sessionId || info.sessionId === sessionId) return;
 				info.sessionId = sessionId;
-				if (!finished) plugins.publish("request.session", info);
+				if (!finished) requestPlugins.publish("request.session", info);
 			},
 			recordFirstToken: timing.recordFirstToken,
-			recordUsage: (event) => plugins.publish("usage.recorded", {
+			recordUsage: (event) => requestPlugins.publish("usage.recorded", {
 				...event,
 				requestId: info.id,
 				userAgent: info.userAgent,
 				sessionId: event.session_id || null,
-				actualModel: event.model
+				actualModel: formatPluginActualModel(event.model, event.provider_name)
 			})
 		};
-		plugins?.publish("request.start", info);
+		requestPlugins?.publish("request.start", info);
 		signal.addEventListener("abort", abort, { once: true });
 		if (signal.aborted) abort();
 		try {
@@ -1389,6 +1402,54 @@ async function ensureConfiguredProviderModelAlias(alias, resolveConfig = resolve
 async function resolveConfiguredProviderModelAlias(model, resolveConfig = resolveProviderConfig) {
 	return ensureConfiguredProviderModelAlias(parseProviderModelAlias(model), resolveConfig);
 }
+// src/lib/token-usage/image-pricing.ts
+const IMAGE_PRICES = {
+	textInput: 5,
+	imageInput: 8,
+	imageOutput: 30
+};
+const IMAGE_MODELS = /* @__PURE__ */ new Set([
+	"gpt-image-2",
+	"gpt-image-2.5",
+	"gpt-image-2.5-sunburst",
+	"gpt-image-2.5-flare"
+]);
+function splitTokens(total, details, defaultModality) {
+	const tokens = normalizeToken(total);
+	if (details?.image_tokens !== void 0) {
+		const image = Math.min(tokens, normalizeToken(details.image_tokens));
+		return {
+			image,
+			text: tokens - image
+		};
+	}
+	if (details?.text_tokens !== void 0) {
+		const text = Math.min(tokens, normalizeToken(details.text_tokens));
+		return {
+			image: tokens - text,
+			text
+		};
+	}
+	return defaultModality === "image" ? {
+		image: tokens,
+		text: 0
+	} : {
+		image: 0,
+		text: tokens
+	};
+}
+function resolveBuiltinImageCost(input) {
+	const model = input.model.trim().toLowerCase().replace(/-\d{4}-\d{2}-\d{2}$/u, "");
+	if (!IMAGE_MODELS.has(model)) return null;
+	const prompt = splitTokens(input.input_tokens, input.input_tokens_details, "text");
+	const output = splitTokens(input.output_tokens, input.output_tokens_details, "image");
+	const totalCostNanos = Math.round((prompt.text * IMAGE_PRICES.textInput + prompt.image * IMAGE_PRICES.imageInput + output.image * IMAGE_PRICES.imageOutput) * 1e3);
+	return totalCostNanos > 0 ? {
+		currency: "USD",
+		source: "builtin",
+		total_cost_nanos: totalCostNanos
+	} : null;
+}
 // src/lib/token-usage/pricing.ts
 const COST_NANOS_PER_UNIT = 1e9;
 const COST_NANOS_PER_TOKEN_AT_ONE_PER_MILLION = 1e3;
@@ -1401,13 +1462,14 @@ const BUILTIN_PROVIDER_CURRENCIES = {
 	"opencode-go": "USD"
 };
 function resolveTokenUsageCost(input) {
-	if (input.source === "provider" && input.providerName?.trim().toLowerCase() === "openrouter") {
+	if (input.source === "provider" && ["openrouter", "xai"].includes(input.providerName?.trim().toLowerCase() ?? "")) {
 		const reportedCost = resolveReportedProviderCost(input);
 		if (reportedCost) return reportedCost;
 	}
 	if (input.source === "copilot") return resolveCopilotCost(input);
 	const providerName = input.providerName?.trim();
 	if (!providerName) return null;
+	if (providerName.toLowerCase() === "codex" && !input.pricing && (input.endpoint === "images_generations" || input.endpoint === "images_edits")) return resolveBuiltinImageCost(input);
 	const resolvedPricing = resolveProviderPricing(providerName, input.model, input.pricing);
 	if (!resolvedPricing) return null;
 	const pricing = resolvePricingTier(resolvedPricing.pricing, getInputTokenTotal(input), resolvePricingTime(input.at));
@@ -1446,6 +1508,9 @@ function resolveReportedProviderCost(input) {
 		total_cost_nanos: totalCostNanos
 	};
 }
+function xaiUsdTicksToCost(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value / 1e10 : void 0;
+}
 function resolveCopilotCost(input) {
 	const totalNanoAiu = normalizeToken(input.total_nano_aiu);
 	if (totalNanoAiu <= 0) return null;
@@ -1551,13 +1616,13 @@ function resolveUserId(input) {
 	return state.userName?.trim() || "";
 }
 function toPersistedEvent(input) {
-	if (!hasAnyToken(input)) return null;
 	const now = /* @__PURE__ */ new Date();
-	const timing = requestContext.getStore()?.requestTiming;
 	const cost = resolveTokenUsageCost({
 		...input,
 		at: now
 	});
+	if (!hasAnyToken(input) && !cost) return null;
+	const timing = requestContext.getStore()?.requestTiming;
 	return {
 		request_id: timing?.id ?? null,
 		first_token_ms: timing?.firstTokenMs ?? null,
@@ -1581,7 +1646,8 @@ function toPersistedEvent(input) {
 		total_tokens: resolveTotalTokens(input),
 		trace_id: resolveTraceId(input.traceId),
 		user_agent: (requestContext.getStore()?.userAgent ?? "").slice(0, USER_AGENT_MAX_LENGTH),
-		user_id: resolveUserId(input)
+		user_id: resolveUserId(input),
+		upstream_request_id: input.upstreamRequestId?.trim() || null
 	};
 }
 tokenUsageEventBus.subscribe("token_usage.recorded", enqueueTokenUsageWrite);
@@ -2230,7 +2296,7 @@ async function forwardProviderMessages(providerConfig, payload, requestHeaders,
 	const headers = buildProviderUpstreamHeaders(providerConfig, requestHeaders);
 	applyOpencodeSessionHeader(providerConfig, headers, resolveOpencodeMessagesSession(payload));
 	const transportConfig = getUpstreamTransportConfig();
-	setPluginRequestActualModel(payload.model);
+	setPluginRequestActualModel(payload.model, providerConfig.name);
 	return await fetchUpstreamWithLifecycle(resolveProviderEndpointUrl(providerConfig, "messages"), {
 		method: "POST",
 		headers,
@@ -2246,7 +2312,7 @@ async function forwardProviderChatCompletions(providerConfig, payload, requestHe
 	const headers = buildProviderUpstreamHeaders(providerConfig, requestHeaders);
 	applyOpencodeSessionHeader(providerConfig, headers, payload.prompt_cache_key?.trim() || void 0);
 	const transportConfig = getUpstreamTransportConfig();
-	setPluginRequestActualModel(payload.model);
+	setPluginRequestActualModel(payload.model, providerConfig.name);
 	return await fetchUpstreamWithLifecycle(resolveProviderEndpointUrl(providerConfig, "chat/completions"), {
 		method: "POST",
 		headers,
@@ -2263,7 +2329,7 @@ async function forwardProviderResponses(providerConfig, payload, requestHeaders,
 	const headers = buildProviderUpstreamHeaders(providerConfig, requestHeaders);
 	applyOpencodeSessionHeader(providerConfig, headers, payload.prompt_cache_key?.trim() || void 0);
 	await applyXaiGrokBuildHeaders(providerConfig, headers, payload);
-	setPluginRequestActualModel(payload.model);
+	setPluginRequestActualModel(payload.model, providerConfig.name);
 	return await fetchUpstreamWithLifecycle(resolveProviderEndpointUrl(providerConfig, "responses"), {
 		method: "POST",
 		headers,
@@ -2887,7 +2953,7 @@ function parseDebugBody(body) {
 }
 async function forwardCodexAlphaSearchRequest(request, model) {
 	await debugJsonAsync(logger$19, "alpha_search.codex.request", async () => ({ body: parseDebugBody(await request.clone().text()) }));
-	if (model) setPluginRequestActualModel(model);
+	if (model) setPluginRequestActualModel(model, "codex");
 	const upstreamResponse = await alphaSearchRouteDependencies.forwardCodexAlphaSearch(request);
 	await debugJsonAsync(logger$19, "alpha_search.codex.response", async () => ({
 		body: parseDebugBody(await upstreamResponse.clone().text()),
@@ -3821,7 +3887,7 @@ var XaiImagesRequestError = class extends Error {
 		this.name = "XaiImagesRequestError";
 	}
 };
-function isRecord$3(value) {
+function isRecord$5(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function readPrompt(value) {
@@ -3930,7 +3996,7 @@ function readImageReference(value) {
 		type: "image_url",
 		url: normalizeImageUrl(value)
 	};
-	if (!isRecord$3(value)) throw new XaiImagesRequestError("image must be a URL or an image object");
+	if (!isRecord$5(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)
@@ -3975,7 +4041,7 @@ function buildEditPayload(model, prompt, images, source) {
 * 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");
+	if (!isRecord$5(payload)) throw new XaiImagesRequestError("Image generation body must be a JSON object");
 	const translated = {
 		model,
 		prompt: readPrompt(payload.prompt)
@@ -3987,7 +4053,7 @@ function translateXaiImageGeneration(payload, model) {
 * 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");
+	if (!isRecord$5(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);
 }
 const MAX_RESPONSE_IMAGE_BYTES = 33554432;
@@ -4080,15 +4146,15 @@ async function ensureImageResponseB64Json(response, fetchImage = globalThis.fetc
 	} catch {
 		return rebuildJsonResponse(response, body);
 	}
-	if (!isRecord$3(payload) || !Array.isArray(payload.data)) return rebuildJsonResponse(response, body);
+	if (!isRecord$5(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) {
+		if (isRecord$5(item) && onImageUrl) {
 			const outputUrl = imageOutputUrlForLog(item.url);
 			if (outputUrl) onImageUrl(outputUrl);
 		}
-		if (!isRecord$3(item) || responseFormat === "url" || responseHasB64Json(item.b64_json)) {
+		if (!isRecord$5(item) || responseFormat === "url" || responseHasB64Json(item.b64_json)) {
 			data.push(item);
 			continue;
 		}
@@ -4223,7 +4289,7 @@ async function parseMultipartImageEdit(request) {
 			const headers = new Headers(requestHeaders);
 			headers.delete("content-length");
 			let body;
-			if (provider === "codex" || provider === "xai") {
+			if (provider === "codex" || provider === "xai" || provider === "github-copilot") {
 				const payload = {
 					...await readPayload(),
 					...model === void 0 ? {} : { model }
@@ -4246,6 +4312,603 @@ async function parseMultipartImageEdit(request) {
 		}
 	};
 }
+// src/lib/image-json-files.ts
+const IMAGE_JSON_MAX_BYTES = 536870912;
+function imageJsonLimitError() {
+	return new HTTPError("Image JSON upload exceeds the staging limit", Response.json({ error: {
+		message: "Image JSON upload exceeds the staging limit",
+		type: "invalid_request_error"
+	} }, { status: 413 }));
+}
+/** Owns only an mkdtemp-created directory; callers never supply deletion paths. */
+async function createImageJsonFiles(ttlMs = 9e5) {
+	const directory = await mkdtemp(join(tmpdir(), "copilot-image-json-"));
+	let index = 0;
+	let timer;
+	let cleanupPromise;
+	const unregister = registerProcessCleanup(() => {
+		if (timer) clearTimeout(timer);
+		rmSync(directory, {
+			recursive: true,
+			force: true
+		});
+	});
+	const cleanup = () => {
+		cleanupPromise ??= (async () => {
+			if (timer) clearTimeout(timer);
+			await rm(directory, {
+				recursive: true,
+				force: true,
+				maxRetries: 3,
+				retryDelay: 20
+			});
+			unregister();
+		})();
+		return cleanupPromise;
+	};
+	return {
+		directory,
+		cleanup,
+		scheduleCleanup() {
+			if (timer || cleanupPromise) return;
+			timer = setTimeout(() => void cleanup().catch(() => {}), ttlMs);
+			timer.unref();
+		},
+		async create() {
+			const path = join(directory, String(index++));
+			return {
+				path,
+				handle: await open(path, "wx")
+			};
+		}
+	};
+}
+async function* readImageJsonFile(path, signal) {
+	const stream = createReadStream(path, {
+		highWaterMark: 65536,
+		signal
+	});
+	try {
+		for await (const bytes of stream) yield bytes;
+	} finally {
+		stream.destroy();
+	}
+}
+// src/lib/streaming-json.ts
+const JSON_CHUNK_BYTES = 65536;
+/** Never ask the tokenizer to accumulate untrusted strings, keys, or numbers. */
+var StreamingJsonReader = class {
+	decode = new TextDecoder("utf-8", { fatal: true });
+	parse = jsonParser({ packValues: false });
+	depth = 0;
+	scalarLength = 0;
+	boundedScalar = false;
+	read(bytes) {
+		const text = this.decode.decode(bytes, { stream: bytes !== void 0 });
+		const result = this.parse(text);
+		const tokens = result === none ? [] : result.values;
+		if (bytes === void 0) {
+			const last = this.parse(none);
+			if (last !== none) tokens.push(...last.values);
+		}
+		for (const token of tokens) switch (token.name) {
+			case "startObject":
+			case "startArray":
+				if (++this.depth > 64) throw new SyntaxError("JSON nesting exceeds 64");
+				break;
+			case "endObject":
+			case "endArray":
+				this.depth--;
+				break;
+			case "startKey":
+			case "startNumber":
+				this.scalarLength = 0;
+				this.boundedScalar = true;
+				break;
+			case "endKey":
+			case "endNumber":
+				this.boundedScalar = false;
+				break;
+			case "stringChunk":
+			case "numberChunk": if (this.boundedScalar) {
+				this.scalarLength += token.value.length;
+				if (this.scalarLength > 65536) throw new SyntaxError("JSON key or number is too large");
+			}
+		}
+		return tokens;
+	}
+};
+/** Splitting also bounds tokenizer allocations when a runtime supplies a huge chunk. */
+async function* readJsonBytes(body, signal) {
+	if (!body) return;
+	const reader = body.getReader();
+	const abort = () => void reader.cancel(signal?.reason).catch(() => {});
+	signal?.addEventListener("abort", abort, { once: true });
+	let complete = false;
+	try {
+		while (true) {
+			signal?.throwIfAborted();
+			const { done, value } = await reader.read();
+			signal?.throwIfAborted();
+			if (done) {
+				complete = true;
+				return;
+			}
+			for (let offset = 0; offset < value.byteLength; offset += JSON_CHUNK_BYTES) yield value.subarray(offset, offset + JSON_CHUNK_BYTES);
+		}
+	} finally {
+		signal?.removeEventListener("abort", abort);
+		if (!complete) await reader.cancel().catch(() => {});
+		reader.releaseLock();
+	}
+}
+function createJsonByteSource(body, signal) {
+	const controller = new AbortController();
+	const bytes = readJsonBytes(body, AbortSignal.any([signal, controller.signal]));
+	return {
+		bytes,
+		async cancel(reason) {
+			controller.abort(reason);
+			await bytes.return(void 0).catch(() => {});
+			if (body && !body.locked) await body.cancel(reason).catch(() => {});
+		}
+	};
+}
+/** Lazy streams allow a route to choose the original or rebuilt body without teeing. */
+function jsonByteStream(iterator, cancel) {
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				const { done, value } = await iterator.next();
+				if (done) controller.close();
+				else controller.enqueue(value);
+			} catch (error) {
+				controller.error(error);
+				await iterator.return(void 0).catch(() => {});
+			}
+		},
+		async cancel(reason) {
+			await cancel?.(reason);
+			await iterator.return(void 0);
+		}
+	}, { highWaterMark: 0 });
+}
+var DuplicateImageModelError = class extends SyntaxError {
+	constructor() {
+		super("Duplicate top-level image model");
+	}
+};
+/** Keeps only the top-level model; all image string chunks are discarded. */
+var ImageModelReader = class {
+	model;
+	object = false;
+	complete = false;
+	invalidModel = false;
+	depth = 0;
+	key = "";
+	inKey = false;
+	readingModel = false;
+	modelText = "";
+	seenModel = false;
+	read(tokens) {
+		for (const token of tokens) {
+			if (token.name === "startKey") {
+				this.inKey = true;
+				this.key = "";
+			} else if (token.name === "endKey") {
+				this.inKey = false;
+				if (this.depth === 1 && this.key === "model") {
+					if (this.seenModel) throw new DuplicateImageModelError();
+					this.seenModel = true;
+				}
+			} else if (token.name === "stringChunk") {
+				if (this.inKey) this.key += token.value;
+				else if (this.readingModel) {
+					this.modelText += token.value;
+					if (this.modelText.length > 4096) {
+						this.invalidModel = true;
+						this.readingModel = false;
+						this.modelText = "";
+					}
+				}
+			} else if (token.name === "startString") this.readingModel = this.depth === 1 && this.key === "model";
+			else if (token.name === "endString") {
+				if (this.readingModel) {
+					this.model = this.modelText;
+					this.modelText = "";
+					this.readingModel = false;
+				}
+			} else if (this.depth === 1 && this.key === "model" && [
+				"startObject",
+				"startArray",
+				"startNumber",
+				"nullValue",
+				"trueValue",
+				"falseValue"
+			].includes(token.name)) this.invalidModel = true;
+			if (token.name === "startObject" || token.name === "startArray") {
+				if (this.depth === 0) this.object = token.name === "startObject";
+				this.depth++;
+			} else if (token.name === "endObject" || token.name === "endArray") {
+				if (--this.depth === 0) this.complete = true;
+			}
+		}
+	}
+};
+/** Re-encodes bounded chunks, replacing or inserting the top-level model. */
+async function* rewriteImageModel(input, model, insertModel = false) {
+	const parser = new StreamingJsonReader();
+	const encode = new TextEncoder();
+	const stringify = stringer();
+	let depth = 0;
+	let key = "";
+	let inKey = false;
+	let replacing = false;
+	const process = (tokens) => {
+		const parts = [];
+		const emit = (token) => {
+			const text = stringify(token);
+			if (text !== none) parts.push(text);
+		};
+		for (const token of tokens) {
+			if (insertModel && depth === 0 && token.name === "startObject") {
+				emit(token);
+				emit({ name: "startKey" });
+				emit({
+					name: "stringChunk",
+					value: "model"
+				});
+				emit({ name: "endKey" });
+				emit({ name: "startString" });
+				emit({
+					name: "stringChunk",
+					value: model
+				});
+				emit({ name: "endString" });
+				depth++;
+				continue;
+			}
+			if (replacing) {
+				if (token.name === "endString") replacing = false;
+				continue;
+			}
+			if (token.name === "startKey") {
+				inKey = true;
+				key = "";
+			} else if (token.name === "endKey") inKey = false;
+			else if (token.name === "stringChunk" && inKey) key += token.value;
+			if (token.name === "startString" && depth === 1 && key === "model") {
+				emit(token);
+				emit({
+					name: "stringChunk",
+					value: model
+				});
+				emit({ name: "endString" });
+				replacing = true;
+				continue;
+			}
+			emit(token);
+			if (token.name === "startObject" || token.name === "startArray") depth++;
+			else if (token.name === "endObject" || token.name === "endArray") depth--;
+		}
+		return encode.encode(parts.join(""));
+	};
+	for await (const bytes of input) yield process(parser.read(bytes));
+	const tail = process(parser.read());
+	if (tail.byteLength) yield tail;
+}
+// src/lib/image-json-request.ts
+function rebuild(request, body, changed = false) {
+	const headers = new Headers(request.headers);
+	if (changed) headers.delete("content-length");
+	return new Request(request.url, {
+		method: request.method,
+		headers,
+		body,
+		signal: request.signal,
+		duplex: "half"
+	});
+}
+/** Read at most 64 KiB before forwarding a model-first request. Late models use disk. */
+async function prepareImageJsonRequest(request, maxStagedBytes = IMAGE_JSON_MAX_BYTES) {
+	const forwardingAbort = new AbortController();
+	const signal = AbortSignal.any([request.signal, forwardingAbort.signal]);
+	const input = createJsonByteSource(request.body, signal);
+	const bytes = input.bytes;
+	const parser = new StreamingJsonReader();
+	const metadata = new ImageModelReader();
+	let valid = true;
+	const scan = (chunk) => {
+		if (!valid) return;
+		try {
+			metadata.read(parser.read(chunk));
+		} catch (error) {
+			if (error instanceof DuplicateImageModelError) throw error;
+			valid = false;
+		}
+	};
+	const prefix = [];
+	let length = 0;
+	let eof = false;
+	let pending;
+	async function* remaining() {
+		if (pending) {
+			const chunk = pending;
+			pending = void 0;
+			yield chunk;
+		}
+		yield* bytes;
+	}
+	let files;
+	let stagedPath;
+	try {
+		while (length < JSON_CHUNK_BYTES) {
+			const next = await bytes.next();
+			if (next.done) {
+				eof = true;
+				scan();
+				break;
+			}
+			const chunk = next.value.subarray(0, JSON_CHUNK_BYTES - length);
+			pending = chunk.byteLength < next.value.byteLength ? next.value.subarray(chunk.byteLength) : void 0;
+			prefix.push(chunk);
+			length += chunk.byteLength;
+			scan(chunk);
+			if (!valid || metadata.model !== void 0 || metadata.invalidModel || metadata.complete) break;
+		}
+		if (valid && !eof && !metadata.complete && metadata.model === void 0 && !metadata.invalidModel) {
+			files = await createImageJsonFiles();
+			const file = await files.create();
+			stagedPath = file.path;
+			try {
+				for (const chunk of prefix) {
+					if (length > maxStagedBytes) throw imageJsonLimitError();
+					await file.handle.writeFile(chunk);
+				}
+				prefix.length = 0;
+				for await (const chunk of remaining()) {
+					length += chunk.byteLength;
+					if (length > maxStagedBytes) throw imageJsonLimitError();
+					scan(chunk);
+					await file.handle.writeFile(chunk);
+				}
+				eof = true;
+				scan();
+			} finally {
+				await file.handle.close();
+			}
+			files.scheduleCleanup();
+		}
+	} catch (error) {
+		await input.cancel(error);
+		await files?.cleanup();
+		if (error instanceof DuplicateImageModelError) throw new HTTPError(error.message, Response.json({ error: {
+			message: error.message,
+			type: "invalid_request_error"
+		} }, { status: 400 }));
+		throw error;
+	}
+	let claimed = false;
+	const abort = () => {
+		input.cancel().catch(() => {});
+		files?.cleanup().catch(() => {});
+	};
+	request.signal.addEventListener("abort", abort, { once: true });
+	async function* source() {
+		if (claimed) throw new Error("Image request body already forwarded");
+		claimed = true;
+		try {
+			signal.throwIfAborted();
+			if (stagedPath) yield* readImageJsonFile(stagedPath, signal);
+			else {
+				yield* prefix;
+				prefix.length = 0;
+				if (!eof) {
+					for await (const chunk of remaining()) {
+						scan(chunk);
+						yield chunk;
+					}
+					scan();
+				}
+			}
+		} finally {
+			request.signal.removeEventListener("abort", abort);
+			await bytes.return(void 0).catch(() => {});
+			await files?.cleanup();
+		}
+	}
+	const cancel = async (reason) => {
+		forwardingAbort.abort(reason);
+		request.signal.removeEventListener("abort", abort);
+		await input.cancel(reason);
+		await files?.cleanup();
+	};
+	return {
+		valid: valid && metadata.object && !metadata.invalidModel,
+		model: metadata.model,
+		originalRequest: rebuild(request, jsonByteStream(source(), cancel)),
+		createRequest: (model) => rebuild(request, jsonByteStream(rewriteImageModel(source(), model, metadata.model === void 0), cancel), true),
+		cleanup: cancel,
+		stagedDirectory: files?.directory
+	};
+}
+// src/lib/image-json-metadata.ts
+const MAX_METADATA_LENGTH = 65536;
+const OMITTED_FIELDS = /* @__PURE__ */ new Set([
+	"data",
+	"b64_json",
+	"partial_image_b64"
+]);
+/** Reads JSON/SSE object metadata without retaining image payloads. */
+var ImageJsonMetadataReader = class {
+	depth = 0;
+	inString = false;
+	escaped = false;
+	phase = "key";
+	keyText = "";
+	key = "";
+	value = null;
+	fields = /* @__PURE__ */ new Map();
+	metadataLength = 0;
+	onMetadata;
+	constructor(onMetadata) {
+		this.onMetadata = onMetadata;
+	}
+	write(text) {
+		for (const char of text) this.readCharacter(char);
+	}
+	readCharacter(char) {
+		if (this.depth === 0) {
+			if (char === "{") {
+				this.depth = 1;
+				this.phase = "key";
+				this.fields.clear();
+				this.metadataLength = 0;
+			}
+			return;
+		}
+		if (!this.inString && this.depth === 1) {
+			if (char === "}") {
+				if (this.phase === "value") this.finishField();
+				this.depth = 0;
+				this.onMetadata(Object.fromEntries(this.fields));
+				return;
+			}
+			if (this.phase === "key" && char === "\"") {
+				this.keyText = "\"";
+				this.phase = "colon";
+				this.inString = true;
+				return;
+			}
+			if (this.phase === "colon" && char === ":") {
+				try {
+					this.key = JSON.parse(this.keyText);
+				} catch {
+					this.key = "";
+				}
+				this.value = OMITTED_FIELDS.has(this.key) ? null : "";
+				this.phase = "value";
+				return;
+			}
+			if (this.phase === "value" && char === ",") {
+				this.finishField();
+				this.phase = "key";
+				return;
+			}
+		}
+		if (this.phase === "colon" && this.keyText.length < MAX_METADATA_LENGTH) this.keyText += char;
+		else if (this.phase === "value" && this.value !== null) {
+			if (this.metadataLength + this.value.length < MAX_METADATA_LENGTH) this.value += char;
+			else this.value = null;
+		}
+		if (this.inString) {
+			if (this.escaped) this.escaped = false;
+			else if (char === "\\") this.escaped = true;
+			else if (char === "\"") this.inString = false;
+		} else if (char === "\"") this.inString = true;
+		else if (char === "{" || char === "[") this.depth++;
+		else if (char === "}" || char === "]") this.depth--;
+	}
+	finishField() {
+		if (this.value === null) return;
+		try {
+			const value = JSON.parse(this.value);
+			this.fields.set(this.key, value);
+			this.metadataLength += this.key.length + this.value.length;
+		} catch {}
+		this.value = null;
+	}
+};
+// src/lib/token-usage/images.ts
+function isRecord$4(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function token(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? normalizeToken(value) : void 0;
+}
+function tokenDetails(value) {
+	if (!isRecord$4(value)) return void 0;
+	return {
+		image_tokens: token(value.image_tokens),
+		text_tokens: token(value.text_tokens)
+	};
+}
+function normalizeImagesUsage(usage, provider) {
+	if (!isRecord$4(usage)) return {};
+	const inputDetails = tokenDetails(usage.input_tokens_details);
+	const outputDetails = tokenDetails(usage.output_tokens_details);
+	return {
+		cost: provider.toLowerCase() === "xai" ? xaiUsdTicksToCost(usage.cost_in_usd_ticks) : void 0,
+		input_tokens: token(usage.input_tokens) ?? (inputDetails?.image_tokens ?? 0) + (inputDetails?.text_tokens ?? 0),
+		input_tokens_details: inputDetails,
+		output_tokens: token(usage.output_tokens) ?? (outputDetails?.image_tokens ?? 0) + (outputDetails?.text_tokens ?? 0),
+		output_tokens_details: outputDetails,
+		total_tokens: token(usage.total_tokens)
+	};
+}
+/** Observes bytes as the client reads them; image data is never buffered here. */
+function observeImagesResponse(response, options) {
+	if (!response.body) return createProviderProxyResponse(response);
+	const context = requestContext.getStore();
+	const provider = options.providerConfig;
+	const recordUsage = createTokenUsageRecorder({
+		source: provider.name === "github-copilot" ? "copilot" : "provider",
+		endpoint: options.operation === "edits" ? "images_edits" : "images_generations",
+		model: options.model,
+		pricing: provider.models?.[options.model]?.pricing,
+		pricingCurrency: provider.pricingCurrency,
+		providerName: provider.name
+	});
+	let usage = {};
+	let finished = false;
+	const decoder = new TextDecoder();
+	const metadataReader = new ImageJsonMetadataReader((metadata) => {
+		if (context) requestContext.run(context, () => options.onMetadata(metadata));
+		else options.onMetadata(metadata);
+		if (response.ok) {
+			if (isRecord$4(metadata.usage)) usage = {
+				...usage,
+				...normalizeImagesUsage(metadata.usage, provider.name)
+			};
+			if (provider.name === "github-copilot" && isRecord$4(metadata.copilot_usage)) {
+				const totalNanoAiu = token(metadata.copilot_usage.total_nano_aiu);
+				if (totalNanoAiu !== void 0) usage.total_nano_aiu = totalNanoAiu;
+			}
+		}
+	});
+	const finish = () => {
+		if (finished) return;
+		finished = true;
+		if (context) requestContext.run(context, () => recordUsage(usage));
+		else recordUsage(usage);
+	};
+	const reader = response.body.getReader();
+	return createProviderProxyResponse(response, new ReadableStream({
+		async pull(controller) {
+			try {
+				const next = await reader.read();
+				if (next.done) {
+					metadataReader.write(decoder.decode());
+					finish();
+					reader.releaseLock();
+					controller.close();
+				} else {
+					metadataReader.write(decoder.decode(next.value, { stream: true }));
+					controller.enqueue(next.value);
+				}
+			} catch (error) {
+				finish();
+				reader.releaseLock();
+				controller.error(error);
+			}
+		},
+		async cancel(reason) {
+			finish();
+			await reader.cancel(reason);
+			reader.releaseLock();
+		}
+	}));
+}
 // src/lib/xai-image-model.ts
 /**
 * Resolves one image-route model setting. Empty values keep the OpenAI
@@ -4275,32 +4938,482 @@ function getImageGenerationModel() {
 function getImageEditModel() {
 	return resolveConfiguredXaiImageModel(getConfig().imageEditModel, "imageEditModel");
 }
+// src/lib/image-json-value.ts
+const STRING_LIMIT = 65536;
+const METADATA_LIMIT = 1048576;
+/** Builds bounded metadata, optionally storing large decoded strings on disk. */
+var ImageJsonValueReader = class {
+	value;
+	external = [];
+	stack = [];
+	key = "";
+	inKey = false;
+	number = "";
+	string;
+	metadataSize = 0;
+	files;
+	externalize;
+	constructor(externalize = false) {
+		this.externalize = externalize;
+	}
+	charge(size) {
+		this.metadataSize += size;
+		if (this.metadataSize > METADATA_LIMIT) throw new SyntaxError("Image JSON metadata exceeds 1 MiB");
+	}
+	add(value) {
+		this.charge(16);
+		const frame = this.stack.at(-1);
+		if (!frame) this.value = value;
+		else if (Array.isArray(frame.value)) frame.value.push(value);
+		else frame.value[frame.key] = value;
+	}
+	field() {
+		const frame = this.stack.at(-1);
+		return frame ? Array.isArray(frame.value) ? frame.field : frame.key : "";
+	}
+	async append(text) {
+		const value = this.string;
+		if (!value.external && value.text.length + text.length <= STRING_LIMIT) {
+			value.text += text;
+			return;
+		}
+		if (!this.externalize) {
+			value.text = "[large string omitted]";
+			value.external ??= {
+				placeholder: value.text,
+				path: "",
+				mode: value.mode,
+				first: 0,
+				end: 0,
+				length: 0,
+				prefix: "",
+				invalidBase64: false,
+				padding: 0
+			};
+			return;
+		}
+		if (!value.external) {
+			if (this.external.length >= 64) throw new SyntaxError("Too many large image JSON strings");
+			this.files ??= await createImageJsonFiles();
+			const file = await this.files.create();
+			value.external = {
+				placeholder: randomBytes(24).toString("hex"),
+				path: file.path,
+				mode: value.mode,
+				first: -1,
+				end: 0,
+				length: 0,
+				prefix: "",
+				invalidBase64: false,
+				padding: 0
+			};
+			value.handle = file.handle;
+			this.external.push(value.external);
+			this.track(value.text);
+			value.pending.push(value.text);
+			value.text = "";
+		}
+		this.track(text);
+		value.pending.push(text);
+	}
+	track(text) {
+		const value = this.string.external;
+		const first = text.search(/\S/u);
+		if (first !== -1) {
+			if (value.first === -1) value.first = value.length + first;
+			value.end = value.length + text.trimEnd().length;
+		}
+		value.length += text.length;
+		const normalized = value.mode === "compact" ? text.replaceAll(/\s+/gu, "") : value.prefix ? text : text.trimStart();
+		if (value.prefix.length < 256) value.prefix = (value.prefix + normalized).slice(0, 256);
+		if (value.mode === "compact") {
+			if (value.padding && /[^=]/u.test(normalized)) value.invalidBase64 = true;
+			if (!/^[a-z0-9+/]*={0,2}$/iu.test(normalized)) value.invalidBase64 = true;
+			value.padding += normalized.length - normalized.replaceAll("=", "").length;
+			if (value.padding > 2) value.invalidBase64 = true;
+		}
+	}
+	async flushString() {
+		const value = this.string;
+		if (value?.handle && value.pending.length) {
+			await value.handle.writeFile(Buffer.from(value.pending.join(""), "utf16le"));
+			value.pending = [];
+		}
+	}
+	async read(tokens) {
+		for (const token of tokens) switch (token.name) {
+			case "startObject":
+			case "startArray": {
+				const field = this.field();
+				const value = token.name === "startArray" ? [] : Object.create(null);
+				this.add(value);
+				this.stack.push({
+					value,
+					key: "",
+					field
+				});
+				break;
+			}
+			case "endObject":
+			case "endArray":
+				this.stack.pop();
+				break;
+			case "startKey":
+				this.inKey = true;
+				this.key = "";
+				break;
+			case "endKey":
+				this.inKey = false;
+				this.charge(this.key.length);
+				this.stack.at(-1).key = this.key;
+				break;
+			case "startString": {
+				const field = this.field();
+				this.string = {
+					text: "",
+					pending: [],
+					mode: field === "b64_json" ? "compact" : [
+						"image",
+						"images",
+						"url",
+						"image_url"
+					].includes(field) ? "trim" : "identity"
+				};
+				break;
+			}
+			case "stringChunk":
+				if (this.inKey) this.key += token.value;
+				else await this.append(token.value);
+				break;
+			case "endString": {
+				await this.flushString();
+				const value = this.string;
+				await value.handle?.close();
+				value.handle = void 0;
+				if (value.external && this.externalize) {
+					const external = value.external;
+					external.placeholder = (/^(?:https?:\/\/|data:image\/[a-z0-9.+-]+;base64,)/iu.exec(external.prefix)?.[0] ?? "") + external.placeholder;
+					this.add(external.first === -1 ? "" : external.placeholder);
+				} else {
+					this.charge(value.text.length);
+					this.add(value.text);
+				}
+				this.string = void 0;
+				break;
+			}
+			case "startNumber":
+				this.number = "";
+				break;
+			case "numberChunk":
+				this.number += token.value;
+				break;
+			case "endNumber":
+				this.add(Number(this.number));
+				break;
+			case "trueValue":
+				this.add(true);
+				break;
+			case "falseValue":
+				this.add(false);
+				break;
+			case "nullValue": this.add(null);
+		}
+		await this.flushString();
+	}
+	async cleanup() {
+		await this.string?.handle?.close();
+		if (this.string) this.string.handle = void 0;
+		await this.files?.cleanup();
+	}
+	scheduleCleanup() {
+		this.files?.scheduleCleanup();
+	}
+};
+/** Reads xAI input into a small skeleton, never assembling large image strings. */
+async function readExternalImageJson(request, maxBytes = IMAGE_JSON_MAX_BYTES) {
+	const reader = new ImageJsonValueReader(true);
+	const parser = new StreamingJsonReader();
+	let length = 0;
+	try {
+		for await (const chunk of readJsonBytes(request.body, request.signal)) {
+			length += chunk.byteLength;
+			if (length > maxBytes) throw imageJsonLimitError();
+			await reader.read(parser.read(chunk));
+		}
+		await reader.read(parser.read());
+		reader.scheduleCleanup();
+		return reader;
+	} catch (error) {
+		await reader.cleanup();
+		throw error;
+	}
+}
+function assertExternalImageBase64(reader, payload) {
+	const text = JSON.stringify(payload);
+	for (const value of reader.external) if (text.includes(value.placeholder) && value.mode === "compact" && !value.prefix.startsWith("data:image/") && value.invalidBase64) throw new SyntaxError("image b64_json is not valid base64");
+}
+/** Serializes the translated skeleton, expanding only strings retained by xAI. */
+function externalImageJsonStream(reader, payload, signal) {
+	const template = JSON.stringify(payload);
+	const pattern = new RegExp(reader.external.map((value) => value.placeholder.replaceAll(/[.*+?^${}()|[\]\\]/gu, "\\$&")).join("|"), "gu");
+	const encode = new TextEncoder();
+	let activeStream;
+	async function* serialize() {
+		try {
+			signal.throwIfAborted();
+			let offset = 0;
+			for (const match of reader.external.length ? template.matchAll(pattern) : []) {
+				signal.throwIfAborted();
+				yield encode.encode(template.slice(offset, match.index));
+				const value = reader.external.find((item) => item.placeholder === match[0]);
+				const trim = value.mode !== "identity";
+				const stream = createReadStream(value.path, {
+					encoding: "utf16le",
+					highWaterMark: 65536,
+					start: trim ? value.first * 2 : 0,
+					end: trim ? value.end * 2 - 1 : void 0
+				});
+				activeStream = stream;
+				try {
+					for await (const chunk of stream) {
+						signal.throwIfAborted();
+						const text = String(chunk);
+						yield encode.encode(JSON.stringify(value.mode === "compact" ? text.replaceAll(/\s+/gu, "") : text).slice(1, -1));
+					}
+				} finally {
+					stream.destroy();
+					activeStream = void 0;
+				}
+				offset = match.index + match[0].length;
+			}
+			signal.throwIfAborted();
+			yield encode.encode(template.slice(offset));
+		} catch (error) {
+			signal.throwIfAborted();
+			throw error;
+		} finally {
+			await reader.cleanup();
+		}
+	}
+	const abort = () => {
+		activeStream?.destroy();
+		reader.cleanup().catch(() => {});
+	};
+	signal.addEventListener("abort", abort, { once: true });
+	if (signal.aborted) abort();
+	async function* body() {
+		try {
+			yield* serialize();
+		} finally {
+			signal.removeEventListener("abort", abort);
+		}
+	}
+	return jsonByteStream(body(), async () => {
+		signal.removeEventListener("abort", abort);
+		activeStream?.destroy();
+		await reader.cleanup();
+	});
+}
+// src/routes/images/request-logging.ts
+function redactImageBase64(value, key = "") {
+	if ([
+		"b64_json",
+		"base64",
+		"image_base64"
+	].includes(key)) return "[image base64 omitted]";
+	if (typeof value === "string") return /^data:image\/[^,]+;base64,/iu.test(value) ? "[image base64 omitted]" : value;
+	if (Array.isArray(value)) return value.map((item) => redactImageBase64(item));
+	if (value !== null && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([field, item]) => [field, redactImageBase64(item, field)]));
+	return value;
+}
+async function editRequestBody(request) {
+	try {
+		const cloned = request.clone();
+		if (request.headers.get("content-type")?.includes("multipart/form-data")) {
+			const fields = [];
+			for (const [name, value] of await cloned.formData()) fields.push({
+				name,
+				value: typeof value === "string" ? redactImageBase64(value, name) : {
+					filename: value.name,
+					mime_type: value.type,
+					size: value.size
+				}
+			});
+			return fields;
+		}
+		return redactImageBase64(await cloned.json());
+	} catch {
+		return "[unavailable JSON body]";
+	}
+}
+async function logImageEditRequest(logger, label, request, extra = {}, debug = debugJsonAsync) {
+	if (!state.verbose) return request;
+	if (!request.headers.get("content-type")?.includes("multipart/form-data")) return logImageJsonRequest(logger, label, request, extra, debug);
+	await debug(logger, label, async () => ({
+		contentType: request.headers.get("content-type"),
+		contentLength: request.headers.get("content-length"),
+		...extra,
+		body: await editRequestBody(request)
+	}));
+	return request;
+}
+/** Observes the same chunks sent upstream; debug logging never tees JSON bodies. */
+function logImageJsonRequest(logger, label, request, extra, debug) {
+	const value = new ImageJsonValueReader();
+	const parser = new StreamingJsonReader();
+	const input = createJsonByteSource(request.body, request.signal);
+	let valid = true;
+	async function* observe() {
+		for await (const chunk of input.bytes) {
+			if (valid) try {
+				await value.read(parser.read(chunk));
+			} catch {
+				valid = false;
+			}
+			yield chunk;
+		}
+		if (valid) try {
+			await value.read(parser.read());
+		} catch {
+			valid = false;
+		}
+		await debug(logger, label, () => Promise.resolve({
+			contentType: request.headers.get("content-type"),
+			contentLength: request.headers.get("content-length"),
+			...extra,
+			body: valid ? redactImageBase64(value.value) : "[unavailable JSON body]"
+		}));
+	}
+	return new Request(request.url, {
+		method: request.method,
+		headers: request.headers,
+		signal: request.signal,
+		body: jsonByteStream(observe(), (reason) => input.cancel(reason)),
+		duplex: "half"
+	});
+}
+DEFAULT_IMAGE_MODELS["github-copilot"];
+const COPILOT_CLIENT_VERSION = "copilot/1.0.103-unstable.r40031404408.gba6c003";
+const COPILOT_IMAGES_TIMEOUT_MS = 9e5;
+const copilotImagesDispatcher = createTimeoutDispatcher(COPILOT_IMAGES_TIMEOUT_MS);
+function resolveCopilotImagesUrl(requestUrl, operation) {
+	const upstreamUrl = new URL(`${copilotBaseUrl(state).replace(/\/+$/u, "")}/v1/images/${operation}`);
+	if (upstreamUrl.hostname === "api.githubcopilot.com") upstreamUrl.hostname = `api.${state.accountType}.githubcopilot.com`;
+	upstreamUrl.search = new URL(requestUrl).search;
+	return upstreamUrl.toString();
+}
+async function forwardCopilotImages(request, operation) {
+	assertGitHubCopilotEnabled();
+	if (!state.githubToken) throw new HTTPError("GitHub token not found", Response.json({ error: {
+		message: "GitHub token not found",
+		type: "authentication_error"
+	} }, { status: 401 }));
+	const init = {
+		method: "POST",
+		headers: {
+			authorization: `Bearer ${state.githubToken}`,
+			"content-type": "application/json",
+			accept: request.headers.get("accept") ?? "application/json",
+			"copilot-integration-id": "vscode-chat",
+			"copilot-harness-id": "copilot-sdk",
+			"editor-version": COPILOT_CLIENT_VERSION,
+			"user-agent": `${COPILOT_CLIENT_VERSION} (${process.platform} unknown) term/unknown client/vscode-agent-host`,
+			"openai-intent": "conversation-agent",
+			"x-initiator": "agent",
+			"x-github-api-version": "2026-08-01",
+			"x-client-machine-id": state.vsCodeDeviceId,
+			"x-interaction-id": randomUUID()
+		},
+		body: request.body,
+		duplex: "half",
+		signal: AbortSignal.any([request.signal, AbortSignal.timeout(COPILOT_IMAGES_TIMEOUT_MS)])
+	};
+	const upstreamUrl = resolveCopilotImagesUrl(request.url, operation);
+	const response = typeof Bun !== "undefined" ? await fetch(upstreamUrl, init) : await fetch$1(upstreamUrl, {
+		...init,
+		dispatcher: copilotImagesDispatcher
+	});
+	logCopilotRateLimits(response.headers);
+	return response;
+}
 // src/routes/images/forward-provider-images.ts
 /**
 * Forwards an images request to a configured provider with debug logging.
 * Shared by the top-level images routes (model mapping) and the
 * provider-scoped images routes so both log and proxy identically.
 */
-async function forwardProviderImagesWithLogging(providerConfig, request, operation, { logger, provider }) {
-	if (operation === "generations") await debugJsonAsync(logger, `provider.images.${operation}.request`, async () => ({
-		body: await request.clone().text(),
-		provider
-	}));
-	else debugJson(logger, `provider.images.${operation}.request`, {
-		contentType: request.headers.get("content-type"),
-		contentLength: request.headers.get("content-length"),
-		provider
-	});
-	const upstreamResponse = await forwardProviderImages(providerConfig, request, operation);
+async function forwardProviderImagesWithLogging(providerConfig, request, operation, { logger, provider, model }) {
+	let actualModel = model;
+	if (actualModel === void 0 && !request.headers.get("content-type")?.includes("multipart/form-data")) {
+		const parsed = await prepareImageJsonRequest(request);
+		actualModel = parsed.valid ? parsed.model : "unknown";
+		request = parsed.originalRequest;
+	}
+	actualModel ??= "unknown";
+	request = await logImageEditRequest(logger, `provider.images.${operation}.request`, request, { provider });
+	let upstreamResponse;
+	try {
+		upstreamResponse = providerConfig.name === "github-copilot" ? await forwardCopilotImages(request, operation) : await forwardProviderImages(providerConfig, request, operation);
+	} catch (error) {
+		await request.body?.cancel().catch(() => {});
+		throw error;
+	}
 	debugJson(logger, `provider.images.${operation}.response`, {
 		contentType: upstreamResponse.headers.get("content-type"),
 		contentLength: upstreamResponse.headers.get("content-length"),
 		provider,
 		statusCode: upstreamResponse.status
 	});
-	return createProviderProxyResponse(upstreamResponse);
+	return observeImagesResponse(upstreamResponse, {
+		model: actualModel,
+		operation,
+		providerConfig,
+		onMetadata: (metadata) => debugJson(logger, `provider.images.${operation}.response.body`, {
+			provider,
+			...metadata
+		})
+	});
+}
+async function forwardCopilotImagesWithLogging(request, operation, context) {
+	const config = getRawProviderConfig(GITHUB_COPILOT_PROVIDER);
+	return await forwardProviderImagesWithLogging({
+		name: GITHUB_COPILOT_PROVIDER,
+		type: "openai-compatible",
+		authType: "oauth2",
+		apiKey: "",
+		baseUrl: "",
+		models: config?.models,
+		pricingCurrency: config?.pricingCurrency
+	}, request, operation, context);
+}
+/** Forwards translated xAI requests and normalizes OpenAI-compatible output. */
+async function forwardXaiImagesWithLogging(providerConfig, request, operation, payload, { logger, provider }, body) {
+	return await ensureImageResponseB64Json(await forwardProviderImagesWithLogging(providerConfig, new Request(request.url, {
+		body: body ?? new TextEncoder().encode(JSON.stringify(payload)),
+		duplex: "half",
+		headers: {
+			accept: "application/json",
+			"content-type": "application/json"
+		},
+		method: "POST",
+		signal: request.signal
+	}), operation, {
+		logger,
+		provider,
+		model: typeof payload.model === "string" ? payload.model : "unknown"
+	}), void 0, {
+		clientSignal: request.signal,
+		onImageUrl: (url) => {
+			logger.info("images.xai.output.url", JSON.stringify({
+				operation,
+				url
+			}));
+		},
+		responseFormat: payload.response_format === "url" ? "url" : "b64_json"
+	});
 }
 // src/services/codex/images.ts
+const DEFAULT_CODEX_IMAGE_MODEL = DEFAULT_IMAGE_MODELS.codex;
 const CODEX_IMAGES_TIMEOUT_MS = 9e5;
 const codexImagesDispatcher = createTimeoutDispatcher(CODEX_IMAGES_TIMEOUT_MS);
 function resolveCodexImagesUrl(requestUrl, operation) {
@@ -4326,12 +5439,66 @@ async function forwardCodexImages(request, operation) {
 		dispatcher: codexImagesDispatcher
 	});
 }
+// src/routes/images/xai-json-request.ts
+/** Existing translators validate a bounded skeleton; large strings stay on disk. */
+async function translateXaiImageJsonRequest(request, operation, model) {
+	let json;
+	try {
+		json = await readExternalImageJson(request);
+	} catch (error) {
+		if (error instanceof HTTPError || request.signal.aborted) throw error;
+		throw new XaiImagesRequestError(operation === "edits" ? "Image edit body must be JSON" : "Image generation body must be JSON");
+	}
+	try {
+		const payload = operation === "edits" ? translateXaiImageEditJson(json.value, model) : translateXaiImageGeneration(json.value, model);
+		try {
+			assertExternalImageBase64(json, payload);
+		} catch {
+			throw new XaiImagesRequestError("image b64_json is not valid base64");
+		}
+		const input = json.value;
+		return {
+			payload,
+			body: externalImageJsonStream(json, payload, request.signal),
+			requestedModel: typeof input.model === "string" ? input.model : model
+		};
+	} catch (error) {
+		await json.cleanup();
+		throw error;
+	}
+}
+// src/routes/images/default-model.ts
+/** Resolve the three supported image models before sending the request. */
+async function resolveImageRequestModel(requestedModel, options = {}) {
+	if (options.provider) {
+		const model = getDefaultImageModel(options.provider);
+		if (model) return model;
+	}
+	const availability = /* @__PURE__ */ new Map();
+	const isAvailable = (provider) => {
+		let pending = availability.get(provider);
+		if (!pending) {
+			pending = provider === "github-copilot" ? Promise.resolve((options.isGitHubCopilotAvailable ?? isGitHubCopilotAvailable)()) : (options.resolveProviderConfig ?? resolveProviderConfig)(provider).then((config) => config !== null);
+			availability.set(provider, pending);
+		}
+		return pending;
+	};
+	const requested = requestedModel?.trim();
+	const selected = IMAGE_PROVIDER_PRIORITY.find((provider) => requested === DEFAULT_IMAGE_MODELS[provider] || requested === `${provider}/${DEFAULT_IMAGE_MODELS[provider]}`);
+	if (selected && await isAvailable(selected)) return `${selected}/${DEFAULT_IMAGE_MODELS[selected]}`;
+	for (const provider of IMAGE_PROVIDER_PRIORITY) if (await isAvailable(provider)) return `${provider}/${DEFAULT_IMAGE_MODELS[provider]}`;
+	throw new HTTPError("No enabled image provider is available", Response.json({ error: {
+		message: "No enabled image provider is available",
+		type: "invalid_request_error"
+	} }, { status: 404 }));
+}
 // src/routes/images/shared.ts
 const logger$15 = createHandlerLogger("images-handler");
 const imageRouteDependencies = {
 	debugJsonAsync,
 	getImageEditModel,
 	getImageGenerationModel,
+	isGitHubCopilotAvailable,
 	resolveMappedModel,
 	resolveProviderConfig
 };
@@ -4350,106 +5517,91 @@ function getContentMetadata(headers) {
 	};
 }
 /**
-* Snapshots generated request headers before consuming the body.
-*/
-function snapshotRequestHeaders(request) {
-	return new Headers(request.headers);
-}
-/**
-* Rebuilds a request from primitives instead of cloning: under Node runtimes
-* srvx wraps incoming requests in a proxy class whose prototype chain
-* satisfies `instanceof Request` without the native internals, so
-* `new Request(request)` throws.
-*/
-function createForwardRequest(request, requestHeaders, body) {
-	const init = {
-		body,
-		duplex: "half",
-		headers: requestHeaders,
-		method: request.method,
-		signal: request.signal
-	};
-	return new Request(request.url, init);
-}
-function createJsonImagesRequest(request, requestHeaders, payload, model) {
-	const headers = new Headers(requestHeaders);
-	headers.delete("content-length");
-	return createForwardRequest(request, headers, new TextEncoder().encode(JSON.stringify({
-		...payload,
-		model
-	})));
-}
-/**
 * Parses an image request body as JSON, retaining the original bytes for
 * unchanged forwarding while allowing model mapping to rebuild the payload.
 * Rebuilt bodies stay binary so Node does not synthesize a text/plain content type.
 */
 async function parseJsonImagesRequest(request) {
-	const requestHeaders = snapshotRequestHeaders(request);
-	const body = new Uint8Array(await request.arrayBuffer());
-	const originalRequest = createForwardRequest(request, requestHeaders, body);
-	let payload;
-	try {
-		const bodyText = new TextDecoder("utf-8", { fatal: true }).decode(body);
-		payload = JSON.parse(bodyText);
-	} catch {
-		return originalRequest;
-	}
-	if (payload === null || typeof payload !== "object" || Array.isArray(payload) || typeof payload.model !== "string") return originalRequest;
-	return {
-		createRequest: (mappedModel) => createJsonImagesRequest(request, requestHeaders, payload, mappedModel),
-		model: payload.model,
-		originalRequest
-	};
+	const parsed = await prepareImageJsonRequest(request);
+	return parsed.valid ? parsed : parsed.originalRequest;
 }
 /**
 * Handles Codex images proxying. Pass a resolvedProviderConfig when the
 * caller already resolved the codex provider to avoid a second resolve, and
 * pass a request when model mapping rebuilt the request body.
 */
-async function handleCodexImages(c, operation, resolvedProviderConfig, request = c.req.raw) {
+async function handleCodexImages(c, operation, resolvedProviderConfig, request = c.req.raw, model) {
 	try {
-		if (!(resolvedProviderConfig ?? await imageRouteDependencies.resolveProviderConfig("codex"))) return c.json({ error: {
-			message: "Provider 'codex' not found or disabled",
-			type: "invalid_request_error"
-		} }, 404);
-		if (operation === "generations") await imageRouteDependencies.debugJsonAsync(logger$15, "images.generations.codex.request", async () => ({ body: await request.clone().text() }));
-		else debugJson(logger$15, "images.edits.codex.request", getContentMetadata(request.headers));
+		const codexProviderConfig = resolvedProviderConfig ?? await imageRouteDependencies.resolveProviderConfig("codex");
+		if (!codexProviderConfig) {
+			await request.body?.cancel().catch(() => {});
+			return c.json({ error: {
+				message: "Provider 'codex' not found or disabled",
+				type: "invalid_request_error"
+			} }, 404);
+		}
+		let actualModel = model;
+		if (actualModel === void 0 && !request.headers.get("content-type")?.includes("multipart/form-data")) {
+			const parsed = await prepareImageJsonRequest(request);
+			actualModel = parsed.valid ? parsed.model ?? DEFAULT_CODEX_IMAGE_MODEL : "unknown";
+			request = parsed.originalRequest;
+		}
+		actualModel ??= "unknown";
+		request = await logImageEditRequest(logger$15, `images.${operation}.codex.request`, request, {}, imageRouteDependencies.debugJsonAsync);
 		const upstreamResponse = await forwardCodexImages(request, operation);
 		debugJson(logger$15, `images.${operation}.codex.response`, {
 			...getContentMetadata(upstreamResponse.headers),
 			statusCode: upstreamResponse.status
 		});
-		return createProviderProxyResponse(upstreamResponse);
+		return observeImagesResponse(upstreamResponse, {
+			model: actualModel,
+			operation,
+			providerConfig: codexProviderConfig,
+			onMetadata: (metadata) => debugJson(logger$15, `images.${operation}.codex.response.body`, metadata)
+		});
 	} catch (error) {
+		await request.body?.cancel().catch(() => {});
 		logger$15.error(`images.${operation}.codex.error`, { error });
 		return await forwardError(c, error);
 	}
 }
 /**
-* Routes a parsed images request: applies the model mapping, forwards to a
-* mapped provider when configured, and otherwise falls back to Codex.
+* Applies model mappings and resolves unknown or absent models to an available
+* provider's image default before dispatching.
 */
 async function routeImagesRequest(c, operation, parsed) {
-	const requestedModel = parsed.model;
-	const mappedModel = imageRouteDependencies.resolveMappedModel(requestedModel);
-	if (mappedModel !== requestedModel) consola.debug(`Resolved model mapping: ${requestedModel} -> ${mappedModel}`);
-	const providerModelAlias = parseProviderModelAlias(mappedModel);
-	if (providerModelAlias) {
-		const providerConfig = await imageRouteDependencies.resolveProviderConfig(providerModelAlias.provider);
-		if (providerConfig) {
-			const request = await parsed.createRequest(providerModelAlias.model, providerConfig.name);
-			if (providerConfig.name === "codex") return await handleCodexImages(c, operation, providerConfig, request);
-			return await forwardProviderImagesWithLogging(providerConfig, request, operation, {
-				logger: logger$15,
-				provider: providerModelAlias.provider
-			});
-		}
-		consola.debug(`Provider '${providerModelAlias.provider}' not found or disabled; forwarding the original model to Codex`);
-		return await handleCodexImages(c, operation, void 0, parsed.originalRequest ?? await parsed.createRequest(requestedModel));
+	let resolvedModel;
+	try {
+		resolvedModel = await resolveImageRequestModel(parsed.model?.trim() ? imageRouteDependencies.resolveMappedModel(parsed.model.trim()) : void 0, {
+			resolveProviderConfig: imageRouteDependencies.resolveProviderConfig,
+			isGitHubCopilotAvailable: imageRouteDependencies.isGitHubCopilotAvailable
+		});
+	} catch (error) {
+		await parsed.originalRequest?.body?.cancel().catch(() => {});
+		throw error;
 	}
-	if (parsed.originalRequest && mappedModel === requestedModel) return await handleCodexImages(c, operation, void 0, parsed.originalRequest);
-	return await handleCodexImages(c, operation, void 0, await parsed.createRequest(mappedModel));
+	const alias = parseProviderModelAlias(resolvedModel);
+	if (!alias) throw new Error("Invalid resolved image model");
+	consola.debug(`Resolved image model: ${parsed.model ?? "(default)"} -> ${resolvedModel}`);
+	const request = parsed.originalRequest && (alias.provider === "xai" || parsed.model === alias.model) ? parsed.originalRequest : await parsed.createRequest(alias.model, alias.provider);
+	if (alias.provider === "github-copilot") return await forwardCopilotImagesWithLogging(request, operation, {
+		logger: logger$15,
+		...alias
+	});
+	const providerConfig = await imageRouteDependencies.resolveProviderConfig(alias.provider);
+	if (!providerConfig) {
+		await request.body?.cancel().catch(() => {});
+		throw new HTTPError(`Provider '${alias.provider}' not found or disabled`, Response.json({ error: {
+			message: `Provider '${alias.provider}' not found or disabled`,
+			type: "invalid_request_error"
+		} }, { status: 404 }));
+	}
+	if (alias.provider === "codex") return await handleCodexImages(c, operation, providerConfig, request, alias.model);
+	const translated = await translateXaiImageJsonRequest(request, operation, alias.model);
+	return await forwardXaiImagesWithLogging(providerConfig, request, operation, translated.payload, {
+		logger: logger$15,
+		...alias
+	}, translated.body);
 }
 // src/routes/images/xai-handler.ts
 function xaiImagesRequestErrorResponse(c, error) {
@@ -4459,50 +5611,28 @@ function xaiImagesRequestErrorResponse(c, error) {
 		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) {
+async function forwardTranslatedXaiImages(c, operation, payload, body) {
 	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, {
+	if (!providerConfig) {
+		await body?.cancel();
+		return c.json({ error: {
+			message: "Provider 'xai' not found or disabled",
+			type: "invalid_request_error"
+		} }, 404);
+	}
+	return await forwardXaiImagesWithLogging(providerConfig, c.req.raw, operation, payload, {
 		logger: logger$15,
 		provider: "xai"
-	}), void 0, {
-		clientSignal: request.signal,
-		onImageUrl: (url) => {
-			logger$15.info("images.xai.output.url", JSON.stringify({
-				operation,
-				url
-			}));
-		},
-		responseFormat: payload.response_format === "url" ? "url" : "b64_json"
-	});
+	}, body);
 }
 async function handleXaiImageGeneration(c, model) {
-	return await forwardTranslatedXaiImages(c, "generations", translateXaiImageGeneration(await readJsonBody(c.req.raw, "Image generation body must be JSON"), model));
+	const translated = await translateXaiImageJsonRequest(c.req.raw, "generations", model);
+	return await forwardTranslatedXaiImages(c, "generations", translated.payload, translated.body);
 }
 async function handleXaiImageEdit(c, model, multipartPayload) {
-	return await forwardTranslatedXaiImages(c, "edits", translateXaiImageEditJson(multipartPayload ?? await readJsonBody(c.req.raw, "Image edit body must be JSON"), model));
+	if (multipartPayload) return await forwardTranslatedXaiImages(c, "edits", translateXaiImageEditJson(multipartPayload, model));
+	const translated = await translateXaiImageJsonRequest(c.req.raw, "edits", model);
+	return await forwardTranslatedXaiImages(c, "edits", translated.payload, translated.body);
 }
 // src/routes/images/edits-handler.ts
 async function handleImagesEdits(c) {
@@ -4517,7 +5647,6 @@ async function handleImagesEdits(c) {
 		const multipart = await parseMultipartImageEdit(c.req.raw);
 		if (multipart) try {
 			if (configuredModel.status === "xai") return await handleXaiImageEdit(c, configuredModel.model, await multipart.readPayload());
-			if (multipart.model === void 0) return await handleCodexImages(c, "edits", void 0, await multipart.createRequest(void 0));
 			return await routeImagesRequest(c, "edits", {
 				model: multipart.model,
 				createRequest: (model, provider) => multipart.createRequest(model, provider)
@@ -4530,7 +5659,7 @@ async function handleImagesEdits(c) {
 		}
 		if (configuredModel.status === "xai") return await handleXaiImageEdit(c, configuredModel.model);
 		const parsed = await parseJsonImagesRequest(c.req.raw);
-		if (parsed instanceof Request) return await handleCodexImages(c, "edits", void 0, parsed);
+		if (parsed instanceof Request) return await handleCodexImages(c, "edits", void 0, parsed, "unknown");
 		return await routeImagesRequest(c, "edits", parsed);
 	} catch (error) {
 		const invalidRequest = imageEditRequestErrorResponse(c, error);
@@ -4549,7 +5678,7 @@ async function handleImagesGenerations(c) {
 		} }, 400);
 		if (configuredModel.status === "xai") return await handleXaiImageGeneration(c, configuredModel.model);
 		const parsed = await parseJsonImagesRequest(c.req.raw);
-		if (parsed instanceof Request) return await handleCodexImages(c, "generations", void 0, parsed);
+		if (parsed instanceof Request) return await handleCodexImages(c, "generations", void 0, parsed, "unknown");
 		return await routeImagesRequest(c, "generations", parsed);
 	} catch (error) {
 		const invalidRequest = xaiImagesRequestErrorResponse(c, error);
@@ -6705,9 +7834,9 @@ const mapResponsesUsage = (response) => {
 		...cacheWriteTokens !== void 0 && { cache_creation_input_tokens: cacheWriteTokens }
 	};
 };
-const isRecord$2 = (value) => typeof value === "object" && value !== null;
-const isResponseOutputText = (block) => isRecord$2(block) && "type" in block && block.type === "output_text";
-const isResponseOutputRefusal = (block) => isRecord$2(block) && "type" in block && block.type === "refusal";
+const isRecord$3 = (value) => typeof value === "object" && value !== null;
+const isResponseOutputText = (block) => isRecord$3(block) && "type" in block && block.type === "output_text";
+const isResponseOutputRefusal = (block) => isRecord$3(block) && "type" in block && block.type === "refusal";
 const convertToolResultContent = (content) => {
 	if (typeof content === "string") return content;
 	if (Array.isArray(content)) {
@@ -7460,7 +8589,7 @@ function resolveToolDescriptor(registry, alias) {
 	};
 }
 function decodeCustomToolInput(input) {
-	if (isRecord$1(input) && typeof input.input === "string") return input.input;
+	if (isRecord$2(input) && typeof input.input === "string") return input.input;
 	return typeof input === "string" ? input : JSON.stringify(input ?? {});
 }
 function toResponseId(messageId) {
@@ -7541,7 +8670,7 @@ function isNamespaceTool(tool) {
 	return getStringField$1(tool, "type") === "namespace";
 }
 function registerTool(tool, registry, strictCustomTools, namespaces = []) {
-	if (!isRecord$1(tool)) throw new ResponsesMessagesTranslationError("Invalid Responses tool definition");
+	if (!isRecord$2(tool)) throw new ResponsesMessagesTranslationError("Invalid Responses tool definition");
 	const type = getStringField$1(tool, "type");
 	if (type === "namespace") {
 		const namespaceTool = tool;
@@ -7558,7 +8687,7 @@ function registerTool(tool, registry, strictCustomTools, namespaces = []) {
 		name,
 		namespace: namespaces.length > 0 ? namespaces.join(".") : void 0,
 		description: getOptionalStringField(tool, "description"),
-		parameters: type === "function" && isRecord$1(tool.parameters) ? tool.parameters : null
+		parameters: type === "function" && isRecord$2(tool.parameters) ? tool.parameters : null
 	}, registry, strictCustomTools);
 }
 function registerMessagesTool(registration, registry, strictCustomTools) {
@@ -7656,7 +8785,7 @@ function translateInputItems(input, messages, system, registry) {
 	}
 }
 function translateInputMessage(item, messages, system, userMessageSeen) {
-	if (!isRecord$1(item)) throw new ResponsesMessagesTranslationError("Invalid Responses message item");
+	if (!isRecord$2(item)) throw new ResponsesMessagesTranslationError("Invalid Responses message item");
 	const role = getStringField$1(item, "role");
 	if (role !== "user" && role !== "assistant" && role !== "system" && role !== "developer") throw new ResponsesMessagesTranslationError("Responses message items require a supported role");
 	if (role === "developer" && !userMessageSeen) return;
@@ -7696,7 +8825,7 @@ function appendDeveloperPrompts(system, input) {
 		if (type === "agent_message") break;
 		if ((type === void 0 || type === "message") && role === "user") break;
 		if (type !== void 0 && type !== "message" || role !== "developer") continue;
-		prompts.push(translateSystemContent(isRecord$1(item) ? item.content : void 0, "message.content"));
+		prompts.push(translateSystemContent(isRecord$2(item) ? item.content : void 0, "message.content"));
 	}
 	const [firstPrompt, ...remainingPrompts] = prompts;
 	if (firstPrompt) system.push({
@@ -7717,7 +8846,7 @@ function translateInputReasoning(item, messages) {
 	});
 }
 function translateInputToolCall(item, kind, messages, registry) {
-	if (!isRecord$1(item)) throw new ResponsesMessagesTranslationError("Invalid Responses tool call item");
+	if (!isRecord$2(item)) throw new ResponsesMessagesTranslationError("Invalid Responses tool call item");
 	const name = requireStringField(item, "name", `${kind}_tool_call`);
 	const namespace = getOptionalStringField(item, "namespace") ?? void 0;
 	const toolIdentity = {
@@ -7748,7 +8877,7 @@ function translateAssistantContent(value, path) {
 	}] : [];
 	if (!Array.isArray(value)) throw new ResponsesMessagesTranslationError(`${path} must be text or an array`);
 	return value.map((part, index) => {
-		if (!isRecord$1(part)) throw new ResponsesMessagesTranslationError(`${path}[${index}] must be an object`);
+		if (!isRecord$2(part)) throw new ResponsesMessagesTranslationError(`${path}[${index}] must be an object`);
 		const type = getStringField$1(part, "type");
 		if (type !== "input_text" && type !== "output_text" && type !== "text") throw new ResponsesMessagesTranslationError(`${path}[${index}] has unsupported assistant content type '${type ?? "unknown"}'`);
 		return {
@@ -7762,14 +8891,14 @@ function translateSystemContent(value, path) {
 	if (typeof value === "string") return value;
 	if (!Array.isArray(value)) throw new ResponsesMessagesTranslationError(`${path} must be text or an array`);
 	return value.map((part, index) => {
-		if (!isRecord$1(part)) throw new ResponsesMessagesTranslationError(`${path}[${index}] must be an object`);
+		if (!isRecord$2(part)) throw new ResponsesMessagesTranslationError(`${path}[${index}] must be an object`);
 		const type = getStringField$1(part, "type");
 		if (type !== "input_text" && type !== "output_text" && type !== "text") throw new ResponsesMessagesTranslationError(`${path}[${index}] has unsupported system content type '${type ?? "unknown"}'`);
 		return requireStringField(part, "text", `${path}[${index}]`);
 	}).join("\n\n");
 }
 function translateUserContentPart(part, path) {
-	if (!isRecord$1(part)) throw new ResponsesMessagesTranslationError(`${path} must be an object`);
+	if (!isRecord$2(part)) throw new ResponsesMessagesTranslationError(`${path} must be an object`);
 	const type = getStringField$1(part, "type");
 	if (type === "input_text" || type === "output_text" || type === "text") return {
 		type: "text",
@@ -7791,7 +8920,7 @@ function translateToolResultContent(value, path) {
 	return blocks.length > 0 ? blocks : "";
 }
 function isEmptyTextContentPart(part) {
-	if (!isRecord$1(part)) return false;
+	if (!isRecord$2(part)) return false;
 	const type = part.type;
 	return (type === "input_text" || type === "output_text" || type === "text") && part.text === "";
 }
@@ -7976,7 +9105,7 @@ function appendUserBlock(messages, block) {
 function parseFunctionArguments(value, _path) {
 	try {
 		const parsed = JSON.parse(value);
-		if (isRecord$1(parsed)) return parsed;
+		if (isRecord$2(parsed)) return parsed;
 	} catch {
 		return {};
 	}
@@ -8019,15 +9148,15 @@ function createStableHash(value) {
 	return createHash("sha256").update(value).digest("hex").slice(0, 24);
 }
 function getItemType(value) {
-	return isRecord$1(value) && typeof value.type === "string" ? value.type : void 0;
+	return isRecord$2(value) && typeof value.type === "string" ? value.type : void 0;
 }
 function getStringField$1(value, field) {
-	if (!isRecord$1(value)) return void 0;
+	if (!isRecord$2(value)) return void 0;
 	const fieldValue = value[field];
 	return typeof fieldValue === "string" ? fieldValue : void 0;
 }
 function getOptionalStringField(value, field) {
-	if (!isRecord$1(value)) return void 0;
+	if (!isRecord$2(value)) return void 0;
 	const fieldValue = value[field];
 	return typeof fieldValue === "string" || fieldValue === null ? fieldValue : void 0;
 }
@@ -8037,10 +9166,10 @@ function requireStringField(value, field, path) {
 	return result;
 }
 function getArrayField(value, field) {
-	if (!isRecord$1(value)) return [];
+	if (!isRecord$2(value)) return [];
 	return Array.isArray(value[field]) ? value[field] : [];
 }
-function isRecord$1(value) {
+function isRecord$2(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 const DEFAULT_RESPONSES_COMPACT_THRESHOLD_RATIO = .85;
@@ -9197,7 +10326,7 @@ async function forwardGoogleGenerateContent(provider, model, payload, requestHea
 	applyOpencodeSessionHeader(provider, headers, options.sessionId);
 	headers.accept = options.stream ? "text/event-stream" : "application/json";
 	const transport = getUpstreamTransportConfig();
-	setPluginRequestActualModel(model.replace(/^models\//u, ""));
+	setPluginRequestActualModel(model.replace(/^models\//u, ""), provider.name);
 	return await fetchUpstreamWithLifecycle(url, {
 		method: "POST",
 		headers,
@@ -10498,14 +11627,14 @@ function withModelDisplayName(model, provider) {
 // src/routes/models/model-discovery.ts
 const logger$10 = createHandlerLogger("models-handler");
 const EPOCH_ISO = (/* @__PURE__ */ new Date(0)).toISOString();
-function isRecord(value) {
+function isRecord$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function firstPositiveInteger(...values) {
 	for (const value of values) if (typeof value === "number" && Number.isFinite(value) && value >= 1) return Math.floor(value);
 }
 function normalizeModelCapabilities(model) {
-	if (!isRecord(model.capabilities)) return model;
+	if (!isRecord$1(model.capabilities)) return model;
 	const limits = getRecordField(model.capabilities, "limits");
 	const supports = getRecordField(model.capabilities, "supports");
 	return {
@@ -10536,13 +11665,21 @@ function getStringField(model, field) {
 }
 function getRecordField(model, field) {
 	const value = model?.[field];
-	return isRecord(value) ? value : void 0;
+	return isRecord$1(value) ? value : void 0;
 }
 function getStringList(value) {
 	if (!Array.isArray(value)) return void 0;
 	const strings = [...new Set(value.filter((item) => typeof item === "string"))];
 	return strings.length > 0 ? strings : void 0;
 }
+function isImageOnlyModel(provider, modelId, model, config) {
+	const record = isRecord$1(model) ? model : void 0;
+	const catalog = getModelsDevModel(resolveProviderModelsDevId(provider, config), modelId);
+	const builtin = getBuiltinProviderImageModelRecords(provider).find((image) => image.id === modelId);
+	const output = getStringList(record?.output_modalities) ?? getStringList(getRecordField(record, "architecture")?.output_modalities) ?? getStringList(catalog?.modalities?.output) ?? getStringList(builtin?.output_modalities);
+	if (output) return output.includes("image") && !output.includes("text");
+	return record?.type === "image" || getRecordField(record, "capabilities")?.type === "image";
+}
 function getFallbackProviderModelRecords(provider, reason, details = {}) {
 	const fallbackModels = getLocalProviderModelRecords(provider, getRawProviderConfig(provider)) ?? getBuiltinProviderModelRecords(provider);
 	logger$10.warn(`models.provider.fallback_${reason}`, {
@@ -10552,10 +11689,10 @@ function getFallbackProviderModelRecords(provider, reason, details = {}) {
 	});
 	return fallbackModels;
 }
-function normalizeProviderModel(provider, model, config) {
-	if (!isRecord(model)) return null;
+function normalizeProviderModel(provider, model, config, includeImageModels = false) {
+	if (!isRecord$1(model)) return null;
 	const rawId = getStringField(model, "id");
-	if (!rawId || !isProviderModelVisible(provider, rawId, config)) return null;
+	if (!rawId || !isProviderModelVisible(provider, rawId, config) || !includeImageModels && isImageOnlyModel(provider, rawId, model, config)) return null;
 	const id = `${provider}/${rawId}`;
 	const ownedBy = getStringField(model, "owned_by") ?? getStringField(model, "vendor") ?? provider;
 	return {
@@ -10568,8 +11705,8 @@ function normalizeProviderModel(provider, model, config) {
 		owned_by: ownedBy
 	};
 }
-function normalizeProviderModels(provider, models, config) {
-	return models.map((model) => normalizeProviderModel(provider, model, config)).filter((model) => model !== null);
+function normalizeProviderModels(provider, models, config, includeImageModels = false) {
+	return models.map((model) => normalizeProviderModel(provider, model, config, includeImageModels)).filter((model) => model !== null);
 }
 async function getProviderModelRecords(providerConfig, requestHeaders) {
 	const localModels = getLocalProviderModelRecords(providerConfig.name, providerConfig);
@@ -10578,8 +11715,8 @@ async function getProviderModelRecords(providerConfig, requestHeaders) {
 		const response = await forwardProviderModels(providerConfig, requestHeaders);
 		if (!response.ok) return getFallbackProviderModelRecords(providerConfig.name, "non_ok", { statusCode: response.status });
 		const body = await response.json();
-		if (!isRecord(body) || !Array.isArray(body.data)) return getFallbackProviderModelRecords(providerConfig.name, "invalid_body");
-		return body.data.filter(isRecord).map(normalizeModelCapabilities);
+		if (!isRecord$1(body) || !Array.isArray(body.data)) return getFallbackProviderModelRecords(providerConfig.name, "invalid_body");
+		return body.data.filter(isRecord$1).map(normalizeModelCapabilities);
 	} catch (error) {
 		return getFallbackProviderModelRecords(providerConfig.name, "error", { error });
 	}
@@ -10589,7 +11726,7 @@ function getCopilotModelRecords() {
 }
 function getModelsById(models) {
 	return new Map(models.flatMap((model) => {
-		if (!isRecord(model)) return [];
+		if (!isRecord$1(model)) return [];
 		const id = getStringField(model, "id");
 		return id ? [[id, model]] : [];
 	}));
@@ -10603,12 +11740,22 @@ function deduplicateModels(models, getId) {
 		return true;
 	});
 }
-async function getProviderModels(provider, requestHeaders, selectModels) {
+function withProviderImageModels(provider, models) {
+	const imageModels = getModelsById(getBuiltinProviderImageModelRecords(provider));
+	if (imageModels.size === 0) return models;
+	const listedModels = getModelsById(models);
+	return [...models.map((model) => isRecord$1(model) ? {
+		...imageModels.get(getStringField(model, "id") ?? ""),
+		...model
+	} : model), ...[...imageModels.values()].filter((model) => !listedModels.has(getStringField(model, "id") ?? ""))];
+}
+async function getProviderModels(provider, requestHeaders, selectModels, includeImageModels = false) {
 	try {
 		const providerConfig = await resolveProviderConfig(provider);
 		if (!providerConfig) return [];
-		const models = providerConfig.name === "codex" ? getModels().data.map(normalizeModelCapabilities) : await getProviderModelRecords(providerConfig, requestHeaders);
-		return normalizeProviderModels(providerConfig.name, selectModels?.(providerConfig, models) ?? models, providerConfig);
+		const upstreamModels = providerConfig.name === "codex" ? getModels().data.map(normalizeModelCapabilities) : await getProviderModelRecords(providerConfig, requestHeaders);
+		const models = includeImageModels ? withProviderImageModels(providerConfig.name, upstreamModels) : upstreamModels;
+		return normalizeProviderModels(providerConfig.name, selectModels?.(providerConfig, models) ?? models, providerConfig, includeImageModels);
 	} catch (error) {
 		if (provider === "codex") {
 			logger$10.warn("models.provider.skip_error", {
@@ -10619,14 +11766,22 @@ async function getProviderModels(provider, requestHeaders, selectModels) {
 		}
 		const fallbackModels = getFallbackProviderModelRecords(provider, "error", { error });
 		const providerConfig = getRawProviderConfig(provider);
-		return normalizeProviderModels(provider, selectModels?.(providerConfig, fallbackModels) ?? fallbackModels, providerConfig);
+		return normalizeProviderModels(provider, selectModels?.(providerConfig, fallbackModels) ?? fallbackModels, providerConfig, includeImageModels);
 	}
 }
 async function getAggregatedModels(requestHeaders, selectors = {}) {
 	const rawCopilotModels = getCopilotModelRecords();
-	const copilotModels = (selectors.selectCopilotModels?.(rawCopilotModels) ?? rawCopilotModels).map(normalizeCopilotModel);
-	const providerModelsByProvider = await Promise.all(listEnabledProviders().map((provider) => getProviderModels(provider, requestHeaders, selectors.selectProviderModels)));
-	return deduplicateModels([...copilotModels, ...providerModelsByProvider.flat()], (model) => model.id);
+	const copilotConfig = getRawProviderConfig(GITHUB_COPILOT_PROVIDER);
+	const isCopilotImage = (model) => isImageOnlyModel(GITHUB_COPILOT_PROVIDER, model.id, model, copilotConfig);
+	const copilotModels = (selectors.selectCopilotModels?.(rawCopilotModels) ?? rawCopilotModels).filter((model) => !isCopilotImage(model)).map(normalizeCopilotModel);
+	const rawCopilotImages = selectors.includeImageModels && isGitHubCopilotAvailable() ? withProviderImageModels(GITHUB_COPILOT_PROVIDER, rawCopilotModels.filter(isCopilotImage)) : [];
+	const copilotImages = selectors.includeImageModels && isGitHubCopilotAvailable() ? normalizeProviderModels(GITHUB_COPILOT_PROVIDER, (selectors.selectProviderModels?.(copilotConfig, rawCopilotImages) ?? rawCopilotImages).filter((model) => isRecord$1(model) && isImageOnlyModel("github-copilot", getStringField(model, "id") ?? "", model, copilotConfig)), copilotConfig, true) : [];
+	const providerModelsByProvider = await Promise.all(listEnabledProviders().map((provider) => getProviderModels(provider, requestHeaders, selectors.selectProviderModels, selectors.includeImageModels)));
+	return deduplicateModels([
+		...copilotModels,
+		...copilotImages,
+		...providerModelsByProvider.flat()
+	], (model) => model.id);
 }
 function selectAgentCopilotModels(models) {
 	const selection = getProviderAgentModels(getRawProviderConfig(GITHUB_COPILOT_PROVIDER));
@@ -10639,8 +11794,9 @@ function selectAgentProviderModels(providerConfig, models) {
 	const modelsById = getModelsById(models);
 	return selection.map((id) => modelsById.get(id) ?? { id });
 }
-async function getAgentModels(requestHeaders) {
+async function getAgentModels(requestHeaders, options = {}) {
 	return getAggregatedModels(requestHeaders, {
+		includeImageModels: options.includeImageModels,
 		selectCopilotModels: selectAgentCopilotModels,
 		selectProviderModels: selectAgentProviderModels
 	});
@@ -10804,7 +11960,8 @@ function getCopilotCodexCandidates() {
 	return candidates;
 }
 function isCopilotCodexCandidate(model) {
-	return (model.supported_endpoints ?? []).some((endpoint) => endpoint === MESSAGES_ENDPOINT || endpoint === CHAT_COMPLETIONS_ENDPOINT || RESPONSES_ENDPOINTS.has(endpoint)) && model.capabilities.supports.tool_calls !== false;
+	const endpoints = model.supported_endpoints ?? [];
+	return !isImageOnlyModel("github-copilot", model.id, model) && endpoints.some((endpoint) => endpoint === MESSAGES_ENDPOINT || endpoint === CHAT_COMPLETIONS_ENDPOINT || RESPONSES_ENDPOINTS.has(endpoint)) && model.capabilities.supports.tool_calls !== false;
 }
 function createCopilotCodexCandidate(model) {
 	const reasoningEfforts = normalizeReasoningEfforts(model.capabilities.supports.reasoning_effort);
@@ -10834,9 +11991,11 @@ async function getProviderCodexCandidates(provider, requestHeaders) {
 		const candidates = [];
 		for (const modelId of modelIds) {
 			if (!isProviderModelVisible(provider, modelId, providerConfig)) continue;
+			const remoteModel = modelsById.get(modelId);
+			if (isImageOnlyModel(provider, modelId, remoteModel, providerConfig)) continue;
 			const effectiveType = resolveEffectiveProviderType(providerConfig, modelId);
 			if (!isMessagesFallbackProviderType(effectiveType) && effectiveType !== "openai-responses") continue;
-			candidates.push(createProviderCodexCandidate(providerConfig, modelId, modelsById.get(modelId), effectiveType));
+			candidates.push(createProviderCodexCandidate(providerConfig, modelId, remoteModel, effectiveType));
 		}
 		return candidates;
 	} catch (error) {
@@ -12623,7 +13782,7 @@ async function handleCodexModelsProxy(c, resolvedProviderConfig) {
 	const providerConfig = getRawProviderConfig("codex");
 	return createCodexCatalogResponse(c, {
 		...catalog,
-		models: catalog.models.filter((model) => isProviderAgentModelVisible(providerConfig, model.slug))
+		models: catalog.models.filter((model) => !isImageOnlyModel("codex", model.slug, model, providerConfig) && isProviderAgentModelVisible(providerConfig, model.slug))
 	}, new Set(getProviderAgentModels(providerConfig)), FALLBACK_CODEX_MODELS[0].model_messages);
 }
 async function handleCodexModels(c) {
@@ -12640,10 +13799,10 @@ async function handleMergedCodexModels(c, candidatesRequest, options = {}) {
 		return [];
 	})]);
 	const upstreamCatalog = upstreamCatalogResult?.catalog;
-	const upstreamModels = upstreamCatalog?.models ?? FALLBACK_CODEX_MODELS;
+	const codexConfig = getRawProviderConfig("codex");
+	const upstreamModels = (upstreamCatalog?.models ?? FALLBACK_CODEX_MODELS).filter((model) => !isImageOnlyModel("codex", model.slug, model, codexConfig));
 	const template = selectTemplate(upstreamModels);
 	const catalogModelsBySlug = new Map(upstreamModels.map((model) => [model.slug, model]));
-	const codexConfig = getRawProviderConfig("codex");
 	const copilotConfig = getRawProviderConfig("github-copilot");
 	const visibleUpstreamModels = upstreamModels.filter((model) => isProviderAgentModelVisible(codexConfig, model.slug) && (upstreamCatalog !== void 0 || codexConfig !== null || isProviderAgentModelVisible(copilotConfig, model.slug)));
 	const explicitSlugs = /* @__PURE__ */ new Set();
@@ -12814,15 +13973,17 @@ function getCandidatePriorityBase(candidate) {
 	return PROVIDER_PRIORITY_BASE;
 }
 function isCodexModelsResponse(value) {
-	if (!isRecord(value) || !Array.isArray(value.models)) return false;
-	return value.models.every((model) => isRecord(model) && typeof model.slug === "string");
+	if (!isRecord$1(value) || !Array.isArray(value.models)) return false;
+	return value.models.every((model) => isRecord$1(model) && typeof model.slug === "string");
 }
 // src/routes/models/default-models.ts
 async function handleDefaultModels(c) {
-	return createModelListResponse(c, await (c.req.header("user-agent")?.toLowerCase().startsWith("deepseek") ? getAgentModels : getAggregatedModels)(stripInternalRequestHeaders(c.req.raw.headers)));
+	const isDeepSeekClient = c.req.header("user-agent")?.toLowerCase().startsWith("deepseek") ?? false;
+	return createModelListResponse(c, await (isDeepSeekClient ? getAgentModels : getAggregatedModels)(stripInternalRequestHeaders(c.req.raw.headers), { includeImageModels: !isDeepSeekClient }));
 }
 // src/routes/models/opencode-models.ts
 const RESPONSES_PACKAGE = "@opencode/ai/providers/openai/responses";
+const IMAGES_PACKAGE = "@opencode/ai/providers/openai/images";
 const CNY_PER_USD = 6.7;
 const COST_DECIMALS = 6;
 function isOpencodeUserAgent(userAgent) {
@@ -12891,10 +14052,12 @@ function toOpencodeModel(model, contextWindow) {
 	const config = getRawProviderConfig(provider);
 	const metadata = getModelMetadata(provider, rawId, model, config);
 	const { modelConfig, defaults, catalog, capabilities, supports, limits } = metadata;
+	const output = getStringList(model.output_modalities) ?? getStringList(catalog?.modalities?.output) ?? (model.type === "image" ? ["image"] : ["text"]);
+	const isImage = output.includes("image") && !output.includes("text");
 	const context = metadata.contextWindow ?? 256e3;
 	const inputLimit = metadata.inputLimit ?? 0;
 	const supportedMediaTypes = getStringList(getRecordField(limits, "vision")?.supported_media_types);
-	const supportPdf = resolveModelPdfSupport(provider, {
+	const supportPdf = !isImage && resolveModelPdfSupport(provider, {
 		supportPdf: modelConfig?.supportPdf,
 		supportedMediaTypes,
 		catalogInputModalities: catalog?.modalities?.input,
@@ -12911,15 +14074,16 @@ function toOpencodeModel(model, contextWindow) {
 		id: model.id,
 		modelID: model.id,
 		providerID: "local",
+		...isImage && { type: "image" },
 		name: getStringField(model, "display_name") ?? catalog?.name ?? model.id,
-		family: catalog?.family ?? getStringField(capabilities ?? {}, "family"),
-		package: RESPONSES_PACKAGE,
+		family: catalog?.family ?? getStringField(model, "family") ?? getStringField(capabilities ?? {}, "family"),
+		package: isImage ? IMAGES_PACKAGE : RESPONSES_PACKAGE,
 		capabilities: {
-			tools: typeof supports?.tool_calls === "boolean" ? supports.tool_calls : catalog?.tool_call ?? true,
+			tools: isImage ? false : typeof supports?.tool_calls === "boolean" ? supports.tool_calls : catalog?.tool_call ?? true,
 			input: [...input],
-			output: [...catalog?.modalities?.output ?? ["text"]]
+			output
 		},
-		variants: efforts.map((effort) => ({
+		variants: isImage ? [] : efforts.map((effort) => ({
 			id: effort,
 			body: { reasoning: { effort } }
 		})),
@@ -12927,7 +14091,10 @@ function toOpencodeModel(model, contextWindow) {
 		cost,
 		status: catalog?.status ?? (model.preview ? "beta" : "active"),
 		enabled: true,
-		limit: {
+		limit: isImage ? {
+			context: 0,
+			output: 0
+		} : {
 			context: Math.min(context, contextWindow),
 			...inputLimit > 0 && { input: Math.min(inputLimit, context, contextWindow) },
 			output: Math.min(context, metadata.maxOutputTokens ?? 32e3)
@@ -12935,7 +14102,7 @@ function toOpencodeModel(model, contextWindow) {
 	};
 }
 async function handleOpencodeModels(c) {
-	const models = await getAgentModels(stripInternalRequestHeaders(c.req.raw.headers));
+	const models = await getAgentModels(stripInternalRequestHeaders(c.req.raw.headers), { includeImageModels: true });
 	const contextWindow = getOpencodeModelContextWindow();
 	c.header("Cache-Control", "private, no-store");
 	c.header("Vary", "User-Agent");
@@ -12997,6 +14164,7 @@ const providerImageRoutes = new Hono();
 async function handleProviderImages(c, operation) {
 	const provider = c.req.param("provider") ?? "";
 	try {
+		if (provider === "github-copilot") return await handleCopilotImages(c, operation);
 		const providerConfig = await resolveProviderConfig(provider);
 		if (!providerConfig) return c.json({ error: {
 			message: `Provider '${provider}' not found or disabled`,
@@ -13007,17 +14175,27 @@ async function handleProviderImages(c, operation) {
 			if (contentTypeError) return contentTypeError;
 			const multipart = await parseMultipartImageEdit(c.req.raw);
 			if (multipart) try {
-				const request = await multipart.createRequest(multipart.model, providerConfig.name);
-				if (providerConfig.name === "codex") return await handleCodexImages(c, operation, providerConfig, request);
+				const model = await resolveImageRequestModel(multipart.model, { provider: providerConfig.name });
+				const request = await multipart.createRequest(model, providerConfig.name);
+				if (providerConfig.name === "codex") return await handleCodexImages(c, operation, providerConfig, request, model);
 				return await forwardProviderImagesWithLogging(providerConfig, request, operation, {
 					logger: logger$6,
-					provider
+					provider,
+					model
 				});
 			} finally {
 				await multipart.cleanup();
 			}
 		}
-		if (providerConfig.name === "codex") return await handleCodexImages(c, operation, providerConfig);
+		if (getDefaultImageModel(providerConfig.name)) {
+			const { request, model } = await prepareProviderJsonImages(c.req.raw, providerConfig.name);
+			if (providerConfig.name === "codex") return await handleCodexImages(c, operation, providerConfig, request, model);
+			return await forwardProviderImagesWithLogging(providerConfig, request, operation, {
+				logger: logger$6,
+				provider,
+				model
+			});
+		}
 		return await forwardProviderImagesWithLogging(providerConfig, c.req.raw, operation, {
 			logger: logger$6,
 			provider
@@ -13032,6 +14210,46 @@ async function handleProviderImages(c, operation) {
 		return await forwardError(c, error);
 	}
 }
+async function handleCopilotImages(c, operation) {
+	if (operation === "edits") {
+		const contentTypeError = imageEditContentTypeErrorResponse(c);
+		if (contentTypeError) return contentTypeError;
+		const multipart = await parseMultipartImageEdit(c.req.raw);
+		if (multipart) try {
+			const model = await resolveImageRequestModel(multipart.model, { provider: GITHUB_COPILOT_PROVIDER });
+			return await forwardCopilotImagesWithLogging(await multipart.createRequest(model, GITHUB_COPILOT_PROVIDER), operation, {
+				logger: logger$6,
+				provider: GITHUB_COPILOT_PROVIDER,
+				model
+			});
+		} finally {
+			await multipart.cleanup();
+		}
+	}
+	const { request, model } = await prepareProviderJsonImages(c.req.raw, GITHUB_COPILOT_PROVIDER);
+	return await forwardCopilotImagesWithLogging(request, operation, {
+		logger: logger$6,
+		provider: GITHUB_COPILOT_PROVIDER,
+		model
+	});
+}
+async function prepareProviderJsonImages(request, provider) {
+	const parsed = await parseJsonImagesRequest(request);
+	if (parsed instanceof Request) return {
+		request: parsed,
+		model: "unknown"
+	};
+	try {
+		const model = await resolveImageRequestModel(parsed.model, { provider });
+		return {
+			model,
+			request: parsed.model === model && parsed.originalRequest ? parsed.originalRequest : await parsed.createRequest(model)
+		};
+	} catch (error) {
+		await parsed.originalRequest?.body?.cancel().catch(() => {});
+		throw error;
+	}
+}
 providerImageRoutes.post("/generations", (c) => handleProviderImages(c, "generations"));
 providerImageRoutes.post("/edits", (c) => handleProviderImages(c, "edits"));
 // src/routes/provider/messages/route.ts
@@ -14862,6 +16080,38 @@ usageRoute.get("/", async (c) => {
 		return c.json({ error: "Failed to fetch Copilot usage" }, 500);
 	}
 });
+// src/lib/token-usage/videos.ts
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** Reads the finite result JSON once for usage accounting and debug output. */
+async function recordVideoResultUsage(response, options) {
+	let body;
+	try {
+		body = await response.clone().text();
+	} catch {
+		return;
+	}
+	options.onBody(body);
+	if (!response.ok) return;
+	let result;
+	try {
+		result = JSON.parse(body);
+	} catch {
+		return;
+	}
+	if (!isRecord(result) || result.status !== "done" || !isRecord(result.usage)) return;
+	const cost = xaiUsdTicksToCost(result.usage.cost_in_usd_ticks);
+	if (cost === void 0) return;
+	recordTokenUsageEvent({
+		source: "provider",
+		providerName: options.providerConfig.name,
+		endpoint: "videos_generations",
+		model: typeof result.model === "string" && result.model.trim() ? result.model : options.defaultModel,
+		cost,
+		upstreamRequestId: options.requestId
+	});
+}
 // src/services/xai/videos.ts
 var XaiVideosRequestError = class extends Error {
 	constructor(message) {
@@ -14894,6 +16144,7 @@ async function forwardXaiVideos(providerConfig, request, videoRequest) {
 const logger$1 = createHandlerLogger("videos-handler");
 const SUPPORTED_VIDEO_MODEL = "grok-imagine-video-1.5";
 const videoRouteDependencies = {
+	debugJson,
 	resolveMappedModel,
 	resolveProviderConfig
 };
@@ -14932,6 +16183,12 @@ async function handleVideos(c, operation) {
 		} }, 404);
 		const upstreamResponse = await forwardXaiVideos(providerConfig, c.req.raw, videoRequest);
 		debugJson(logger$1, `videos.${operation}.response`, { statusCode: upstreamResponse.status });
+		if (videoRequest.operation === "result") await recordVideoResultUsage(upstreamResponse, {
+			providerConfig,
+			requestId: videoRequest.requestId,
+			defaultModel: SUPPORTED_VIDEO_MODEL,
+			onBody: (body) => videoRouteDependencies.debugJson(logger$1, "videos.result.response.body", { body })
+		});
 		return createProviderProxyResponse(upstreamResponse);
 	} catch (error) {
 		if (error instanceof XaiVideosRequestError && !c.req.raw.signal.aborted) return c.json({ error: {
@@ -15013,4 +16270,4 @@ function createServer(options = {}) {
 createServer();
 export { createServer };
 
-//# sourceMappingURL=server-CwSW3Oz8.js.map
+//# sourceMappingURL=server-Cw9qn5Gt.js.map