@jeffreycao/copilot-api 2.8.0 → 2.8.1

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

@@ -6,10 +6,10 @@ import { n as isProviderAgentModelVisible, t as getProviderAgentModels } from ".
 import { i as registerProcessCleanup, n as stopModelsRefreshLoop, r as EventBus, t as setupCopilotRuntime } from "./copilot-runtime-DvmA6ALD.js";
 import consola from "consola";
 import { createHash, randomUUID } from "node:crypto";
-import fs, { readFileSync } from "node:fs";
-import path from "node:path";
-import fs$1 from "node:fs/promises";
-import os from "node:os";
+import fs, { createWriteStream, readFileSync, rmSync } from "node:fs";
+import path, { join } from "node:path";
+import fs$1, { mkdtemp, 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";
 import { z } from "zod";
@@ -18,6 +18,9 @@ import { cors } from "hono/cors";
 import { logger } from "hono/logger";
 import util from "node:util";
 import { streamSSE } from "hono/streaming";
+import { Busboy } from "@fastify/busboy";
+import { Readable, Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
 import { decompress } from "fzstd";
 // src/lib/trace.ts
 const traceIdMiddleware = async (c, next) => {
@@ -2360,7 +2363,7 @@ async function forwardProviderImages(providerConfig, request, operation) {
 	});
 }
 // src/routes/alpha-search/alpha-search-responses.ts
-const logger$19 = createHandlerLogger("alpha-search-responses-handler");
+const logger$20 = createHandlerLogger("alpha-search-responses-handler");
 const SESSION_TTL_MS = 36e5;
 const MAX_SESSIONS = 128;
 const MAX_URL_REFERENCES = 256;
@@ -2718,14 +2721,14 @@ function createRemoteResponsesPayload(request, model, instruction) {
 	};
 }
 async function requestProviderSearch(c, providerConfig, payload, model, sessionId) {
-	debugJson(logger$19, "Alpha search provider Responses request:", {
+	debugJson(logger$20, "Alpha search provider Responses request:", {
 		payload,
 		provider: providerConfig.name
 	});
 	const upstreamResponse = await forwardProviderResponses(providerConfig, payload, c.req.raw.headers, { clientSignal: c.req.raw.signal });
 	if (!upstreamResponse.ok) throw new HTTPError(`Failed to create ${providerConfig.name} responses for alpha search`, upstreamResponse);
 	const result = await upstreamResponse.json();
-	debugJson(logger$19, "Alpha search provider Responses result:", {
+	debugJson(logger$20, "Alpha search provider Responses result:", {
 		provider: providerConfig.name,
 		result
 	});
@@ -2741,7 +2744,7 @@ async function requestProviderSearch(c, providerConfig, payload, model, sessionI
 	return result;
 }
 async function requestCopilotSearch(payload, model, requestId, sessionId, clientSignal) {
-	debugJson(logger$19, "Alpha search Copilot Responses request:", payload);
+	debugJson(logger$20, "Alpha search Copilot Responses request:", payload);
 	const result = await alphaSearchResponsesDependencies.createResponses(payload, {
 		vision: false,
 		initiator: "agent",
@@ -2750,7 +2753,7 @@ async function requestCopilotSearch(payload, model, requestId, sessionId, client
 		sessionId,
 		clientSignal
 	});
-	debugJson(logger$19, "Alpha search Copilot Responses result:", result);
+	debugJson(logger$20, "Alpha search Copilot Responses result:", result);
 	alphaSearchResponsesDependencies.createUsageRecorder(model, sessionId)({
 		...normalizeResponsesUsage(result.usage),
 		total_nano_aiu: normalizeOptionalToken(result.copilot_usage?.total_nano_aiu)
@@ -2863,7 +2866,7 @@ async function forwardCodexAlphaSearch(request) {
 	});
 }
 // src/routes/alpha-search/route.ts
-const logger$18 = createHandlerLogger("alpha-search-handler");
+const logger$19 = createHandlerLogger("alpha-search-handler");
 const alphaSearchRoutes = new Hono();
 const alphaSearchRouteDependencies = {
 	findEndpointModel,
@@ -2883,10 +2886,10 @@ function parseDebugBody(body) {
 	}
 }
 async function forwardCodexAlphaSearchRequest(request, model) {
-	await debugJsonAsync(logger$18, "alpha_search.codex.request", async () => ({ body: parseDebugBody(await request.clone().text()) }));
+	await debugJsonAsync(logger$19, "alpha_search.codex.request", async () => ({ body: parseDebugBody(await request.clone().text()) }));
 	if (model) setPluginRequestActualModel(model);
 	const upstreamResponse = await alphaSearchRouteDependencies.forwardCodexAlphaSearch(request);
-	await debugJsonAsync(logger$18, "alpha_search.codex.response", async () => ({
+	await debugJsonAsync(logger$19, "alpha_search.codex.response", async () => ({
 		body: parseDebugBody(await upstreamResponse.clone().text()),
 		statusCode: upstreamResponse.status
 	}));
@@ -2999,7 +3002,7 @@ alphaSearchRoutes.post("/", async (c) => {
 	try {
 		return await handleAlphaSearchRequest(c);
 	} catch (error) {
-		logger$18.error("alpha_search.error", { error });
+		logger$19.error("alpha_search.error", { error });
 		return await forwardError(c, error);
 	}
 });
@@ -3180,7 +3183,7 @@ const normalizeProviderResponsesReasoningEffort = (payload, providerConfig) => {
 	};
 };
 // src/routes/provider/chat-completions/handler.ts
-const logger$17 = createHandlerLogger("provider-chat-completions-handler");
+const logger$18 = createHandlerLogger("provider-chat-completions-handler");
 async function handleProviderChatCompletionsForProvider(c, options) {
 	const { payload, provider } = options;
 	const configuredProvider = await resolveProviderConfig(provider);
@@ -3195,13 +3198,13 @@ async function handleProviderChatCompletionsForProvider(c, options) {
 	applyProviderStreamOptions(payload);
 	applyDashScopePreserveThinkingDefault(payload, providerConfig);
 	applyProviderContextCache(payload, modelConfig, providerConfig);
-	debugJson(logger$17, "provider.chat_completions.request", {
+	debugJson(logger$18, "provider.chat_completions.request", {
 		payload,
 		provider
 	});
 	const upstreamResponse = await forwardProviderChatCompletions(providerConfig, payload, c.req.raw.headers, { clientSignal: c.req.raw.signal });
 	if (!upstreamResponse.ok) {
-		logger$17.error("Failed to create provider chat completions", {
+		logger$18.error("Failed to create provider chat completions", {
 			provider,
 			statusCode: upstreamResponse.status
 		});
@@ -3215,7 +3218,7 @@ async function handleProviderChatCompletionsForProvider(c, options) {
 	});
 	const responseBody = await upstreamResponse.clone().json();
 	recordUsage(normalizeOpenAIUsage(responseBody.usage));
-	debugJson(logger$17, "provider.chat_completions.response", responseBody);
+	debugJson(logger$18, "provider.chat_completions.response", responseBody);
 	return createProviderProxyResponse(upstreamResponse);
 }
 const applyProviderStreamOptions = (payload) => {
@@ -3237,12 +3240,12 @@ const createProviderChatCompletionsUsageRecorder = (payload, provider, modelConf
 	providerName: provider
 });
 const streamProviderChatCompletions = (c, upstreamResponse, options) => {
-	logger$17.debug("provider.chat_completions.streaming", { provider: options.provider });
+	logger$18.debug("provider.chat_completions.streaming", { provider: options.provider });
 	return streamSSE(c, async (stream) => {
 		let usage = {};
 		try {
 			for await (const chunk of events(upstreamResponse)) {
-				debugJson(logger$17, "provider.chat_completions.stream_chunk", chunk);
+				debugJson(logger$18, "provider.chat_completions.stream_chunk", chunk);
 				if (chunk.data && chunk.data !== "[DONE]") {
 					const parsedChunk = parseChatCompletionChunkData(chunk.data);
 					recordChatCompletionFirstToken(parsedChunk);
@@ -3301,7 +3304,7 @@ const createChatCompletions = async (payload, options) => {
 	return await response.json();
 };
 // src/routes/chat-completions/handler.ts
-const logger$16 = createHandlerLogger("chat-completions-handler");
+const logger$17 = createHandlerLogger("chat-completions-handler");
 async function handleCompletion$1(c) {
 	let payload = await c.req.json();
 	setPluginRequestModel(payload.model);
@@ -3316,7 +3319,7 @@ async function handleCompletion$1(c) {
 			provider: providerModelAlias.provider
 		});
 	}
-	debugJson(logger$16, "Request payload:", payload);
+	debugJson(logger$17, "Request payload:", payload);
 	const selectedModel = findEndpointModel(payload.model);
 	payload.model = selectedModel?.id ?? payload.model;
 	if (isNullish(payload.max_tokens) && isNullish(payload.max_completion_tokens)) {
@@ -3324,16 +3327,16 @@ async function handleCompletion$1(c) {
 			...payload,
 			max_tokens: selectedModel?.capabilities.limits.max_output_tokens
 		};
-		debugJson(logger$16, "Set max_tokens to:", payload.max_tokens);
+		debugJson(logger$17, "Set max_tokens to:", payload.max_tokens);
 	}
 	if (payload.model.includes("gpt")) {
 		if (isNullish(payload.max_completion_tokens)) payload.max_completion_tokens = payload.max_tokens;
 		delete payload.max_tokens;
 	}
 	const requestId = generateRequestIdFromPayload(payload);
-	logger$16.debug("Generated request ID:", requestId);
+	logger$17.debug("Generated request ID:", requestId);
 	const sessionId = getUUID(requestId);
-	logger$16.debug("Extracted session ID:", sessionId);
+	logger$17.debug("Extracted session ID:", sessionId);
 	const recordUsage = createCopilotTokenUsageRecorder({
 		endpoint: "chat_completions",
 		fallbackSessionId: sessionId,
@@ -3345,18 +3348,18 @@ async function handleCompletion$1(c) {
 		sessionId
 	});
 	if (isNonStreaming$1(response)) {
-		debugJson(logger$16, "Non-streaming response:", response);
+		debugJson(logger$17, "Non-streaming response:", response);
 		recordUsage({
 			...normalizeOpenAIUsage(response.usage),
 			total_nano_aiu: normalizeOptionalToken(response.copilot_usage?.total_nano_aiu)
 		});
 		return c.json(response);
 	}
-	logger$16.debug("Streaming response");
+	logger$17.debug("Streaming response");
 	return streamSSE(c, async (stream) => {
 		let usage = {};
 		for await (const chunk of response) {
-			debugJson(logger$16, "Streaming chunk:", chunk);
+			debugJson(logger$17, "Streaming chunk:", chunk);
 			const parsedChunk = parseChatCompletionChunk(chunk);
 			recordChatCompletionFirstToken(parsedChunk);
 			if (parsedChunk?.usage || parsedChunk?.copilot_usage) usage = {
@@ -3497,209 +3500,246 @@ embeddingRoutes.post("/", async (c) => {
 		return await forwardError(c, error);
 	}
 });
-// src/lib/xai-image-model.ts
+// src/routes/images/temp-form-data.ts
+const logger$16 = createHandlerLogger("images-temp-form-data");
+const multipartStagingDependencies = { createWriteStream };
 /**
-* Resolves one image-route model setting. Empty values keep the OpenAI
-* protocol. Only an xai/model alias selects the xAI Imagine API.
+* Matches the images forwarding timeouts: an upstream upload may take that
+* long, so staged files must survive at least the whole forwarding window.
 */
-function resolveConfiguredXaiImageModel(configured, settingName) {
-	if (configured === void 0 || configured === null) return { status: "disabled" };
-	if (typeof configured !== "string") return {
-		message: `${settingName} must be an xai/model alias`,
-		status: "invalid"
-	};
-	const trimmed = configured.trim();
-	if (!trimmed) return { status: "disabled" };
-	const alias = parseProviderModelAlias(trimmed);
-	if (alias?.provider.toLowerCase() !== "xai") return {
-		message: `${settingName} only supports an xai/model alias, received '${trimmed}'`,
-		status: "invalid"
-	};
-	return {
-		model: alias.model,
-		status: "xai"
-	};
+const STAGED_FILES_TTL_MS = 9e5;
+const DEFAULT_MULTIPART_STAGING_LIMITS = {
+	maxBodySizeBytes: 134217728,
+	maxFieldSizeBytes: 10485760,
+	maxFields: 64,
+	maxFileSizeBytes: 67108864,
+	maxFiles: 16,
+	maxParts: 80
+};
+var InvalidMultipartBodyError = class extends Error {
+	constructor(options) {
+		super("Invalid multipart form data body", options);
+		this.name = "InvalidMultipartBodyError";
+	}
+};
+var MultipartBodyTooLargeError = class extends Error {
+	constructor() {
+		super("Multipart form data body exceeds the configured upload limits");
+		this.name = "MultipartBodyTooLargeError";
+	}
+};
+function sanitizeFileName(name) {
+	return name.split(/[\\/]/).pop()?.replaceAll("\0", "") || "file";
 }
-function getImageGenerationModel() {
-	return resolveConfiguredXaiImageModel(getConfig().imageGenerationModel, "imageGenerationModel");
+async function createDiskBackedBlob(filePath, type) {
+	if (typeof Bun !== "undefined") return Bun.file(filePath, { type });
+	const { openAsBlob } = await import("node:fs");
+	return await openAsBlob(filePath, { type });
 }
-function getImageEditModel() {
-	return resolveConfiguredXaiImageModel(getConfig().imageEditModel, "imageEditModel");
+function toError(error) {
+	return error instanceof Error ? error : new Error(String(error));
 }
-// 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);
-	debugJson(logger, `provider.images.${operation}.response`, {
-		contentType: upstreamResponse.headers.get("content-type"),
-		contentLength: upstreamResponse.headers.get("content-length"),
-		provider,
-		statusCode: upstreamResponse.status
+function parseMultipartBody(body, contentType, directory, entries, limits, signal) {
+	return new Promise((resolve, reject) => {
+		let busboy;
+		try {
+			busboy = new Busboy({
+				headers: { "content-type": contentType },
+				limits: {
+					fieldSize: limits.maxFieldSizeBytes,
+					fields: limits.maxFields,
+					fileSize: limits.maxFileSizeBytes,
+					files: limits.maxFiles,
+					parts: limits.maxParts
+				}
+			});
+		} catch (error) {
+			reject(new InvalidMultipartBodyError({ cause: toError(error) }));
+			return;
+		}
+		const pendingWrites = [];
+		const activeFileStreams = /* @__PURE__ */ new Set();
+		const source = body === null ? Readable.from([]) : Readable.fromWeb(body);
+		let bodySizeBytes = 0;
+		const bodyLimiter = new Transform({ transform(chunk, _encoding, callback) {
+			bodySizeBytes += chunk.byteLength;
+			if (bodySizeBytes > limits.maxBodySizeBytes) {
+				callback(new MultipartBodyTooLargeError());
+				return;
+			}
+			callback(null, chunk);
+		} });
+		let fileIndex = 0;
+		let failure = null;
+		let inputPipeline = null;
+		let settled = false;
+		const settleStreams = () => Promise.allSettled([...inputPipeline ? [inputPipeline] : [], ...pendingWrites]);
+		const fail = (error) => {
+			if (failure || settled) return;
+			const failureError = toError(error);
+			failure = failureError;
+			source.destroy(failureError);
+			bodyLimiter.destroy(failureError);
+			busboy.destroy(failureError);
+			for (const stream of activeFileStreams) stream.destroy(failureError);
+			settleStreams().then(() => {
+				if (settled) return;
+				settled = true;
+				reject(failureError);
+			});
+		};
+		const failLimit = () => fail(new MultipartBodyTooLargeError());
+		busboy.on("field", (name, value, nameTruncated, valueTruncated) => {
+			if (nameTruncated || valueTruncated) {
+				failLimit();
+				return;
+			}
+			entries.push({
+				kind: "field",
+				name,
+				value
+			});
+		});
+		busboy.on("file", (name, stream, fileName, _transferEncoding, mimeType) => {
+			if (failure) {
+				stream.resume();
+				return;
+			}
+			const filePath = join(directory, `${fileIndex}.upload`);
+			fileIndex += 1;
+			entries.push({
+				fileName: sanitizeFileName(fileName),
+				filePath,
+				kind: "file",
+				mimeType,
+				name
+			});
+			activeFileStreams.add(stream);
+			stream.once("error", fail);
+			stream.once("close", () => activeFileStreams.delete(stream));
+			stream.once("limit", failLimit);
+			try {
+				const write = pipeline(stream, multipartStagingDependencies.createWriteStream(filePath));
+				pendingWrites.push(write);
+				write.catch(fail);
+			} catch (error) {
+				fail(error);
+			}
+		});
+		busboy.on("fieldsLimit", failLimit);
+		busboy.on("filesLimit", failLimit);
+		busboy.on("partsLimit", failLimit);
+		inputPipeline = pipeline(source, bodyLimiter, busboy, { signal });
+		inputPipeline.then(() => {
+			Promise.allSettled(pendingWrites).then((results) => {
+				if (failure || settled) return;
+				const failed = results.find((result) => result.status === "rejected");
+				if (failed) fail(failed.reason);
+				else {
+					settled = true;
+					resolve();
+				}
+			});
+		}, (error) => {
+			fail(error instanceof MultipartBodyTooLargeError || signal?.aborted ? error : new InvalidMultipartBodyError({ cause: toError(error) }));
+		});
 	});
-	return createProviderProxyResponse(upstreamResponse);
-}
-// src/services/codex/images.ts
-const CODEX_IMAGES_TIMEOUT_MS = 9e5;
-const codexImagesDispatcher = createTimeoutDispatcher(CODEX_IMAGES_TIMEOUT_MS);
-function resolveCodexImagesUrl(requestUrl, operation) {
-	const upstreamUrl = new URL(`${CODEX_API_BASE_URL}/codex/images/${operation}`);
-	upstreamUrl.search = new URL(requestUrl, "http://localhost").search;
-	return upstreamUrl.toString();
 }
-async function forwardCodexImages(request, operation) {
-	const headers = buildCodexRequestHeaders(request.headers);
-	if (!headers.has("accept")) headers.set("accept", "application/json");
-	if (operation === "generations" && !headers.has("content-type")) headers.set("content-type", "application/json");
-	const init = {
-		method: "POST",
-		headers,
-		body: request.body,
-		duplex: "half",
-		signal: AbortSignal.timeout(CODEX_IMAGES_TIMEOUT_MS)
-	};
-	const upstreamUrl = resolveCodexImagesUrl(request.url, operation);
-	if (typeof Bun !== "undefined") return await fetch(upstreamUrl, init);
-	return await fetch$1(upstreamUrl, {
-		...init,
-		dispatcher: codexImagesDispatcher
-	});
-}
-// src/routes/images/shared.ts
-const logger$15 = createHandlerLogger("images-handler");
-const imageRouteDependencies = {
-	debugJsonAsync,
-	getImageEditModel,
-	getImageGenerationModel,
-	resolveMappedModel,
-	resolveProviderConfig
-};
-function imageEditContentTypeErrorResponse(c) {
-	if (c.req.header("content-type")?.split(";", 1)[0]?.trim().toLowerCase() === "application/json") return null;
-	return c.json({ error: {
-		message: "Image edits require application/json with images: [{ image_url }] or [{ file_id }]; multipart uploads are not supported",
-		type: "invalid_request_error"
-	} }, 415);
-}
-function getContentMetadata(headers) {
-	return {
-		contentType: headers.get("content-type"),
-		contentLength: headers.get("content-length")
+function resolveStagingLimits(overrides) {
+	const limits = {
+		...DEFAULT_MULTIPART_STAGING_LIMITS,
+		...overrides
 	};
+	for (const [name, value] of Object.entries(limits)) if (!Number.isSafeInteger(value) || value <= 0) throw new RangeError(`${name} must be a positive safe integer`);
+	return limits;
 }
 /**
-* Snapshots generated request headers before consuming the body.
+* Streams a multipart request body through the parser, writing every file
+* part to a temporary directory as it arrives and rebuilding the form data
+* with disk-backed blobs, so forwarding streams payloads from disk instead
+* of pinning the whole upload in memory.
 */
-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;
+async function stageMultipartBodyToDisk(body, contentType, limitOverrides = {}, signal) {
+	signal?.throwIfAborted();
+	const limits = resolveStagingLimits(limitOverrides);
+	const directory = await mkdtemp(join(tmpdir(), "copilot-api-images-"));
+	const entries = [];
 	try {
-		const bodyText = new TextDecoder("utf-8", { fatal: true }).decode(body);
-		payload = JSON.parse(bodyText);
-	} catch {
-		return originalRequest;
+		await parseMultipartBody(body, contentType, directory, entries, limits, signal);
+	} catch (error) {
+		await rm(directory, {
+			force: true,
+			recursive: true
+		});
+		throw error;
 	}
-	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
-	};
-}
-/**
-* 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) {
+	const stagedFormData = new FormData();
 	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 upstreamResponse = await forwardCodexImages(request, operation);
-		debugJson(logger$15, `images.${operation}.codex.response`, {
-			...getContentMetadata(upstreamResponse.headers),
-			statusCode: upstreamResponse.status
-		});
-		return createProviderProxyResponse(upstreamResponse);
+		for (const entry of entries) if (entry.kind === "field") stagedFormData.append(entry.name, entry.value);
+		else stagedFormData.append(entry.name, await createDiskBackedBlob(entry.filePath, entry.mimeType), entry.fileName);
 	} catch (error) {
-		logger$15.error(`images.${operation}.codex.error`, { error });
-		return await forwardError(c, error);
+		await rm(directory, {
+			force: true,
+			recursive: true
+		});
+		throw error;
 	}
-}
-/**
-* Routes a parsed images request: applies the model mapping, forwards to a
-* mapped provider when configured, and otherwise falls back to Codex.
-*/
-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 = parsed.createRequest(providerModelAlias.model);
-			if (providerConfig.name === "codex") return await handleCodexImages(c, operation, providerConfig, request);
-			return await forwardProviderImagesWithLogging(providerConfig, request, operation, {
-				logger: logger$15,
-				provider: providerModelAlias.provider
+	let cleanupPromise = null;
+	let cleanupTimer = null;
+	let unregisterProcessCleanup = null;
+	const cleanup = () => {
+		cleanupPromise ??= (async () => {
+			if (cleanupTimer) {
+				clearTimeout(cleanupTimer);
+				cleanupTimer = null;
+			}
+			try {
+				await rm(directory, {
+					force: true,
+					recursive: true
+				});
+			} catch (error) {
+				logger$16.warn("Failed to remove staged images temp directory", {
+					directory,
+					error
+				});
+			} finally {
+				unregisterProcessCleanup?.();
+				unregisterProcessCleanup = null;
+			}
+		})();
+		return cleanupPromise;
+	};
+	unregisterProcessCleanup = registerProcessCleanup(() => {
+		if (cleanupTimer) {
+			clearTimeout(cleanupTimer);
+			cleanupTimer = null;
+		}
+		try {
+			rmSync(directory, {
+				force: true,
+				recursive: true
 			});
+		} catch (error) {
+			logger$16.warn("Failed to remove staged images temp directory on exit", {
+				directory,
+				error
+			});
+		} finally {
+			unregisterProcessCleanup?.();
+			unregisterProcessCleanup = null;
 		}
-		consola.debug(`Provider '${providerModelAlias.provider}' not found or disabled; forwarding the original model to Codex`);
-		return await handleCodexImages(c, operation, void 0, parsed.originalRequest ?? parsed.createRequest(requestedModel));
-	}
-	if (parsed.originalRequest && mappedModel === requestedModel) return await handleCodexImages(c, operation, void 0, parsed.originalRequest);
-	return await handleCodexImages(c, operation, void 0, parsed.createRequest(mappedModel));
+	});
+	return {
+		directory,
+		formData: stagedFormData,
+		cleanup,
+		scheduleCleanup: () => {
+			if (cleanupPromise || cleanupTimer) return;
+			cleanupTimer = setTimeout(() => void cleanup(), STAGED_FILES_TTL_MS);
+			cleanupTimer.unref();
+		}
+	};
 }
 // src/services/xai/images.ts
 const XAI_ASPECT_RATIOS = [
@@ -4086,6 +4126,331 @@ async function ensureImageResponseB64Json(response, fetchImage = globalThis.fetc
 		data
 	}));
 }
+// src/routes/images/multipart-edits.ts
+const multipartEditDependencies = { stageMultipartBodyToDisk };
+var ImageEditRequestError = class extends Error {};
+function imageEditRequestErrorResponse(c, error) {
+	if (c.req.raw.signal.aborted) return null;
+	if (!(error instanceof ImageEditRequestError) && !(error instanceof InvalidMultipartBodyError) && !(error instanceof MultipartBodyTooLargeError) && !(error instanceof XaiImagesRequestError)) return null;
+	return c.json({ error: {
+		message: error.message,
+		type: "invalid_request_error"
+	} }, error instanceof MultipartBodyTooLargeError ? 413 : 400);
+}
+function imageMimeType(bytes, declared) {
+	if (declared.startsWith("image/")) return declared;
+	if (bytes.subarray(0, 8).equals(Buffer.from([
+		137,
+		80,
+		78,
+		71,
+		13,
+		10,
+		26,
+		10
+	]))) return "image/png";
+	if (bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) return "image/jpeg";
+	if (bytes.toString("ascii", 0, 4) === "RIFF" && bytes.toString("ascii", 8, 12) === "WEBP") return "image/webp";
+	if (/^GIF8[79]a/u.test(bytes.toString("ascii", 0, 6))) return "image/gif";
+	throw new ImageEditRequestError("Uploaded image must have an image MIME type");
+}
+async function imageReference(value, signal) {
+	signal.throwIfAborted();
+	if (typeof value === "string") {
+		const url = value.trim();
+		if (!/^(?:https?:\/\/|data:image\/[a-z0-9.+-]+;base64,)/iu.test(url)) throw new ImageEditRequestError("image must be a file, HTTP URL or base64 data URL");
+		return { image_url: url };
+	}
+	const bytes = Buffer.from(await value.arrayBuffer());
+	signal.throwIfAborted();
+	if (bytes.length === 0) throw new ImageEditRequestError("image is empty");
+	return { image_url: `data:${imageMimeType(bytes, value.type.trim().toLowerCase())};base64,${bytes.toString("base64")}` };
+}
+function fieldValue(name, value) {
+	if ([
+		"n",
+		"partial_images",
+		"output_compression"
+	].includes(name)) {
+		const trimmed = value.trim();
+		const number = Number(trimmed);
+		if (!/^-?\d+$/u.test(trimmed) || !Number.isSafeInteger(number)) throw new ImageEditRequestError(`${name} must be an integer`);
+		return number;
+	}
+	if (name === "stream") {
+		if (value.trim() === "true") return true;
+		if (value.trim() === "false") return false;
+		throw new ImageEditRequestError("stream must be true or false");
+	}
+	return value;
+}
+async function formPayload(form, signal) {
+	const fields = /* @__PURE__ */ new Map();
+	const images = [];
+	for (const [name, value] of form.entries()) {
+		if (name === "image" || name === "image[]") {
+			images.push(await imageReference(value, signal));
+			continue;
+		}
+		const key = name === "mask[]" ? "mask" : name;
+		if (fields.has(key)) throw new ImageEditRequestError(`Duplicate image edit field: ${key}`);
+		if (key === "mask") fields.set(key, await imageReference(value, signal));
+		else if (typeof value === "string") fields.set(key, fieldValue(key, value));
+		else throw new ImageEditRequestError(`Unexpected image edit file field: ${key}`);
+	}
+	if (images.length === 0) throw new ImageEditRequestError("image is required");
+	fields.set("images", images);
+	return Object.fromEntries(fields);
+}
+/** Parse multipart once, keeping uploads on disk until the target is known. */
+async function parseMultipartImageEdit(request) {
+	const requestHeaders = new Headers(request.headers);
+	const contentType = requestHeaders.get("content-type");
+	if (contentType?.split(";", 1)[0]?.trim().toLowerCase() !== "multipart/form-data") return null;
+	const staged = await multipartEditDependencies.stageMultipartBodyToDisk(request.body, contentType, {}, request.signal);
+	const form = staged.formData;
+	const model = form.get("model");
+	let payloadPromise;
+	const readPayload = () => {
+		payloadPromise ??= formPayload(form, request.signal).finally(staged.cleanup);
+		return payloadPromise;
+	};
+	return {
+		...staged,
+		model: typeof model === "string" ? model : void 0,
+		readPayload,
+		createRequest: async (model, provider = "codex") => {
+			const headers = new Headers(requestHeaders);
+			headers.delete("content-length");
+			let body;
+			if (provider === "codex" || provider === "xai") {
+				const payload = {
+					...await readPayload(),
+					...model === void 0 ? {} : { model }
+				};
+				if (provider === "xai" && !model) throw new ImageEditRequestError("model is required for xAI multipart edits");
+				headers.set("content-type", "application/json");
+				body = new TextEncoder().encode(JSON.stringify(provider === "xai" ? translateXaiImageEditJson(payload, model) : payload));
+			} else {
+				if (model !== void 0) form.set("model", model);
+				headers.delete("content-type");
+				body = form;
+			}
+			request.signal.throwIfAborted();
+			return new Request(request.url, {
+				method: request.method,
+				headers,
+				body,
+				signal: request.signal
+			});
+		}
+	};
+}
+// src/lib/xai-image-model.ts
+/**
+* Resolves one image-route model setting. Empty values keep the OpenAI
+* protocol. Only an xai/model alias selects the xAI Imagine API.
+*/
+function resolveConfiguredXaiImageModel(configured, settingName) {
+	if (configured === void 0 || configured === null) return { status: "disabled" };
+	if (typeof configured !== "string") return {
+		message: `${settingName} must be an xai/model alias`,
+		status: "invalid"
+	};
+	const trimmed = configured.trim();
+	if (!trimmed) return { status: "disabled" };
+	const alias = parseProviderModelAlias(trimmed);
+	if (alias?.provider.toLowerCase() !== "xai") return {
+		message: `${settingName} only supports an xai/model alias, received '${trimmed}'`,
+		status: "invalid"
+	};
+	return {
+		model: alias.model,
+		status: "xai"
+	};
+}
+function getImageGenerationModel() {
+	return resolveConfiguredXaiImageModel(getConfig().imageGenerationModel, "imageGenerationModel");
+}
+function getImageEditModel() {
+	return resolveConfiguredXaiImageModel(getConfig().imageEditModel, "imageEditModel");
+}
+// 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);
+	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);
+}
+// src/services/codex/images.ts
+const CODEX_IMAGES_TIMEOUT_MS = 9e5;
+const codexImagesDispatcher = createTimeoutDispatcher(CODEX_IMAGES_TIMEOUT_MS);
+function resolveCodexImagesUrl(requestUrl, operation) {
+	const upstreamUrl = new URL(`${CODEX_API_BASE_URL}/codex/images/${operation}`);
+	upstreamUrl.search = new URL(requestUrl, "http://localhost").search;
+	return upstreamUrl.toString();
+}
+async function forwardCodexImages(request, operation) {
+	const headers = buildCodexRequestHeaders(request.headers);
+	if (!headers.has("accept")) headers.set("accept", "application/json");
+	if (operation === "generations" && !headers.has("content-type")) headers.set("content-type", "application/json");
+	const init = {
+		method: "POST",
+		headers,
+		body: request.body,
+		duplex: "half",
+		signal: AbortSignal.any([request.signal, AbortSignal.timeout(CODEX_IMAGES_TIMEOUT_MS)])
+	};
+	const upstreamUrl = resolveCodexImagesUrl(request.url, operation);
+	if (typeof Bun !== "undefined") return await fetch(upstreamUrl, init);
+	return await fetch$1(upstreamUrl, {
+		...init,
+		dispatcher: codexImagesDispatcher
+	});
+}
+// src/routes/images/shared.ts
+const logger$15 = createHandlerLogger("images-handler");
+const imageRouteDependencies = {
+	debugJsonAsync,
+	getImageEditModel,
+	getImageGenerationModel,
+	resolveMappedModel,
+	resolveProviderConfig
+};
+function imageEditContentTypeErrorResponse(c) {
+	const mediaType = c.req.header("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
+	if (mediaType === "application/json" || mediaType === "multipart/form-data") return null;
+	return c.json({ error: {
+		message: "Image edits require application/json or multipart/form-data",
+		type: "invalid_request_error"
+	} }, 415);
+}
+function getContentMetadata(headers) {
+	return {
+		contentType: headers.get("content-type"),
+		contentLength: headers.get("content-length")
+	};
+}
+/**
+* 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
+	};
+}
+/**
+* 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) {
+	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 upstreamResponse = await forwardCodexImages(request, operation);
+		debugJson(logger$15, `images.${operation}.codex.response`, {
+			...getContentMetadata(upstreamResponse.headers),
+			statusCode: upstreamResponse.status
+		});
+		return createProviderProxyResponse(upstreamResponse);
+	} catch (error) {
+		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.
+*/
+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));
+	}
+	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));
+}
 // src/routes/images/xai-handler.ts
 function xaiImagesRequestErrorResponse(c, error) {
 	if (!(error instanceof XaiImagesRequestError)) return null;
@@ -4136,8 +4501,8 @@ async function forwardXaiImages(providerConfig, request, operation, payload) {
 async function handleXaiImageGeneration(c, model) {
 	return await forwardTranslatedXaiImages(c, "generations", translateXaiImageGeneration(await readJsonBody(c.req.raw, "Image generation body must be JSON"), model));
 }
-async function handleXaiImageEdit(c, model) {
-	return await forwardTranslatedXaiImages(c, "edits", translateXaiImageEditJson(await readJsonBody(c.req.raw, "Image edit body must be JSON"), model));
+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));
 }
 // src/routes/images/edits-handler.ts
 async function handleImagesEdits(c) {
@@ -4149,12 +4514,26 @@ async function handleImagesEdits(c) {
 		} }, 400);
 		const contentTypeError = imageEditContentTypeErrorResponse(c);
 		if (contentTypeError) return contentTypeError;
+		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)
+			});
+		} catch (error) {
+			await multipart.cleanup();
+			throw error;
+		} finally {
+			multipart.scheduleCleanup();
+		}
 		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);
 		return await routeImagesRequest(c, "edits", parsed);
 	} catch (error) {
-		const invalidRequest = xaiImagesRequestErrorResponse(c, error);
+		const invalidRequest = imageEditRequestErrorResponse(c, error);
 		if (invalidRequest) return invalidRequest;
 		logger$15.error("images.edits.error", { error });
 		return await forwardError(c, error);
@@ -12623,18 +13002,29 @@ async function handleProviderImages(c, operation) {
 			message: `Provider '${provider}' not found or disabled`,
 			type: "invalid_request_error"
 		} }, 404);
-		if (providerConfig.name === "codex") {
-			if (operation === "edits") {
-				const contentTypeError = imageEditContentTypeErrorResponse(c);
-				if (contentTypeError) return contentTypeError;
+		if (operation === "edits" && (providerConfig.name === "codex" || providerConfig.name === "xai")) {
+			const contentTypeError = imageEditContentTypeErrorResponse(c);
+			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);
+				return await forwardProviderImagesWithLogging(providerConfig, request, operation, {
+					logger: logger$6,
+					provider
+				});
+			} finally {
+				await multipart.cleanup();
 			}
-			return await handleCodexImages(c, operation, providerConfig);
 		}
+		if (providerConfig.name === "codex") return await handleCodexImages(c, operation, providerConfig);
 		return await forwardProviderImagesWithLogging(providerConfig, c.req.raw, operation, {
 			logger: logger$6,
 			provider
 		});
 	} catch (error) {
+		const invalidRequest = imageEditRequestErrorResponse(c, error);
+		if (invalidRequest) return invalidRequest;
 		logger$6.error(`provider.images.${operation}.error`, {
 			provider,
 			error
@@ -14623,4 +15013,4 @@ function createServer(options = {}) {
 createServer();
 export { createServer };
 
-//# sourceMappingURL=server-Bz8hGP4q.js.map
+//# sourceMappingURL=server-CwSW3Oz8.js.map