xiaodcs-copilot-api 2.4.1-public.1 → 2.5.1-public.2

package/dist/{server-wD8xXlqc.js → server-DmKNMBLd.js}

@@ -1,22 +1,26 @@
-import { A as isResponsesApiCompactionRecoveryEnabled, C as getClaudeTokenMultiplier, D as isAlphaSearchCodexPriorityEnabled, E as getResponsesTransportConfig, F as PATHS, M as isResponsesApiWebSocketEnabled, O as isCopilotFastTierEnabled, S as getClaudeAutoModel, T as getMessageApiWebSearchModel, _ as resolveMappedModel, b as getAlphaSearchModel, d as getModelResponsesApiCompactThreshold$1, f as getReasoningEffortForModel, g as isGpt56OrAbove, h as isContextManagementEnabledForResponses, i as listEnabledProviders, j as isResponsesApiWebSearchEnabled, k as isMessagesApiEnabled, l as getExtraPromptForModel, m as isContextManagementEnabledForMessages, n as getRawProviderConfig, o as resolveEffectiveProviderType, p as getSmallModel, s as resolveProviderAuthType, t as getProviderConfig, u as getModelMappings, v as setModelMappings, x as getAnthropicApiKey } from "./config-A1SyzmBJ.js";
-import { B as fetchResponsesWithLifecycle, C as compactAutoContinuePromptStarts, D as compactTextOnlyGuard, E as compactSystemPromptStarts, F as forwardCodexResponses, G as createWebSocketUrl, H as encodePoolKeyPart, I as generateTraceId, J as forwardError, K as state, L as requestContext, N as CODEX_API_BASE_URL, O as createAuthMiddleware, P as buildCodexRequestHeaders, R as resolveTraceId$1, U as isTerminalResponsesStreamChunk, V as createResponsesSafeStream, W as createPooledWebSocketStream, b as prepareInteractionHeaders, c as getUUID, d as isResponsesStream$1, f as parseUserIdMetadata, g as copilotHeaders, h as copilotBaseUrl, k as getConfiguredAdminApiKeys, l as isAsyncIterable, o as generateRequestIdFromPayload, p as getCopilotUsage, q as HTTPError, r as setupCodexToken, s as getRootSessionId, u as isNullish, v as copilotWebSocketHeaders, w as compactMessageSections, x as prepareMessageProxyHeaders, y as prepareForCompact, z as createResponsesHttpEventStream } from "./token-CQyKjtuM.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-Ds1vbmGG.js";
-import { i as toClientModelId, r as normalizeSdkModelId, t as findEndpointModel } from "./models-CmzVpYlg.js";
-import consola from "consola";
+import { C as getAnthropicApiKey, D as getMessageApiWebSearchModel, F as isResponsesApiWebSocketEnabled, M as isMessagesApiEnabled, N as isResponsesApiCompactionRecoveryEnabled, O as getResponsesTransportConfig, P as isResponsesApiWebSearchEnabled, R as PATHS, S as getAlphaSearchModel, T as getClaudeTokenMultiplier, _ as isContextManagementEnabledForResponses, b as setModelMappings, d as getExtraPromptForModel, f as getModelMappings, g as isContextManagementEnabledForMessages, h as getSmallModel, i as listEnabledProviders, j as isCopilotFastTierEnabled, k as isAlphaSearchCodexPriorityEnabled, m as getReasoningEffortForModel, n as getRawProviderConfig, o as resolveEffectiveProviderType, p as getModelResponsesApiCompactThreshold$1, s as resolveProviderAuthType, t as getProviderConfig, u as isQoderSdkProvider, v as isGpt56OrAbove, w as getClaudeAutoModel, y as resolveMappedModel } from "./config-DnMKoKrg.js";
+import { B as fetchResponsesWithLifecycle, C as compactAutoContinuePromptStarts, D as compactTextOnlyGuard, E as compactSystemPromptStarts, F as forwardCodexResponses, G as createWebSocketUrl, H as encodePoolKeyPart, I as generateTraceId, J as forwardError, K as state, L as requestContext, N as CODEX_API_BASE_URL, O as createAuthMiddleware, P as buildCodexRequestHeaders, R as resolveTraceId$1, U as isTerminalResponsesStreamChunk, V as createResponsesSafeStream, W as createPooledWebSocketStream, b as prepareInteractionHeaders, c as getUUID, d as isResponsesStream$1, f as parseUserIdMetadata, g as copilotHeaders, h as copilotBaseUrl, k as getConfiguredAdminApiKeys, l as isAsyncIterable, o as generateRequestIdFromPayload, p as getCopilotUsage, q as HTTPError, r as setupCodexToken, s as getRootSessionId, u as isNullish, v as copilotWebSocketHeaders, w as compactMessageSections, x as prepareMessageProxyHeaders, y as prepareForCompact, z as createResponsesHttpEventStream } from "./token-CQftvMU4.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-DCb3HbWj.js";
+import { a as forwardProviderMessages, c as createTimeoutDispatcher, d as normalizeSdkModelId, f as toClientModelId, i as forwardProviderImages, l as findEndpointModel, n as forwardProviderAlphaSearch, o as forwardProviderModels, r as forwardProviderChatCompletions, s as forwardProviderResponses, t as createProviderProxyResponse } from "./provider-proxy-BbLwvtD_.js";
+import { n as forwardQoder } from "./transport-DE8Q0wU-.js";
+import fs, { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path, { join } from "node:path";
 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 { fetch as fetch$1, getGlobalDispatcher } from "undici";
+import { Readable, Transform } from "node:stream";
+import consola from "consola";
+import fs$1, { createWriteStream, readFileSync, rmSync } from "node:fs";
+import { fetch as fetch$1 } from "undici";
 import { events } from "fetch-event-stream";
 import { z } from "zod";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
-import { decompress } from "fzstd";
 import util from "node:util";
 import { streamSSE } from "hono/streaming";
-import { bufferToFormData } from "hono/utils/buffer";
+import { Busboy } from "@fastify/busboy";
+import { pipeline } from "node:stream/promises";
+import { decompress } from "fzstd";
 //#region src/lib/trace.ts
 const traceIdMiddleware = async (c, next) => {
 	const traceId = resolveTraceId$1(c.req.header("x-trace-id"));
@@ -33,58 +37,6 @@ const traceIdMiddleware = async (c, next) => {
 	});
 };
 //#endregion
-//#region src/lib/zstd-request.ts
-const ZSTD_CONTENT_ENCODING = "zstd";
-const INVALID_BODY_STATUS = 400;
-let nodeZlibPromise = null;
-const zstdDecompressionMiddleware = async (c, next) => {
-	if (c.req.header("content-encoding")?.trim().toLowerCase() !== ZSTD_CONTENT_ENCODING) return next();
-	try {
-		const decompressedBody = await decompressZstd(new Uint8Array(await c.req.raw.arrayBuffer()));
-		const headers = new Headers(c.req.raw.headers);
-		headers.delete("content-encoding");
-		headers.delete("content-length");
-		c.req.raw = new Request(c.req.raw.url, {
-			body: decompressedBody,
-			headers,
-			method: c.req.raw.method,
-			signal: c.req.raw.signal
-		});
-		c.req.bodyCache = {};
-	} catch {
-		return c.json({ error: {
-			message: "Failed to decompress zstd request body.",
-			type: "invalid_request_error"
-		} }, INVALID_BODY_STATUS);
-	}
-	return next();
-};
-const decompressZstd = async (input) => {
-	const bun = getBunRuntime();
-	if (bun?.zstdDecompress) return toUint8Array(await bun.zstdDecompress(input));
-	const nodeZlib = await getNodeZlib();
-	if (nodeZlib?.zstdDecompress) return new Promise((resolve, reject) => {
-		nodeZlib.zstdDecompress?.(input, (error, result) => {
-			if (error) {
-				reject(error);
-				return;
-			}
-			resolve(toUint8Array(result));
-		});
-	});
-	return decompress(input);
-};
-const getBunRuntime = () => globalThis.Bun;
-const getNodeZlib = async () => {
-	nodeZlibPromise ??= import("node:zlib").then((module) => module).catch(() => null);
-	return nodeZlibPromise;
-};
-const toUint8Array = (data) => {
-	if (data instanceof Uint8Array) return data;
-	if (data instanceof ArrayBuffer) return new Uint8Array(data);
-	return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-};
-//#endregion
 //#region src/lib/process-cleanup.ts
 const cleanupHandlers = /* @__PURE__ */ new Set();
 let cleanupPromise = null;
@@ -152,7 +104,7 @@ let cleanupInterval;
 let currentLogDateKey;
 const ensureLogDirectory = () => {
 	const logDir = getLogDir();
-	if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+	if (!fs$1.existsSync(logDir)) fs$1.mkdirSync(logDir, { recursive: true });
 };
 const formatArgs = (args) => args.map((arg) => typeof arg === "string" ? arg : util.inspect(arg, {
 	depth: null,
@@ -204,13 +156,13 @@ const closePreviousDateLogFiles = (dateKey) => {
 };
 const cleanupOldLogs = async () => {
 	const logDir = getLogDir();
-	if (!fs.existsSync(logDir)) return;
+	if (!fs$1.existsSync(logDir)) return;
 	const now = Date.now();
-	for (const entry of fs.readdirSync(logDir)) {
+	for (const entry of fs$1.readdirSync(logDir)) {
 		const filePath = path.join(logDir, entry);
 		let stats;
 		try {
-			stats = fs.statSync(filePath);
+			stats = fs$1.statSync(filePath);
 		} catch {
 			continue;
 		}
@@ -222,7 +174,7 @@ const cleanupOldLogs = async () => {
 			continue;
 		}
 		try {
-			fs.rmSync(filePath);
+			fs$1.rmSync(filePath);
 		} catch (error) {
 			console.warn(`Failed to remove old handler log: ${filePath}`, error);
 		}
@@ -267,7 +219,7 @@ const getLogStream = (filePath) => {
 	initializeLoggerRuntime();
 	let stream = logStreams.get(filePath);
 	if (!stream || stream.destroyed) {
-		const createdStream = fs.createWriteStream(filePath, { flags: "a" });
+		const createdStream = fs$1.createWriteStream(filePath, { flags: "a" });
 		stream = createdStream;
 		logStreams.set(filePath, createdStream);
 		createdStream.on("error", (error) => {
@@ -1063,7 +1015,7 @@ async function openNodeDatabase(dbPath) {
 }
 async function openSqliteDatabase(dbPath) {
 	const dir = path.dirname(dbPath);
-	if (dbPath !== ":memory:" && dir !== ".") await fs$1.mkdir(dir, { recursive: true });
+	if (dbPath !== ":memory:" && dir !== ".") await fs.mkdir(dir, { recursive: true });
 	return isBunRuntime() ? openBunDatabase(dbPath) : openNodeDatabase(dbPath);
 }
 var SqliteDbStore = class {
@@ -2695,11 +2647,11 @@ var CompactionRecoveryStore = class {
 	async prepareStorageDirectory() {
 		if (this.dbPath === ":memory:" || this.storagePrepared) return;
 		const directory = path.dirname(this.dbPath);
-		await fs$1.mkdir(directory, {
+		await fs.mkdir(directory, {
 			mode: this.secureDirectory ? 448 : void 0,
 			recursive: true
 		});
-		if (this.secureDirectory) await fs$1.chmod(directory, 448);
+		if (this.secureDirectory) await fs.chmod(directory, 448);
 		this.storagePrepared = true;
 	}
 	async secureDatabaseFiles() {
@@ -2710,7 +2662,7 @@ var CompactionRecoveryStore = class {
 		];
 		await Promise.all(candidates.map(async (candidate) => {
 			try {
-				await fs$1.chmod(candidate, 384);
+				await fs.chmod(candidate, 384);
 			} catch (error) {
 				if (!isMissingFileError(error)) throw error;
 			}
@@ -3521,160 +3473,8 @@ const createResponsesWebSocketStreamChunk = (data) => {
 	}
 };
 //#endregion
-//#region src/lib/timeout-dispatcher.ts
-/**
-* Node's global fetch keeps Undici's shorter default headers/body timeouts.
-* Wrap the global dispatcher so long-running requests (e.g. image
-* generation) get an explicit cap.
-*/
-const createTimeoutDispatcher = (timeoutMs) => ({ dispatch(options, handler) {
-	return getGlobalDispatcher().dispatch({
-		...options,
-		bodyTimeout: timeoutMs,
-		headersTimeout: timeoutMs
-	}, handler);
-} });
-//#endregion
-//#region src/services/providers/provider-proxy.ts
-const SHARED_FORWARDABLE_HEADERS = ["accept", "user-agent"];
-const ANTHROPIC_FORWARDABLE_HEADERS = ["anthropic-version", "anthropic-beta"];
-const STRIPPED_RESPONSE_HEADERS = [
-	"connection",
-	"content-encoding",
-	"content-length",
-	"keep-alive",
-	"proxy-authenticate",
-	"proxy-authorization",
-	"te",
-	"trailer",
-	"transfer-encoding",
-	"upgrade"
-];
-function buildProviderUpstreamHeaders(providerConfig, requestHeaders) {
-	const authHeaders = {};
-	if (providerConfig.authType === "x-api-key") authHeaders["x-api-key"] = providerConfig.apiKey;
-	else authHeaders.authorization = `Bearer ${providerConfig.apiKey}`;
-	const headers = {
-		"content-type": "application/json",
-		accept: "application/json",
-		...authHeaders
-	};
-	for (const headerName of SHARED_FORWARDABLE_HEADERS) {
-		const headerValue = requestHeaders.get(headerName);
-		if (headerValue) headers[headerName] = headerValue;
-	}
-	if (providerConfig.type !== "anthropic") return headers;
-	for (const headerName of ANTHROPIC_FORWARDABLE_HEADERS) {
-		const headerValue = requestHeaders.get(headerName);
-		if (headerValue) headers[headerName] = headerValue;
-	}
-	return headers;
-}
-const OPENCODE_GO_PROVIDER_NAME = "opencode-go";
-const OPENCODE_SESSION_HEADER = "x-opencode-session";
-const resolveOpencodeMessagesSession = (payload) => {
-	const sessionAffinity = requestContext.getStore()?.sessionAffinity?.trim();
-	if (sessionAffinity) return sessionAffinity;
-	const userId = payload.metadata?.user_id;
-	if (!userId?.trim()) return;
-	const { sessionId } = parseUserIdMetadata(userId);
-	return sessionId ?? userId;
-};
-const applyOpencodeSessionHeader = (providerConfig, headers, session) => {
-	if (providerConfig.name !== OPENCODE_GO_PROVIDER_NAME || !session) return;
-	headers[OPENCODE_SESSION_HEADER] = session;
-};
-function createProviderProxyResponse(upstreamResponse, body) {
-	const headers = new Headers(upstreamResponse.headers);
-	for (const headerName of STRIPPED_RESPONSE_HEADERS) headers.delete(headerName);
-	return new Response(body ?? upstreamResponse.body, {
-		headers,
-		status: upstreamResponse.status,
-		statusText: upstreamResponse.statusText
-	});
-}
-async function forwardProviderMessages(providerConfig, payload, requestHeaders) {
-	consola.log(`<-- model: ${payload.model}`);
-	const headers = buildProviderUpstreamHeaders(providerConfig, requestHeaders);
-	applyOpencodeSessionHeader(providerConfig, headers, resolveOpencodeMessagesSession(payload));
-	return await fetch(`${providerConfig.baseUrl}/v1/messages`, {
-		method: "POST",
-		headers,
-		body: JSON.stringify(payload)
-	});
-}
-async function forwardProviderChatCompletions(providerConfig, payload, requestHeaders) {
-	consola.log(`<-- model: ${payload.model}`);
-	const headers = buildProviderUpstreamHeaders(providerConfig, requestHeaders);
-	applyOpencodeSessionHeader(providerConfig, headers, payload.prompt_cache_key?.trim() || void 0);
-	return await fetch(`${providerConfig.baseUrl}/v1/chat/completions`, {
-		method: "POST",
-		headers,
-		body: JSON.stringify(payload)
-	});
-}
-async function forwardProviderResponses(providerConfig, payload, requestHeaders, options = {}) {
-	consola.log(`<-- model: ${payload.model}`);
-	const transportConfig = getResponsesTransportConfig();
-	const headers = buildProviderUpstreamHeaders(providerConfig, requestHeaders);
-	applyOpencodeSessionHeader(providerConfig, headers, payload.prompt_cache_key?.trim() || void 0);
-	return await fetchResponsesWithLifecycle(`${providerConfig.baseUrl}/v1/responses`, {
-		method: "POST",
-		headers,
-		body: JSON.stringify(payload)
-	}, {
-		headersTimeoutMs: transportConfig.headersTimeoutMs,
-		signal: options.signal,
-		streamInactivityTimeoutMs: transportConfig.streamInactivityTimeoutMs
-	});
-}
-const PROVIDER_MODELS_TIMEOUT_MS = 15e3;
-async function forwardProviderModels(providerConfig, requestHeaders) {
-	return await fetch(`${providerConfig.baseUrl}/v1/models`, {
-		method: "GET",
-		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders),
-		signal: AbortSignal.timeout(PROVIDER_MODELS_TIMEOUT_MS)
-	});
-}
-/** Align with Codex images: long-running generation/edits need a generous cap. */
-const PROVIDER_IMAGES_TIMEOUT_MS = 900 * 1e3;
-const providerImagesDispatcher = createTimeoutDispatcher(PROVIDER_IMAGES_TIMEOUT_MS);
-function resolveProviderRequestUrl(providerConfig, requestUrl, path) {
-	const upstreamUrl = new URL(`${providerConfig.baseUrl}${path}`);
-	upstreamUrl.search = new URL(requestUrl, "http://localhost").search;
-	return upstreamUrl.toString();
-}
-async function forwardProviderAlphaSearch(providerConfig, request) {
-	const headers = buildProviderUpstreamHeaders(providerConfig, request.headers);
-	const body = await request.arrayBuffer();
-	return await fetch(resolveProviderRequestUrl(providerConfig, request.url, "/v1/alpha/search"), {
-		method: "POST",
-		headers,
-		body
-	});
-}
-async function forwardProviderImages(providerConfig, request, operation) {
-	const headers = buildProviderUpstreamHeaders(providerConfig, request.headers);
-	const contentType = request.headers.get("content-type");
-	if (contentType) headers["content-type"] = contentType;
-	else if (operation === "edits") delete headers["content-type"];
-	const init = {
-		method: "POST",
-		headers,
-		body: request.body,
-		duplex: "half",
-		signal: AbortSignal.timeout(PROVIDER_IMAGES_TIMEOUT_MS)
-	};
-	const upstreamUrl = resolveProviderRequestUrl(providerConfig, request.url, `/v1/images/${operation}`);
-	if (typeof Bun !== "undefined") return await fetch(upstreamUrl, init);
-	return await fetch$1(upstreamUrl, {
-		...init,
-		dispatcher: providerImagesDispatcher
-	});
-}
-//#endregion
 //#region src/routes/alpha-search/alpha-search-responses.ts
-const logger$16 = createHandlerLogger("alpha-search-responses-handler");
+const logger$17 = createHandlerLogger("alpha-search-responses-handler");
 const SESSION_TTL_MS = 3600 * 1e3;
 const MAX_SESSIONS = 128;
 const MAX_URL_REFERENCES = 256;
@@ -4032,14 +3832,14 @@ function createRemoteResponsesPayload(request, model, instruction) {
 	};
 }
 async function requestProviderSearch(c, providerConfig, payload, model, sessionId) {
-	debugJson(logger$16, "Alpha search provider Responses request:", {
+	debugJson(logger$17, "Alpha search provider Responses request:", {
 		payload,
 		provider: providerConfig.name
 	});
 	const upstreamResponse = await forwardProviderResponses(providerConfig, payload, c.req.raw.headers, { signal: 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$16, "Alpha search provider Responses result:", {
+	debugJson(logger$17, "Alpha search provider Responses result:", {
 		provider: providerConfig.name,
 		result
 	});
@@ -4055,7 +3855,7 @@ async function requestProviderSearch(c, providerConfig, payload, model, sessionI
 	return result;
 }
 async function requestCopilotSearch(payload, model, requestId, sessionId, signal) {
-	debugJson(logger$16, "Alpha search Copilot Responses request:", payload);
+	debugJson(logger$17, "Alpha search Copilot Responses request:", payload);
 	const result = await alphaSearchResponsesDependencies.createResponses(payload, {
 		vision: false,
 		initiator: "agent",
@@ -4064,7 +3864,7 @@ async function requestCopilotSearch(payload, model, requestId, sessionId, signal
 		sessionId,
 		signal
 	});
-	debugJson(logger$16, "Alpha search Copilot Responses result:", result);
+	debugJson(logger$17, "Alpha search Copilot Responses result:", result);
 	alphaSearchResponsesDependencies.createUsageRecorder(model, sessionId)({
 		...normalizeResponsesUsage(result.usage),
 		total_nano_aiu: normalizeOptionalToken(result.copilot_usage?.total_nano_aiu)
@@ -4179,7 +3979,7 @@ async function forwardCodexAlphaSearch(request) {
 }
 //#endregion
 //#region src/routes/alpha-search/route.ts
-const logger$15 = createHandlerLogger("alpha-search-handler");
+const logger$16 = createHandlerLogger("alpha-search-handler");
 const alphaSearchRoutes = new Hono();
 const alphaSearchRouteDependencies = {
 	findEndpointModel,
@@ -4199,9 +3999,9 @@ function parseDebugBody(body) {
 	}
 }
 async function forwardCodexAlphaSearchRequest(request) {
-	await debugJsonAsync(logger$15, "alpha_search.codex.request", async () => ({ body: parseDebugBody(await request.clone().text()) }));
+	await debugJsonAsync(logger$16, "alpha_search.codex.request", async () => ({ body: parseDebugBody(await request.clone().text()) }));
 	const upstreamResponse = await alphaSearchRouteDependencies.forwardCodexAlphaSearch(request);
-	await debugJsonAsync(logger$15, "alpha_search.codex.response", async () => ({
+	await debugJsonAsync(logger$16, "alpha_search.codex.response", async () => ({
 		body: parseDebugBody(await upstreamResponse.clone().text()),
 		statusCode: upstreamResponse.status
 	}));
@@ -4312,7 +4112,7 @@ alphaSearchRoutes.post("/", async (c) => {
 	try {
 		return await handleAlphaSearchRequest(c);
 	} catch (error) {
-		logger$15.error("alpha_search.error", { error });
+		logger$16.error("alpha_search.error", { error });
 		return await forwardError(c, error);
 	}
 });
@@ -4485,7 +4285,7 @@ const normalizeProviderResponsesReasoningEffort = (payload, providerConfig) => {
 };
 //#endregion
 //#region src/routes/provider/chat-completions/handler.ts
-const logger$14 = createHandlerLogger("provider-chat-completions-handler");
+const logger$15 = createHandlerLogger("provider-chat-completions-handler");
 async function handleProviderChatCompletionsForProvider(c, options) {
 	const { payload, provider } = options;
 	const providerConfig = await resolveProviderConfig(provider);
@@ -4499,13 +4299,13 @@ async function handleProviderChatCompletionsForProvider(c, options) {
 	applyProviderStreamOptions(payload);
 	applyDashScopePreserveThinkingDefault(payload, providerConfig);
 	applyProviderContextCache(payload, modelConfig, providerConfig);
-	debugJson(logger$14, "provider.chat_completions.request", {
+	debugJson(logger$15, "provider.chat_completions.request", {
 		payload,
 		provider
 	});
-	const upstreamResponse = await forwardProviderChatCompletions(providerConfig, payload, c.req.raw.headers);
+	const upstreamResponse = await forwardProviderChatCompletions(providerConfig, payload, c.req.raw.headers, { signal: c.req.raw.signal });
 	if (!upstreamResponse.ok) {
-		logger$14.error("Failed to create provider chat completions", {
+		logger$15.error("Failed to create provider chat completions", {
 			provider,
 			statusCode: upstreamResponse.status
 		});
@@ -4519,7 +4319,7 @@ async function handleProviderChatCompletionsForProvider(c, options) {
 	});
 	const responseBody = await upstreamResponse.clone().json();
 	recordUsage(normalizeOpenAIUsage(responseBody.usage));
-	debugJson(logger$14, "provider.chat_completions.response", responseBody);
+	debugJson(logger$15, "provider.chat_completions.response", responseBody);
 	return createProviderProxyResponse(upstreamResponse);
 }
 const applyProviderStreamOptions = (payload) => {
@@ -4541,12 +4341,12 @@ const createProviderChatCompletionsUsageRecorder = (payload, provider, modelConf
 	providerName: provider
 });
 const streamProviderChatCompletions = (c, upstreamResponse, options) => {
-	logger$14.debug("provider.chat_completions.streaming", { provider: options.provider });
+	logger$15.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$14, "provider.chat_completions.stream_chunk", chunk);
+				debugJson(logger$15, "provider.chat_completions.stream_chunk", chunk);
 				if (chunk.data && chunk.data !== "[DONE]") {
 					const parsedChunk = parseChatCompletionChunkData(chunk.data);
 					if (parsedChunk?.usage) usage = normalizeOpenAIUsage(parsedChunk.usage);
@@ -4600,7 +4400,7 @@ const createChatCompletions = async (payload, options) => {
 };
 //#endregion
 //#region src/routes/chat-completions/handler.ts
-const logger$13 = createHandlerLogger("chat-completions-handler");
+const logger$14 = createHandlerLogger("chat-completions-handler");
 async function handleCompletion$1(c) {
 	let payload = await c.req.json();
 	const requestedModel = payload.model;
@@ -4614,7 +4414,7 @@ async function handleCompletion$1(c) {
 			provider: providerModelAlias.provider
 		});
 	}
-	debugJson(logger$13, "Request payload:", payload);
+	debugJson(logger$14, "Request payload:", payload);
 	const selectedModel = findEndpointModel(payload.model);
 	payload.model = selectedModel?.id ?? payload.model;
 	if (isNullish(payload.max_tokens) && isNullish(payload.max_completion_tokens)) {
@@ -4622,16 +4422,16 @@ async function handleCompletion$1(c) {
 			...payload,
 			max_tokens: selectedModel?.capabilities.limits.max_output_tokens
 		};
-		debugJson(logger$13, "Set max_tokens to:", payload.max_tokens);
+		debugJson(logger$14, "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$13.debug("Generated request ID:", requestId);
+	logger$14.debug("Generated request ID:", requestId);
 	const sessionId = getUUID(requestId);
-	logger$13.debug("Extracted session ID:", sessionId);
+	logger$14.debug("Extracted session ID:", sessionId);
 	const recordUsage = createCopilotTokenUsageRecorder({
 		endpoint: "chat_completions",
 		fallbackSessionId: sessionId,
@@ -4642,18 +4442,18 @@ async function handleCompletion$1(c) {
 		sessionId
 	});
 	if (isNonStreaming$1(response)) {
-		debugJson(logger$13, "Non-streaming response:", response);
+		debugJson(logger$14, "Non-streaming response:", response);
 		recordUsage({
 			...normalizeOpenAIUsage(response.usage),
 			total_nano_aiu: normalizeOptionalToken(response.copilot_usage?.total_nano_aiu)
 		});
 		return c.json(response);
 	}
-	logger$13.debug("Streaming response");
+	logger$14.debug("Streaming response");
 	return streamSSE(c, async (stream) => {
 		let usage = {};
 		for await (const chunk of response) {
-			debugJson(logger$13, "Streaming chunk:", chunk);
+			debugJson(logger$14, "Streaming chunk:", chunk);
 			const parsedChunk = parseChatCompletionChunk(chunk);
 			if (parsedChunk?.usage || parsedChunk?.copilot_usage) usage = {
 				...normalizeOpenAIUsage(parsedChunk.usage),
@@ -4742,31 +4542,48 @@ embeddingRoutes.post("/", async (c) => {
 	}
 });
 //#endregion
-//#region src/services/codex/images.ts
-const CODEX_IMAGES_TIMEOUT_MS = 900 * 1e3;
-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();
+//#region src/routes/images/body-limit.ts
+function createImagesBodyTooLargeError(maxBytes) {
+	const message = `Image request body exceeds the ${maxBytes}-byte limit`;
+	return new HTTPError(message, new Response(message, {
+		headers: { "content-type": "text/plain; charset=utf-8" },
+		status: 413
+	}));
 }
-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
-	});
+async function readRequestBodyWithLimit(request, maxBytes) {
+	const contentLength = request.headers.get("content-length");
+	if (contentLength !== null) {
+		const declaredBytes = Number(contentLength);
+		if (Number.isFinite(declaredBytes) && declaredBytes > maxBytes) throw createImagesBodyTooLargeError(maxBytes);
+	}
+	if (!request.body) return /* @__PURE__ */ new ArrayBuffer(0);
+	const reader = request.body.getReader();
+	const chunks = [];
+	let totalBytes = 0;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			if (!value || value.byteLength === 0) continue;
+			totalBytes += value.byteLength;
+			if (totalBytes > maxBytes) {
+				try {
+					await reader.cancel();
+				} catch {}
+				throw createImagesBodyTooLargeError(maxBytes);
+			}
+			chunks.push(value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	const body = new Uint8Array(totalBytes);
+	let offset = 0;
+	for (const chunk of chunks) {
+		body.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return body.buffer;
 }
 //#endregion
 //#region src/routes/images/forward-provider-images.ts
@@ -4795,13 +4612,38 @@ async function forwardProviderImagesWithLogging(providerConfig, request, operati
 	return createProviderProxyResponse(upstreamResponse);
 }
 //#endregion
-//#region src/routes/images/route.ts
-const logger$12 = createHandlerLogger("images-handler");
-const MAX_IMAGES_REQUEST_BODY_BYTES = 64 * 1024 * 1024;
-const imageRoutes = new Hono();
+//#region src/services/codex/images.ts
+const CODEX_IMAGES_TIMEOUT_MS = 900 * 1e3;
+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
+	});
+}
+//#endregion
+//#region src/routes/images/shared.ts
+const logger$13 = createHandlerLogger("images-handler");
 const imageRouteDependencies = {
+	maxRequestBodyBytes: 64 * 1024 * 1024,
 	debugJsonAsync,
-	maxRequestBodyBytes: MAX_IMAGES_REQUEST_BODY_BYTES,
 	resolveMappedModel,
 	resolveProviderConfig
 };
@@ -4811,114 +4653,33 @@ function getContentMetadata(headers) {
 		contentLength: headers.get("content-length")
 	};
 }
-function createJsonImagesRequest(request, requestHeaders, payload, model) {
-	const headers = new Headers(requestHeaders);
-	headers.delete("content-length");
-	return new Request(request.url, {
-		body: JSON.stringify({
-			...payload,
-			model
-		}),
-		headers,
-		method: request.method,
-		signal: request.signal
-	});
+/**
+* Snapshots request headers before the body is consumed: Bun drops
+* auto-generated body headers (like the multipart boundary) afterwards.
+*/
+function snapshotRequestHeaders(request) {
+	return new Headers(request.headers);
 }
-function createBufferedImagesRequest(request, requestHeaders, body) {
-	return new Request(request.url, {
+/**
+* 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
-	});
-}
-function createMultipartImagesRequest(request, requestHeaders, formData, model) {
-	formData.set("model", model);
-	const headers = new Headers(requestHeaders);
-	headers.delete("content-length");
-	headers.delete("content-type");
-	return new Request(request.url, {
-		body: formData,
-		headers,
-		method: request.method,
-		signal: request.signal
-	});
-}
-function createImagesBodyTooLargeError(maxBytes) {
-	const message = `Image request body exceeds the ${maxBytes}-byte limit`;
-	return new HTTPError(message, new Response(message, {
-		headers: { "content-type": "text/plain; charset=utf-8" },
-		status: 413
-	}));
-}
-async function readRequestBodyWithLimit(request, maxBytes) {
-	const contentLength = request.headers.get("content-length");
-	if (contentLength !== null) {
-		const declaredBytes = Number(contentLength);
-		if (Number.isFinite(declaredBytes) && declaredBytes > maxBytes) throw createImagesBodyTooLargeError(maxBytes);
-	}
-	if (!request.body) return /* @__PURE__ */ new ArrayBuffer(0);
-	const reader = request.body.getReader();
-	const chunks = [];
-	let totalBytes = 0;
-	try {
-		while (true) {
-			const { done, value } = await reader.read();
-			if (done) break;
-			if (!value || value.byteLength === 0) continue;
-			totalBytes += value.byteLength;
-			if (totalBytes > maxBytes) {
-				try {
-					await reader.cancel();
-				} catch {}
-				throw createImagesBodyTooLargeError(maxBytes);
-			}
-			chunks.push(value);
-		}
-	} finally {
-		reader.releaseLock();
-	}
-	const body = new Uint8Array(totalBytes);
-	let offset = 0;
-	for (const chunk of chunks) {
-		body.set(chunk, offset);
-		offset += chunk.byteLength;
-	}
-	return body.buffer;
-}
-async function parseImagesRequest(request) {
-	const requestHeaders = new Headers(request.headers);
-	const contentType = requestHeaders.get("content-type");
-	const body = await readRequestBodyWithLimit(request, imageRouteDependencies.maxRequestBodyBytes);
-	const originalRequest = createBufferedImagesRequest(request, requestHeaders, body);
-	if (contentType?.split(";", 1)[0]?.trim().toLowerCase() === "multipart/form-data" && contentType) try {
-		const formData = await bufferToFormData(body, contentType);
-		const model = formData.get("model");
-		if (typeof model !== "string") return originalRequest;
-		return {
-			createRequest: (mappedModel) => createMultipartImagesRequest(request, requestHeaders, formData, mappedModel),
-			model,
-			originalRequest
-		};
-	} catch {
-		return originalRequest;
-	}
-	try {
-		const payload = JSON.parse(new TextDecoder().decode(body));
-		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
-		};
-	} catch {
-		return originalRequest;
-	}
+	};
+	return new Request(request.url, init);
 }
 /**
-* Handles Codex images proxying. Pass `resolvedProviderConfig` when the
+* Handles Codex images proxying. Pass a resolvedProviderConfig when the
 * caller already resolved the codex provider to avoid a second resolve, and
-* pass `request` when model mapping rebuilt the request body.
+* pass a request when model mapping rebuilt the request body.
 */
 async function handleCodexImages(c, operation, resolvedProviderConfig, request = c.req.raw) {
 	try {
@@ -4926,48 +4687,386 @@ async function handleCodexImages(c, operation, resolvedProviderConfig, request =
 			message: "Provider 'codex' not found or disabled",
 			type: "invalid_request_error"
 		} }, 404);
-		if (operation === "generations") await imageRouteDependencies.debugJsonAsync(logger$12, "images.generations.codex.request", async () => ({ body: await request.clone().text() }));
-		else debugJson(logger$12, "images.edits.codex.request", getContentMetadata(request.headers));
+		if (operation === "generations") await imageRouteDependencies.debugJsonAsync(logger$13, "images.generations.codex.request", async () => ({ body: await request.clone().text() }));
+		else debugJson(logger$13, "images.edits.codex.request", getContentMetadata(request.headers));
 		const upstreamResponse = await forwardCodexImages(request, operation);
-		debugJson(logger$12, `images.${operation}.codex.response`, {
+		debugJson(logger$13, `images.${operation}.codex.response`, {
 			...getContentMetadata(upstreamResponse.headers),
 			statusCode: upstreamResponse.status
 		});
 		return createProviderProxyResponse(upstreamResponse);
 	} catch (error) {
-		logger$12.error(`images.${operation}.codex.error`, { error });
+		logger$13.error(`images.${operation}.codex.error`, { error });
 		return await forwardError(c, error);
 	}
 }
-async function handleImagesRequest(c, operation) {
+/**
+* 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$13,
+				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 ?? 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));
+}
+//#endregion
+//#region src/routes/images/temp-form-data.ts
+const logger$12 = createHandlerLogger("images-temp-form-data");
+const multipartStagingDependencies = { createWriteStream };
+/**
+* Matches the images forwarding timeouts: an upstream upload may take that
+* long, so staged files must survive at least the whole forwarding window.
+*/
+const STAGED_FILES_TTL_MS = 900 * 1e3;
+const DEFAULT_MULTIPART_STAGING_LIMITS = {
+	maxBodySizeBytes: 128 * 1024 * 1024,
+	maxFieldSizeBytes: 10 * 1024 * 1024,
+	maxFields: 64,
+	maxFileSizeBytes: 64 * 1024 * 1024,
+	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";
+}
+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 toError(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+function parseMultipartBody(body, contentType, directory, entries, limits) {
+	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("close", () => activeFileStreams.delete(stream));
+			stream.once("limit", failLimit);
+			const write = pipeline(stream, multipartStagingDependencies.createWriteStream(filePath));
+			pendingWrites.push(write);
+			write.catch(fail);
+		});
+		busboy.on("fieldsLimit", failLimit);
+		busboy.on("filesLimit", failLimit);
+		busboy.on("partsLimit", failLimit);
+		inputPipeline = pipeline(source, bodyLimiter, busboy);
+		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 ? error : new InvalidMultipartBodyError({ cause: toError(error) }));
+		});
+	});
+}
+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;
+}
+/**
+* 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.
+*/
+async function stageMultipartBodyToDisk(body, contentType, limitOverrides = {}) {
+	const limits = resolveStagingLimits(limitOverrides);
+	const directory = await mkdtemp(join(tmpdir(), "copilot-api-images-"));
+	const entries = [];
 	try {
-		const parsedRequest = await parseImagesRequest(c.req.raw);
-		if (parsedRequest instanceof Request) return await handleCodexImages(c, operation, void 0, parsedRequest);
-		const requestedModel = parsedRequest.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 = parsedRequest.createRequest(providerModelAlias.model);
-				if (providerConfig.name === "codex") return await handleCodexImages(c, operation, providerConfig, request);
-				return await forwardProviderImagesWithLogging(providerConfig, request, operation, {
-					logger: logger$12,
-					provider: providerModelAlias.provider
+		await parseMultipartBody(body, contentType, directory, entries, limits);
+	} catch (error) {
+		await rm(directory, {
+			force: true,
+			recursive: true
+		});
+		throw error;
+	}
+	const stagedFormData = new FormData();
+	try {
+		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) {
+		await rm(directory, {
+			force: true,
+			recursive: true
+		});
+		throw error;
+	}
+	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$12.warn("Failed to remove staged images temp directory", {
+					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, parsedRequest.originalRequest);
+		})();
+		return cleanupPromise;
+	};
+	unregisterProcessCleanup = registerProcessCleanup(() => {
+		if (cleanupTimer) {
+			clearTimeout(cleanupTimer);
+			cleanupTimer = null;
+		}
+		try {
+			rmSync(directory, {
+				force: true,
+				recursive: true
+			});
+		} catch (error) {
+			logger$12.warn("Failed to remove staged images temp directory on exit", {
+				directory,
+				error
+			});
+		} finally {
+			unregisterProcessCleanup?.();
+			unregisterProcessCleanup = null;
+		}
+	});
+	return {
+		directory,
+		formData: stagedFormData,
+		cleanup,
+		scheduleCleanup: () => {
+			if (cleanupPromise || cleanupTimer) return;
+			cleanupTimer = setTimeout(() => void cleanup(), STAGED_FILES_TTL_MS);
+			cleanupTimer.unref();
+		}
+	};
+}
+//#endregion
+//#region src/routes/images/edits-handler.ts
+const imageEditsRouteDependencies = { stageMultipartBodyToDisk };
+function createStagedFormDataRequest(request, requestHeaders, formData) {
+	const headers = new Headers(requestHeaders);
+	headers.delete("content-length");
+	headers.delete("content-type");
+	return createForwardRequest(request, headers, formData);
+}
+function createMultipartImagesRequest(request, requestHeaders, formData, model) {
+	formData.set("model", model);
+	return createStagedFormDataRequest(request, requestHeaders, formData);
+}
+/**
+* Streams an edits multipart body to disk, staging uploaded files so
+* forwarding streams them from the filesystem instead of pinning them in
+* memory. Non-multipart bodies come back as an untouched request stream;
+* malformed multipart bodies throw a typed error because the consumed stream
+* can no longer be forwarded.
+*/
+async function parseEditsRequest(request) {
+	const requestHeaders = snapshotRequestHeaders(request);
+	const contentType = requestHeaders.get("content-type");
+	if (contentType?.split(";", 1)[0]?.trim().toLowerCase() !== "multipart/form-data" || !contentType) return createForwardRequest(request, requestHeaders, await readRequestBodyWithLimit(request, imageRouteDependencies.maxRequestBodyBytes));
+	const staged = await imageEditsRouteDependencies.stageMultipartBodyToDisk(request.body, contentType, { maxBodySizeBytes: imageRouteDependencies.maxRequestBodyBytes });
+	const model = staged.formData.get("model");
+	return {
+		model: typeof model === "string" ? model : void 0,
+		requestHeaders,
+		staged
+	};
+}
+async function handleImagesEdits(c) {
+	try {
+		const parsed = await parseEditsRequest(c.req.raw);
+		if (parsed instanceof Request) return await handleCodexImages(c, "edits", void 0, parsed);
+		const { model, requestHeaders, staged } = parsed;
+		try {
+			const response = model === void 0 ? await handleCodexImages(c, "edits", void 0, createStagedFormDataRequest(c.req.raw, requestHeaders, staged.formData)) : await routeImagesRequest(c, "edits", {
+				createRequest: (mappedModel) => createMultipartImagesRequest(c.req.raw, requestHeaders, staged.formData, mappedModel),
+				model
+			});
+			staged.scheduleCleanup();
+			return response;
+		} catch (error) {
+			await staged.cleanup();
+			throw error;
 		}
-		return await handleCodexImages(c, operation, void 0, mappedModel === requestedModel ? parsedRequest.originalRequest : parsedRequest.createRequest(mappedModel));
 	} catch (error) {
-		logger$12.error(`images.${operation}.error`, { error });
+		if (error instanceof InvalidMultipartBodyError || error instanceof MultipartBodyTooLargeError) return c.json({ error: {
+			message: error.message,
+			type: "invalid_request_error"
+		} }, error instanceof MultipartBodyTooLargeError ? 413 : 400);
+		logger$13.error("images.edits.error", { error });
 		return await forwardError(c, error);
 	}
 }
-imageRoutes.post("/generations", (c) => handleImagesRequest(c, "generations"));
-imageRoutes.post("/edits", (c) => handleImagesRequest(c, "edits"));
+//#endregion
+//#region src/routes/images/generations-handler.ts
+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 a generations request body as JSON. Generation payloads are small
+* JSON documents, so one byte copy covers both routing on the model field
+* and forwarding an unchanged body to Codex. Rebuilt bodies stay binary so
+* Node does not synthesize a text/plain content type.
+*/
+async function parseGenerationsRequest(request) {
+	const requestHeaders = snapshotRequestHeaders(request);
+	const body = new Uint8Array(await readRequestBodyWithLimit(request, imageRouteDependencies.maxRequestBodyBytes));
+	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
+	};
+}
+async function handleImagesGenerations(c) {
+	try {
+		const parsed = await parseGenerationsRequest(c.req.raw);
+		if (parsed instanceof Request) return await handleCodexImages(c, "generations", void 0, parsed);
+		return await routeImagesRequest(c, "generations", parsed);
+	} catch (error) {
+		logger$13.error("images.generations.error", { error });
+		return await forwardError(c, error);
+	}
+}
+//#endregion
+//#region src/routes/images/route.ts
+const imageRoutes = new Hono();
+imageRoutes.post("/generations", handleImagesGenerations);
+imageRoutes.post("/edits", handleImagesEdits);
 //#endregion
 //#region src/lib/tokenizer.ts
 const ENCODING_MAP = {
@@ -6117,6 +6216,7 @@ async function handleCountTokens(c) {
 //#endregion
 //#region src/lib/codex-rate-limit.ts
 const codexRateLimitScopes = ["primary", "secondary"];
+const quotaWarningUsedPercent = 90;
 const formatCodexRateLimitResetAt = (resetAt) => {
 	const date = /* @__PURE__ */ new Date(resetAt * 1e3);
 	return Number.isNaN(date.getTime()) ? String(resetAt) : date.toLocaleString();
@@ -6131,16 +6231,21 @@ const logCodexRateLimitsEvent = (event) => {
 	const rateLimitRecord = rateLimits;
 	const allowed = typeof rateLimitRecord.allowed === "boolean" ? rateLimitRecord.allowed : null;
 	const limitReached = typeof rateLimitRecord.limit_reached === "boolean" ? rateLimitRecord.limit_reached : null;
+	const blocked = allowed === false || limitReached === true;
+	let hasWindow = false;
 	for (const scope of codexRateLimitScopes) {
 		const window = rateLimitRecord[scope];
 		if (!isCodexRateLimitWindow(window)) continue;
+		hasWindow = true;
 		const summary = [];
 		if (allowed !== null) summary.push(`allowed=${allowed}`);
 		if (limitReached !== null) summary.push(`limit_reached=${limitReached}`);
 		summary.push(`used=${window.used_percent}%`, `reset_at=${formatCodexRateLimitResetAt(window.reset_at)}`);
-		const label = planType ? `Codex ${scope} rate limit (${planType})` : `Codex ${scope} rate limit`;
-		consola.log(`${label}: ${summary.join(", ")}`);
+		const message = `${planType ? `Codex ${scope} quota (${planType})` : `Codex ${scope} quota`}: ${summary.join(", ")}`;
+		if (blocked || window.used_percent >= quotaWarningUsedPercent) consola.warn(message);
+		else consola.debug(message);
 	}
+	if (blocked && !hasWindow) consola.warn(`Codex quota restricted: allowed=${allowed}, limit_reached=${limitReached}`);
 };
 const isCodexRateLimitWindow = (value) => {
 	if (!value || typeof value !== "object") return false;
@@ -9212,7 +9317,7 @@ const handleOpenAICompatibleProviderMessages = async (c, options) => {
 		payload: openAIPayload,
 		provider
 	});
-	const upstreamResponse = await forwardProviderChatCompletions(providerConfig, openAIPayload, c.req.raw.headers);
+	const upstreamResponse = await forwardProviderChatCompletions(providerConfig, openAIPayload, c.req.raw.headers, { signal: c.req.raw.signal });
 	if (!upstreamResponse.ok) {
 		logger$10.error("Failed to create openai-compatible responses", upstreamResponse);
 		throw new HTTPError("Failed to create openai-compatible responses", upstreamResponse);
@@ -11418,17 +11523,6 @@ function isDeepSeekModelId(modelId) {
 function shouldInjectMessagesToolCallTips(userAgent, targetModel) {
 	return isCodexUserAgent(userAgent) && !isDeepSeekModelId(targetModel);
 }
-async function logCodexModelsResponse(response) {
-	try {
-		const models = await response.clone().json();
-		debugJson(logger$8, "models.codex.response", {
-			statusCode: response.status,
-			models
-		});
-	} catch (error) {
-		logger$8.warn("models.codex.response_log_error", { error });
-	}
-}
 /**
 * Proxies a models request to the fixed Codex upstream models endpoint.
 * Returns a 404 JSON response when the codex provider is unavailable.
@@ -11440,9 +11534,7 @@ async function handleCodexModelsProxy(c, resolvedProviderConfig) {
 		message: "Provider 'codex' not found or disabled",
 		type: "invalid_request_error"
 	} }, 404);
-	const upstreamResponse = await forwardCodexModels(c.req.url, c.req.raw.headers);
-	await logCodexModelsResponse(upstreamResponse);
-	return createProviderProxyResponse(upstreamResponse);
+	return createProviderProxyResponse(await forwardCodexModels(c.req.url, c.req.raw.headers));
 }
 async function handleMergedCodexModels(c, candidatesRequest, options = {}) {
 	const [upstreamCatalog, candidates] = await Promise.all([tryGetCodexCatalog(c), Promise.resolve(candidatesRequest).catch((error) => {
@@ -11482,12 +11574,6 @@ async function handleMergedCodexModels(c, candidatesRequest, options = {}) {
 		...upstreamCatalog ?? {},
 		models
 	};
-	debugJson(logger$8, "models.codex.merged_response", {
-		upstreamCount: upstreamModels.length,
-		codexProviderAliasCount: codexProviderAliases.length,
-		syntheticCount: syntheticModels.length,
-		models: response
-	});
 	return c.json(response);
 }
 function createCatalogAlias(model, slug, providerName) {
@@ -12034,6 +12120,74 @@ providerModelRoutes.get("/", async (c) => {
 	}
 });
 //#endregion
+//#region src/lib/zstd-request.ts
+const ZSTD_CONTENT_ENCODING = "zstd";
+const INVALID_BODY_STATUS = 400;
+let nodeZlibPromise = null;
+const zstdDecompressionMiddleware = async (c, next) => {
+	if (c.req.header("content-encoding")?.trim().toLowerCase() !== ZSTD_CONTENT_ENCODING) return next();
+	try {
+		const decompressedBody = await decompressZstd(new Uint8Array(await c.req.raw.arrayBuffer()));
+		const headers = new Headers(c.req.raw.headers);
+		headers.delete("content-encoding");
+		headers.delete("content-length");
+		c.req.raw = new Request(c.req.raw.url, {
+			body: decompressedBody,
+			headers,
+			method: c.req.raw.method,
+			signal: c.req.raw.signal
+		});
+		c.req.bodyCache = {};
+	} catch {
+		return c.json({ error: {
+			message: "Failed to decompress zstd request body.",
+			type: "invalid_request_error"
+		} }, INVALID_BODY_STATUS);
+	}
+	return next();
+};
+const decompressZstd = async (input) => {
+	const bun = getBunRuntime();
+	if (bun?.zstdDecompress) return toUint8Array(await bun.zstdDecompress(input));
+	const nodeZlib = await getNodeZlib();
+	if (nodeZlib?.zstdDecompress) return new Promise((resolve, reject) => {
+		nodeZlib.zstdDecompress?.(input, (error, result) => {
+			if (error) {
+				reject(error);
+				return;
+			}
+			resolve(toUint8Array(result));
+		});
+	});
+	return decompress(input);
+};
+const getBunRuntime = () => globalThis.Bun;
+const getNodeZlib = async () => {
+	nodeZlibPromise ??= import("node:zlib").then((module) => module).catch(() => null);
+	return nodeZlibPromise;
+};
+const toUint8Array = (data) => {
+	if (data instanceof Uint8Array) return data;
+	if (data instanceof ArrayBuffer) return new Uint8Array(data);
+	return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+};
+//#endregion
+//#region src/services/qoder/responses-compat.ts
+const NATIVE_SEARCH = new Set(["web_search", "web_search_preview"]);
+function qoderResponsesPayload(payload) {
+	const tools = payload.tools ?? [];
+	if (!tools.some((tool) => typeof tool.type === "string" && NATIVE_SEARCH.has(tool.type))) return payload;
+	const choice = payload.tool_choice;
+	if (typeof choice === "object" && choice !== null && NATIVE_SEARCH.has(choice.type)) throw new ResponsesMessagesTranslationError("Qoder does not support provider-native web search; use a client search tool");
+	const supported = tools.filter((tool) => !(typeof tool.type === "string" && NATIVE_SEARCH.has(tool.type)));
+	if (choice === "required" && !supported.length) throw new ResponsesMessagesTranslationError("Qoder cannot satisfy a required native web search tool");
+	return {
+		...payload,
+		tools: supported,
+		instructions: [payload.instructions, "Provider-native web search is unavailable on this route. Do not claim to have searched the web unless an available client tool actually returns search results."].filter(Boolean).join("\n\n")
+	};
+}
+//#endregion
 //#region src/routes/responses/custom-tool-input-stream-decoder.ts
 const CUSTOM_TOOL_INPUT_PREFIX_TOKENS = [
 	"{",
@@ -12919,7 +13073,8 @@ function isAnthropicResponse(value) {
 const logger$2 = createHandlerLogger("provider-responses-handler");
 const providerResponsesHandlerDependencies = { resolveProviderConfig };
 async function handleProviderResponsesForProvider(c, options) {
-	const { payload, provider } = options;
+	const { provider } = options;
+	let { payload } = options;
 	debugJson(logger$2, "Responses request payload:", {
 		payload,
 		provider
@@ -12929,6 +13084,7 @@ async function handleProviderResponsesForProvider(c, options) {
 		message: `Provider '${provider}' does not support the /v1/responses endpoint`,
 		type: "invalid_request_error"
 	} }, 400);
+	if (isQoderSdkProvider(providerConfig)) payload = qoderResponsesPayload(payload);
 	const effectiveType = resolveEffectiveProviderType(providerConfig, payload.model);
 	const normalizedReasoningEffort = normalizeProviderResponsesReasoningEffort(payload, providerConfig);
 	if (normalizedReasoningEffort) logger$2.debug(`Normalized reasoning effort from ${normalizedReasoningEffort.from} to ${normalizedReasoningEffort.to} based on the provider model configuration`);
@@ -12945,7 +13101,8 @@ async function handleProviderResponsesForProvider(c, options) {
 		type: "invalid_request_error"
 	} }, 400);
 	filterReasoningForTransport(payload, false);
-	if (applyResponsesApiContextManagement(payload, (providerConfig.name === "codex" ? getModels().data.find((model) => model.id === payload.model) : void 0)?.capabilities.limits.max_prompt_tokens, {
+	const model = providerConfig.name === "codex" ? getModels().data.find((model) => model.id === payload.model) : void 0;
+	if (applyResponsesApiContextManagement(payload, model?.capabilities.limits.max_prompt_tokens, {
 		compactThresholdRatio: .8,
 		source: "responses"
 	})) compactInputByLatestCompaction(payload);
@@ -13073,6 +13230,7 @@ const getResponsesEvents = (response, signal) => createResponsesSafeStream(creat
 //#endregion
 //#region src/routes/provider/responses/route.ts
 const providerResponsesRoutes = new Hono();
+providerResponsesRoutes.use(zstdDecompressionMiddleware);
 providerResponsesRoutes.post("/", async (c) => {
 	try {
 		const provider = c.req.param("provider") ?? "";
@@ -13330,6 +13488,7 @@ const getTrimmedHeader = (c, name) => {
 //#endregion
 //#region src/routes/responses/route.ts
 const responsesRoutes = new Hono();
+responsesRoutes.use(zstdDecompressionMiddleware);
 responsesRoutes.post("/", async (c) => {
 	try {
 		return await handleResponses(c);
@@ -13380,6 +13539,14 @@ tokenUsageRoute.get("/events", async (c) => {
 	return c.json(eventsPage);
 });
 //#endregion
+//#region src/routes/qoder/route.ts
+const qoderRoutes = new Hono();
+qoderRoutes.get("/usage", async (c) => {
+	const provider = getProviderConfig("qoder");
+	if (!provider || !isQoderSdkProvider(provider)) return c.json({ error: { message: "Builtin Qoder provider is not configured or is disabled" } }, 404);
+	return forwardQoder(provider, "/usage", { signal: c.req.raw.signal });
+});
+//#endregion
 //#region src/routes/usage/route.ts
 const usageRoute = new Hono();
 usageRoute.get("/", async (c) => {
@@ -13393,54 +13560,69 @@ usageRoute.get("/", async (c) => {
 });
 //#endregion
 //#region src/server.ts
-const server = new Hono();
-server.use(traceIdMiddleware);
-server.use(logger());
-server.use(cors());
-server.use("*", createAuthMiddleware({
-	allowUnauthenticatedPaths: [
-		"/",
-		"/usage-viewer",
-		"/usage-viewer/"
-	],
-	shouldSkipPath: (path) => path.startsWith("/admin/")
-}));
-server.use("/admin/*", createAuthMiddleware({
-	getApiKeys: getConfiguredAdminApiKeys,
-	allowUnauthenticatedPaths: [],
-	allowWhenNoApiKeys: false
-}));
-server.use(zstdDecompressionMiddleware);
-server.get("/", (c) => c.text("Server running"));
-server.get("/usage-viewer", (c) => {
-	const usageViewerFileUrl = new URL("../pages/index.html", import.meta.url);
-	return c.html(readFileSync(usageViewerFileUrl, "utf8"));
-});
-server.get("/usage-viewer/", (c) => c.redirect("/usage-viewer", 301));
-server.route("/chat/completions", completionRoutes);
-server.route("/admin/config", configRoutes);
-server.route("/models", modelRoutes);
-server.route("/embeddings", embeddingRoutes);
-server.route("/usage", usageRoute);
-server.route("/token-usage", tokenUsageRoute);
-server.route("/responses", responsesRoutes);
-server.route("/alpha/search", alphaSearchRoutes);
-server.route("/images", imageRoutes);
-server.route("/v1/chat/completions", completionRoutes);
-server.route("/v1/models", modelRoutes);
-server.route("/v1/embeddings", embeddingRoutes);
-server.route("/v1/responses", responsesRoutes);
-server.route("/v1/alpha/search", alphaSearchRoutes);
-server.route("/v1/images", imageRoutes);
-server.route("/v1/messages", messageRoutes);
-server.route("/:provider/v1/messages", providerMessageRoutes);
-server.route("/:provider/v1/models", providerModelRoutes);
-server.route("/:provider/v1/responses", providerResponsesRoutes);
-server.route("/:provider/v1/alpha/search", providerAlphaSearchRoutes);
-server.route("/:provider/v1/images", providerImageRoutes);
-server.route("/:provider/models", providerModelRoutes);
-server.route("/:provider/responses", providerResponsesRoutes);
-server.route("/:provider/alpha/search", providerAlphaSearchRoutes);
-server.route("/:provider/images", providerImageRoutes);
+function resolveSameOriginCorsOrigin(origin, context) {
+	if (!origin) return null;
+	try {
+		return origin === new URL(context.req.url).origin ? origin : null;
+	} catch {
+		return null;
+	}
+}
+function createServer(options = {}) {
+	const server = new Hono();
+	const networkExposed = options.networkExposed ?? false;
+	server.use(traceIdMiddleware);
+	server.use(logger());
+	server.use(networkExposed ? cors({ origin: resolveSameOriginCorsOrigin }) : cors());
+	server.use("*", createAuthMiddleware({
+		getApiKeys: options.getApiKeys,
+		allowUnauthenticatedPaths: [
+			"/",
+			"/usage-viewer",
+			"/usage-viewer/"
+		],
+		shouldSkipPath: (path) => path.startsWith("/admin/"),
+		allowWhenNoApiKeys: !networkExposed
+	}));
+	server.use("/admin/*", createAuthMiddleware({
+		getApiKeys: getConfiguredAdminApiKeys,
+		allowUnauthenticatedPaths: [],
+		allowWhenNoApiKeys: false
+	}));
+	server.get("/", (c) => c.text("Server running"));
+	server.get("/usage-viewer", (c) => {
+		const usageViewerFileUrl = new URL("../pages/index.html", import.meta.url);
+		return c.html(readFileSync(usageViewerFileUrl, "utf8"));
+	});
+	server.get("/usage-viewer/", (c) => c.redirect("/usage-viewer", 301));
+	server.route("/chat/completions", completionRoutes);
+	server.route("/admin/config", configRoutes);
+	server.route("/models", modelRoutes);
+	server.route("/embeddings", embeddingRoutes);
+	server.route("/usage", usageRoute);
+	server.route("/qoder", qoderRoutes);
+	server.route("/token-usage", tokenUsageRoute);
+	server.route("/responses", responsesRoutes);
+	server.route("/alpha/search", alphaSearchRoutes);
+	server.route("/images", imageRoutes);
+	server.route("/v1/chat/completions", completionRoutes);
+	server.route("/v1/models", modelRoutes);
+	server.route("/v1/embeddings", embeddingRoutes);
+	server.route("/v1/responses", responsesRoutes);
+	server.route("/v1/alpha/search", alphaSearchRoutes);
+	server.route("/v1/images", imageRoutes);
+	server.route("/v1/messages", messageRoutes);
+	server.route("/:provider/v1/messages", providerMessageRoutes);
+	server.route("/:provider/v1/models", providerModelRoutes);
+	server.route("/:provider/v1/responses", providerResponsesRoutes);
+	server.route("/:provider/v1/alpha/search", providerAlphaSearchRoutes);
+	server.route("/:provider/v1/images", providerImageRoutes);
+	server.route("/:provider/models", providerModelRoutes);
+	server.route("/:provider/responses", providerResponsesRoutes);
+	server.route("/:provider/alpha/search", providerAlphaSearchRoutes);
+	server.route("/:provider/images", providerImageRoutes);
+	return server;
+}
+createServer();
 //#endregion
-export { server };
+export { createServer };