@nick3/copilot-api 1.10.29 → 1.10.34

package/dist/{server-DJ3_UGc4.js → server-C7pCkArb.js}

@@ -1,12 +1,13 @@
 import { A as accountFromState, B as compactSystemPromptStarts, C as copilotHeaders, D as prepareForCompact, E as normalizeDomain, F as resolveTraceId, L as compactAutoContinuePromptStarts, M as captureOutboundHeadersSnapshot, O as prepareInteractionHeaders, P as requestContext, R as compactMessageSections, S as copilotBaseUrl, T as copilotWebSocketHeaders, b as HTTPError, c as getUUID, d as parseUserIdMetadata, f as resolveAffinityKey, g as getCopilotUsage, h as getDeviceCode, j as state, k as prepareMessageProxyHeaders, l as isNullish, m as getGitHubUser, o as generateRequestIdFromPayload, p as sleep, s as getRootSessionId, t as pollAccessToken, u as normalizeStableSessionId, v as getProxyEnvDispatcher, x as forwardError } from "./poll-access-token-GzVkiTH8.js";
 import { a as getAccountClientIdentityByLoginAndApp, b as getCurrentIdentityEnvironment, d as loadRegistry, g as saveRegistry, h as saveAccountToken, l as listAccountsFromRegistry, m as removeAccountToken, p as removeAccountFromRegistry, r as addAccountToRegistry, t as isAccountType } from "./account-DpW8RaT6.js";
 import { r as ensurePaths, t as PATHS } from "./paths-Bpsb62LK.js";
-import { C as isResponsesApiWebSocketEnabled, E as resolveModelAlias, O as shouldCompactUseSmallModel, S as isResponsesApiWebSearchEnabled, T as mergeConfigWithDefaults, _ as isAccountAffinityEnabled, a as getConfig, b as isMessagesApiEnabled, c as getModelAliases, d as getProviderConfig, g as getSmallModel, i as getClaudeTokenMultiplier, l as getModelAliasesInfo, m as getReasoningEffortForModel, n as getAliasTargetSet, o as getExtraPromptForModel, r as getAnthropicApiKey, s as getLogLevel, t as PROVIDER_TYPE_ANTHROPIC, u as getModelRefreshIntervalMs, v as isForceAgentEnabled, x as isResponsesApiContextManagementEnabled, y as isMessageStartInputTokensFallbackEnabled } from "./config-CmhIPHn_.js";
+import { A as shouldCompactUseSmallModel, C as isResponsesApiWebSearchEnabled, D as resolveMappedModel, E as mergeConfigWithDefaults, O as resolveModelAlias, S as isResponsesApiContextManagementEnabled, _ as getSmallModel, a as getConfig, b as isMessageStartInputTokensFallbackEnabled, c as getModelAliases, d as getModelResponsesApiCompactThreshold$1, f as getProviderConfig, h as getReasoningEffortForModel, i as getClaudeTokenMultiplier, l as getModelAliasesInfo, m as getRawProviderConfig, n as getAliasTargetSet, o as getExtraPromptForModel, r as getAnthropicApiKey, s as getLogLevel, t as PROVIDER_TYPE_ANTHROPIC, u as getModelRefreshIntervalMs, v as isAccountAffinityEnabled, w as isResponsesApiWebSocketEnabled, x as isMessagesApiEnabled, y as isForceAgentEnabled } from "./config-BaU_aWgi.js";
+import { a as forwardCodexResponses, n as setupCodexToken } from "./token-671YFxgv.js";
 import { i as getRequestOutboundStore, r as getRedactedHeaderKeys } from "./request-outbound-DZTxxtcx.js";
 import { i as isMcpHttpEnabledFromEnv, n as DEFAULT_MCP_HTTP_PATH } from "./mcp-http-config-DMdUDz1D.js";
 import { a as isDeferredToolName, c as parseMcpToolSearchSentinel, i as isBridgeToolSearchName, l as selectDeferredToolsByNames, n as BRIDGE_TOOL_SEARCH_NAME, o as listDeferredToolNames, r as formatToolSearchBridgeArguments, s as normalizeToolSearchBridgeArguments, u as shouldEnableResponsesToolSearch } from "./mcp-server-DEqHrXFq.js";
 import { n as handleStreamableHttpMcpRequest, r as mcpHttpCorsOptions } from "./mcp-http-DI4Vz01p.js";
-import { S as createAuthMiddleware, _ as normalizeMessagesUsage, b as flushPendingCapture, c as accountsManager, d as extractResponsesUsageFromStreamEvent, f as getClientIpInfo, g as normalizeEmbeddingsUsage, h as normalizeChatCompletionsUsage, l as applySharedSessionAffinityRetention, m as getStatsStore, p as getRequestHistoryStore, s as updateQuotaRefreshSchedulerFromConfig, t as closeResponsesBridge, u as extractResponsesUsageFromResult, v as toLocalDateString, x as isDevModeEnabled, y as copilotFetch } from "./responses-bridge-registry-BJ5Sbh6-.js";
+import { C as createAuthMiddleware, S as isDevModeEnabled, _ as normalizeMessagesUsage, b as copilotFetch, c as accountsManager, d as extractResponsesUsageFromStreamEvent, f as getClientIpInfo, g as normalizeEmbeddingsUsage, h as normalizeChatCompletionsUsage, l as applySharedSessionAffinityRetention, m as getStatsStore, p as getRequestHistoryStore, s as updateQuotaRefreshSchedulerFromConfig, t as closeResponsesBridge, u as extractResponsesUsageFromResult, v as normalizeResponsesUsage, x as flushPendingCapture, y as toLocalDateString } from "./responses-bridge-registry-DqCoY6Ex.js";
 import consola from "consola";
 import fs, { readFile } from "node:fs/promises";
 import { createHash, randomUUID } from "node:crypto";
@@ -953,6 +954,44 @@ const stripCacheControl = (payload) => {
 		}
 	}
 };
+const normalizeCacheControl = (cacheControl) => {
+	if (!cacheControl || typeof cacheControl !== "object" || Array.isArray(cacheControl)) return;
+	const type = cacheControl.type;
+	return type === "ephemeral" ? { type } : void 0;
+};
+const applyTopLevelCacheControl = (payload) => {
+	const topLevel = normalizeCacheControl(payload.cache_control);
+	if (!topLevel) {
+		if (payload.cache_control !== void 0) delete payload.cache_control;
+		return;
+	}
+	delete payload.cache_control;
+	for (let m = payload.messages.length - 1; m >= 0; m--) {
+		const message = payload.messages[m];
+		if (typeof message.content === "string") {
+			message.content = [{
+				type: "text",
+				text: message.content,
+				cache_control: { ...topLevel }
+			}];
+			return;
+		}
+		if (!Array.isArray(message.content)) continue;
+		for (let b = message.content.length - 1; b >= 0; b--) {
+			const block = message.content[b];
+			if (block.type !== "text" && block.type !== "image" && block.type !== "tool_use" && block.type !== "tool_result") continue;
+			block.cache_control ??= { ...topLevel };
+			return;
+		}
+	}
+};
+const stripToolEagerInputStreaming = (payload) => {
+	if (!payload.tools || payload.tools.length === 0) return;
+	for (const tool of payload.tools) {
+		const extended = tool;
+		if ("eager_input_streaming" in extended) delete extended.eager_input_streaming;
+	}
+};
 const filterAssistantThinkingBlocks = (payload) => {
 	for (const msg of payload.messages) if (msg.role === "assistant" && Array.isArray(msg.content)) msg.content = msg.content.filter((block) => {
 		if (block.type !== "thinking") return true;
@@ -961,6 +1000,8 @@ const filterAssistantThinkingBlocks = (payload) => {
 };
 const prepareMessagesApiPayload = (payload, selectedModel) => {
 	stripCacheControl(payload);
+	applyTopLevelCacheControl(payload);
+	stripToolEagerInputStreaming(payload);
 	filterAssistantThinkingBlocks(payload);
 	const hasThinking = Boolean(payload.thinking);
 	const toolChoice = payload.tool_choice;
@@ -2499,13 +2540,22 @@ adminApiRoutes.get("/accounts", async (c) => {
 				unlimited: s.unlimited,
 				failed: s.failed,
 				failureReason: s.failureReason,
-				enabled: s.enabled
+				enabled: s.enabled,
+				lastModelsFetch: s.lastModelsFetch,
+				isRefreshingModels: s.isRefreshingModels
 			},
 			stats
 		};
 	});
 	return c.json({ items });
 });
+adminApiRoutes.post("/accounts/models/refresh", async (c) => {
+	const { failedCount } = await accountsManager.refreshAllModelsNow();
+	return c.json({
+		ok: true,
+		failedCount
+	});
+});
 adminApiRoutes.get("/requests", (c) => {
 	const p = new URL(c.req.url, "http://local").searchParams;
 	const limit = parseFiniteNumber(p.get("limit")) ?? 50;
@@ -3736,6 +3786,41 @@ const createHandlerLogger = (name) => {
 	return instance;
 };
 //#endregion
+//#region src/lib/provider-model.ts
+const parseProviderModelAlias = (model) => {
+	const separatorIndex = model.indexOf("/");
+	if (separatorIndex <= 0 || separatorIndex === model.length - 1) return null;
+	const provider = model.slice(0, separatorIndex).trim();
+	const providerModel = model.slice(separatorIndex + 1).trim();
+	if (!provider || !providerModel) return null;
+	return {
+		model: providerModel,
+		provider
+	};
+};
+const resolveExistingProviderModelAlias = (model, resolveProvider) => {
+	const alias = parseProviderModelAlias(model);
+	if (!alias) return null;
+	return resolveProvider(alias.provider) ? alias : null;
+};
+const createFallbackModel = (modelId) => ({
+	capabilities: {
+		family: "provider",
+		limits: {},
+		object: "model_capabilities",
+		supports: {},
+		tokenizer: "o200k_base",
+		type: "chat"
+	},
+	id: modelId,
+	model_picker_enabled: false,
+	name: modelId,
+	object: "model",
+	preview: false,
+	vendor: "provider",
+	version: "unknown"
+});
+//#endregion
 //#region src/lib/rate-limit.ts
 async function checkRateLimit(state) {
 	if (state.rateLimitSeconds === void 0) return;
@@ -3761,6 +3846,210 @@ async function checkRateLimit(state) {
 	consola.info("Rate limit wait completed, proceeding with request");
 }
 //#endregion
+//#region src/lib/provider-resolver.ts
+function isMissingCodexCredentialsError(error) {
+	return error instanceof Error && error.message === "Codex credentials not found. Run `copilot-api auth login --provider codex` first.";
+}
+async function resolveProviderConfig$3(providerName) {
+	const normalizedProviderName = providerName.trim();
+	if (!normalizedProviderName) return null;
+	if (normalizedProviderName === "codex") {
+		if (getRawProviderConfig(normalizedProviderName)?.enabled === false) return null;
+		try {
+			await setupCodexToken();
+		} catch (error) {
+			if (isMissingCodexCredentialsError(error)) return null;
+			throw error;
+		}
+		const providerConfig = getProviderConfig(normalizedProviderName);
+		if (!providerConfig) return null;
+		return {
+			...providerConfig,
+			apiKey: state.codexAccessToken ?? providerConfig.apiKey
+		};
+	}
+	return getProviderConfig(normalizedProviderName);
+}
+//#endregion
+//#region src/lib/token-usage.ts
+function normalizeOpenAIUsage$1(usage) {
+	const cacheCreationInputTokens = usage?.prompt_tokens_details?.cache_creation_input_tokens;
+	const cacheReadInputTokens = usage?.prompt_tokens_details?.cached_tokens;
+	return {
+		inputTokens: usage?.prompt_tokens === void 0 ? void 0 : Math.max(0, usage.prompt_tokens - (cacheCreationInputTokens ?? 0) - (cacheReadInputTokens ?? 0)),
+		outputTokens: usage?.completion_tokens,
+		cacheCreationInputTokens,
+		cacheReadInputTokens
+	};
+}
+function createProviderTokenUsageRecorder(options) {
+	const logger = createHandlerLogger(`provider-${options.providerName}`);
+	return (usage) => {
+		logger.debug(`${options.endpoint} usage`, {
+			model: options.model,
+			provider: options.providerName,
+			...usage
+		});
+	};
+}
+//#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;
+}
+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, fetchImpl = fetch) {
+	return await fetchImpl(`${providerConfig.baseUrl}/v1/messages`, {
+		method: "POST",
+		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders),
+		body: JSON.stringify(payload)
+	});
+}
+async function forwardProviderChatCompletions(providerConfig, payload, requestHeaders, fetchImpl = fetch) {
+	return await fetchImpl(`${providerConfig.baseUrl}/v1/chat/completions`, {
+		method: "POST",
+		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders),
+		body: JSON.stringify(payload)
+	});
+}
+async function forwardProviderResponses(providerConfig, payload, requestHeaders) {
+	return await fetch(`${providerConfig.baseUrl}/v1/responses`, {
+		method: "POST",
+		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders),
+		body: JSON.stringify(payload)
+	});
+}
+async function forwardProviderModels(providerConfig, requestHeaders, fetchImpl = fetch) {
+	return await fetchImpl(`${providerConfig.baseUrl}/v1/models`, {
+		method: "GET",
+		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders)
+	});
+}
+//#endregion
+//#region src/routes/provider/chat-completions/handler.ts
+const logger$8 = createHandlerLogger("provider-chat-completions-handler");
+async function handleProviderChatCompletionsForProvider(c, options) {
+	const { payload, provider } = options;
+	const providerConfig = await (c.get("providerConfigResolver") ?? resolveProviderConfig$3)(provider);
+	if (providerConfig?.type !== "openai-compatible") return c.json({ error: {
+		message: `Provider '${provider}' does not support the /v1/chat/completions endpoint`,
+		type: "invalid_request_error"
+	} }, 400);
+	const modelConfig = providerConfig.models?.[payload.model];
+	applyProviderModelDefaults(payload, modelConfig);
+	applyMissingExtraBody$1(payload, { extraBody: modelConfig?.extraBody });
+	applyProviderStreamOptions(payload);
+	debugJson(logger$8, "provider.chat_completions.request", {
+		payload,
+		provider
+	});
+	const upstreamResponse = await forwardProviderChatCompletions(providerConfig, payload, c.req.raw.headers);
+	if (!upstreamResponse.ok) {
+		logger$8.error("Failed to create provider chat completions", {
+			provider,
+			statusCode: upstreamResponse.status
+		});
+		throw new HTTPError(`Failed to create ${provider} chat completions`, upstreamResponse);
+	}
+	const recordUsage = createProviderChatCompletionsUsageRecorder(payload, provider);
+	const contentType = upstreamResponse.headers.get("content-type") ?? "";
+	if (Boolean(payload.stream) && contentType.includes("text/event-stream")) return streamProviderChatCompletions(c, upstreamResponse, {
+		provider,
+		recordUsage
+	});
+	const responseBody = await upstreamResponse.clone().json();
+	recordUsage(normalizeOpenAIUsage$1(responseBody.usage));
+	debugJson(logger$8, "provider.chat_completions.response", responseBody);
+	return createProviderProxyResponse(upstreamResponse);
+}
+const applyProviderModelDefaults = (payload, modelConfig) => {
+	payload.temperature ??= modelConfig?.temperature;
+	payload.top_p ??= modelConfig?.topP;
+	payload.top_k ??= modelConfig?.topK;
+};
+const applyMissingExtraBody$1 = (payload, options) => {
+	for (const [key, value] of Object.entries(options.extraBody ?? {})) if (!Object.hasOwn(payload, key)) payload[key] = value;
+};
+const applyProviderStreamOptions = (payload) => {
+	if (!payload.stream) return;
+	payload.stream_options = {
+		...payload.stream_options ?? {},
+		include_usage: true
+	};
+};
+const createProviderChatCompletionsUsageRecorder = (payload, provider) => createProviderTokenUsageRecorder({
+	endpoint: "chat_completions",
+	model: payload.model,
+	providerName: provider
+});
+const streamProviderChatCompletions = (c, upstreamResponse, options) => {
+	logger$8.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$8, "provider.chat_completions.stream_chunk", chunk);
+				if (chunk.data && chunk.data !== "[DONE]") {
+					const parsedChunk = parseChatCompletionChunkData(chunk.data);
+					if (parsedChunk?.usage) usage = normalizeOpenAIUsage$1(parsedChunk.usage);
+				}
+				await stream.writeSSE({
+					event: chunk.event,
+					data: chunk.data ?? ""
+				});
+			}
+		} finally {
+			options.recordUsage(usage);
+		}
+	});
+};
+const parseChatCompletionChunkData = (data) => {
+	try {
+		return JSON.parse(data);
+	} catch {
+		return null;
+	}
+};
+//#endregion
 //#region src/routes/chat-completions/support.ts
 const CHAT_COMPLETIONS_ENDPOINT$1 = "/chat/completions";
 const GPT_5_4_MODEL_ID = "gpt-5.4";
@@ -3870,7 +4159,7 @@ function selectionFailureResponse$2(c, params) {
 }
 //#endregion
 //#region src/routes/chat-completions/handler.ts
-const logger$6 = createHandlerLogger("chat-completions-handler");
+const logger$7 = createHandlerLogger("chat-completions-handler");
 function buildChatCompletionCandidates(clientModel) {
 	return [{
 		modelId: clientModel,
@@ -3905,10 +4194,21 @@ function maybeRejectChatCompletionsClientModel(c, store, params) {
 	return null;
 }
 async function handleCompletion$1(c) {
+	const payload = await c.req.json();
+	const mappedModelResolver = c.get("resolveMappedModel") ?? resolveMappedModel;
+	const providerConfigResolver = c.get("providerConfigResolver") ?? getProviderConfig;
+	payload.model = mappedModelResolver(payload.model);
+	const providerModelAlias = resolveExistingProviderModelAlias(payload.model, providerConfigResolver);
+	if (providerModelAlias) {
+		payload.model = providerModelAlias.model;
+		return await handleProviderChatCompletionsForProvider(c, {
+			payload,
+			provider: providerModelAlias.provider
+		});
+	}
 	await checkRateLimit(state);
 	const store = getRequestHistoryStore();
 	const request = buildRequestContext$1(c);
-	const payload = await c.req.json();
 	const clientModel = payload.model;
 	const streamRequested = Boolean(payload.stream);
 	const normalizedPromptCacheKey = applyChatRequestMetadata(request, payload, getChatInitiator(payload.messages));
@@ -4007,12 +4307,12 @@ async function writeChatCompletionsStreamError(stream, message) {
 		} }) });
 		await stream.writeSSE({ data: "[DONE]" });
 	} catch (streamError) {
-		logger$6.warn("Failed to write chat completions stream error event:", streamError);
+		logger$7.warn("Failed to write chat completions stream error event:", streamError);
 	}
 }
 async function selectChatCompletionAccount(params) {
 	const { c, store, request, payload, clientModel, streamRequested, normalizedPromptCacheKey } = params;
-	debugJsonTail(logger$6, "Request payload:", {
+	debugJsonTail(logger$7, "Request payload:", {
 		value: payload,
 		tailLength: 400
 	});
@@ -4047,9 +4347,9 @@ async function selectChatCompletionAccount(params) {
 async function logTokenCountForRequest(params) {
 	try {
 		const tokenCount = await getTokenCount(params.payload, params.selectedModel);
-		logger$6.info("Current token count:", tokenCount);
+		logger$7.info("Current token count:", tokenCount);
 	} catch (error) {
-		logger$6.warn("Failed to calculate token count:", error);
+		logger$7.warn("Failed to calculate token count:", error);
 	}
 }
 function applyDefaultMaxTokens(payload, selectedModel) {
@@ -4058,7 +4358,7 @@ function applyDefaultMaxTokens(payload, selectedModel) {
 		...payload,
 		max_tokens: selectedModel.capabilities.limits.max_output_tokens
 	};
-	debugJson(logger$6, "Set max_tokens to:", updated.max_tokens);
+	debugJson(logger$7, "Set max_tokens to:", updated.max_tokens);
 	return updated;
 }
 async function handleStreamingRequest(params) {
@@ -4092,7 +4392,7 @@ async function handleStreamingRequest(params) {
 		premiumUnlimitedBefore,
 		response
 	});
-	logger$6.debug("Streaming response");
+	logger$7.debug("Streaming response");
 	return streamSSE(c, (stream) => streamChatCompletionsAndLog$1({
 		stream,
 		response,
@@ -4147,7 +4447,7 @@ async function handleNonStreamingUpstreamResponse(params) {
 	let upstreamErrorMessageRaw;
 	const finishedAtMs = Date.now();
 	try {
-		debugJson(logger$6, "Non-streaming response:", response);
+		debugJson(logger$7, "Non-streaming response:", response);
 		return c.json(response);
 	} catch (error) {
 		const details = await extractErrorObservability(error);
@@ -4200,7 +4500,7 @@ async function streamChatCompletionsAndLog$1(params) {
 			if (ttfbMs === void 0) ttfbMs = Date.now() - request.startedAtMs;
 			const usage = await extractUsageFromChunk(chunk);
 			if (usage) lastUsage = usage;
-			debugJson(logger$6, "Streaming chunk:", chunk);
+			debugJson(logger$7, "Streaming chunk:", chunk);
 			await stream.writeSSE(chunk);
 		}
 	} catch (error) {
@@ -4209,7 +4509,7 @@ async function streamChatCompletionsAndLog$1(params) {
 		errorStatus = details.errorStatus;
 		errorMessage = details.errorMessage;
 		upstreamErrorMessageRaw = details.upstreamErrorMessageRaw;
-		logger$6.warn("Streaming error:", error);
+		logger$7.warn("Streaming error:", error);
 		if (shouldMarkAccountFailed(details)) accountsManager.markAccountFailed(account.id, "Unauthorized (401)");
 		await writeChatCompletionsStreamError(stream, getUserVisibleErrorMessage(details));
 	} finally {
@@ -4247,7 +4547,7 @@ async function extractUsageFromChunk(chunk) {
 	try {
 		data = typeof chunk.data === "string" ? chunk.data : await chunk.data;
 	} catch (error) {
-		logger$6.warn("Failed to read chat completions usage chunk:", error);
+		logger$7.warn("Failed to read chat completions usage chunk:", error);
 		return;
 	}
 	if (!data || data === "[DONE]") return;
@@ -4256,7 +4556,7 @@ async function extractUsageFromChunk(chunk) {
 		if (!parsed.usage) return void 0;
 		return normalizeChatCompletionsUsage(parsed.usage);
 	} catch (error) {
-		logger$6.warn("Failed to parse chat completions usage chunk:", {
+		logger$7.warn("Failed to parse chat completions usage chunk:", {
 			error,
 			data
 		});
@@ -4283,7 +4583,7 @@ async function handleNonStreamingRequest(params) {
 		selection.confirmAffinity?.();
 		finishedAtMs = Date.now();
 		usage = normalizeChatCompletionsUsage(response.usage);
-		debugJson(logger$6, "Non-streaming response:", response);
+		debugJson(logger$7, "Non-streaming response:", response);
 		return c.json(response);
 	} catch (error) {
 		finishedAtMs = Date.now();
@@ -4505,43 +4805,8 @@ async function runEmbeddingsWithAccount({ c, store, ctx, payload, clientModel, s
 	}
 }
 //#endregion
-//#region src/lib/provider-model.ts
-const parseProviderModelAlias = (model) => {
-	const separatorIndex = model.indexOf("/");
-	if (separatorIndex <= 0 || separatorIndex === model.length - 1) return null;
-	const provider = model.slice(0, separatorIndex).trim();
-	const providerModel = model.slice(separatorIndex + 1).trim();
-	if (!provider || !providerModel) return null;
-	return {
-		model: providerModel,
-		provider
-	};
-};
-const resolveExistingProviderModelAlias = (model, resolveProvider) => {
-	const alias = parseProviderModelAlias(model);
-	if (!alias) return null;
-	return resolveProvider(alias.provider) ? alias : null;
-};
-const createFallbackModel = (modelId) => ({
-	capabilities: {
-		family: "provider",
-		limits: {},
-		object: "model_capabilities",
-		supports: {},
-		tokenizer: "o200k_base",
-		type: "chat"
-	},
-	id: modelId,
-	model_picker_enabled: false,
-	name: modelId,
-	object: "model",
-	preview: false,
-	vendor: "provider",
-	version: "unknown"
-});
-//#endregion
 //#region src/routes/provider/messages/count-tokens-handler.ts
-const logger$5 = createHandlerLogger("provider-count-tokens-handler");
+const logger$6 = createHandlerLogger("provider-count-tokens-handler");
 const resolveProviderConfig$2 = (c, provider) => {
 	return (c.get("providerConfigResolver") ?? getProviderConfig)(provider);
 };
@@ -4573,14 +4838,14 @@ async function handleProviderCountTokensForProvider(c, options) {
 	try {
 		const tokenCount = await getTokenCount(translateToOpenAI(anthropicPayload, translationOptions), findEndpointModel(modelId) ?? createFallbackModel(modelId));
 		const finalTokenCount = tokenCount.input + tokenCount.output;
-		logger$5.debug("provider.count_tokens.success", {
+		logger$6.debug("provider.count_tokens.success", {
 			provider,
 			model: anthropicPayload.model,
 			input_tokens: finalTokenCount
 		});
 		return c.json({ input_tokens: finalTokenCount });
 	} catch (error) {
-		logger$5.error("provider.count_tokens.error", {
+		logger$6.error("provider.count_tokens.error", {
 			provider,
 			error
 		});
@@ -5035,7 +5300,11 @@ const consumeResponsesWebSocketStream = async (stream) => {
 	for await (const chunk of stream) {
 		if (!chunk.data || chunk.data === "[DONE]") continue;
 		const event = JSON.parse(chunk.data);
-		if (event.type === "error") throw new Error(event.message);
+		if (event.type === "error") {
+			const status = typeof event.code === "string" ? parseInt(event.code, 10) : NaN;
+			const httpStatus = Number.isFinite(status) && status >= 100 && status < 600 ? status : 500;
+			throw new HTTPError(event.message, new Response(JSON.stringify({ error: { message: event.message } }), { status: httpStatus }));
+		}
 		if (event.type === "response.completed" || event.type === "response.failed" || event.type === "response.incomplete") return event.response;
 	}
 	throw new Error("Responses websocket ended without a terminal response");
@@ -6015,73 +6284,8 @@ function closeThinkingBlockIfOpen(state, events) {
 	}
 }
 //#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;
-}
-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, fetchImpl = fetch) {
-	return await fetchImpl(`${providerConfig.baseUrl}/v1/messages`, {
-		method: "POST",
-		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders),
-		body: JSON.stringify(payload)
-	});
-}
-async function forwardProviderChatCompletions(providerConfig, payload, requestHeaders, fetchImpl = fetch) {
-	return await fetchImpl(`${providerConfig.baseUrl}/v1/chat/completions`, {
-		method: "POST",
-		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders),
-		body: JSON.stringify(payload)
-	});
-}
-async function forwardProviderModels(providerConfig, requestHeaders, fetchImpl = fetch) {
-	return await fetchImpl(`${providerConfig.baseUrl}/v1/models`, {
-		method: "GET",
-		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders)
-	});
-}
-//#endregion
 //#region src/routes/provider/messages/handler.ts
-const logger$4 = createHandlerLogger("provider-messages-handler");
+const logger$5 = createHandlerLogger("provider-messages-handler");
 const getProviderFetch$1 = (c) => c.get("providerFetch") ?? fetch;
 const resolveProviderConfig$1 = (c, provider) => {
 	return (c.get("providerConfigResolver") ?? getProviderConfig)(provider);
@@ -6107,7 +6311,7 @@ const writeProviderStreamError = async (stream, message) => {
 			})
 		});
 	} catch (error) {
-		logger$4.warn("Failed to write provider stream error event", error);
+		logger$5.warn("Failed to write provider stream error event", error);
 	}
 };
 async function handleProviderMessages(c) {
@@ -6136,7 +6340,7 @@ async function handleProviderMessagesForProvider(c, options) {
 	try {
 		const modelConfig = providerConfig.models?.[payload.model];
 		applyModelDefaults(payload, modelConfig);
-		debugJson(logger$4, "provider.messages.request", {
+		debugJson(logger$5, "provider.messages.request", {
 			payload,
 			provider
 		});
@@ -6150,7 +6354,7 @@ async function handleProviderMessagesForProvider(c, options) {
 		applyMissingExtraBody(payload, { extraBody: modelConfig?.extraBody });
 		const upstreamResponse = await forwardProviderMessages(providerConfig, payload, c.req.raw.headers, getProviderFetch$1(c));
 		if (!upstreamResponse.ok) {
-			logger$4.error("Failed to create responses", upstreamResponse);
+			logger$5.error("Failed to create responses", upstreamResponse);
 			throw new HTTPError("Failed to create responses", upstreamResponse);
 		}
 		const contentType = upstreamResponse.headers.get("content-type") ?? "";
@@ -6170,7 +6374,7 @@ async function handleProviderMessagesForProvider(c, options) {
 			providerConfig
 		});
 	} catch (error) {
-		logger$4.error("provider.messages.error", {
+		logger$5.error("provider.messages.error", {
 			provider,
 			error
 		});
@@ -6207,13 +6411,13 @@ const applyOpenAICompatibleExtraBodyThinkingBudget = (payload, options) => {
 const handleOpenAICompatibleProviderMessages = async (c, options) => {
 	const { instrumentation, modelConfig, payload, provider, providerConfig } = options;
 	const openAIPayload = createOpenAICompatiblePayload(payload, modelConfig);
-	debugJson(logger$4, "provider.messages.openai_compatible.request", {
+	debugJson(logger$5, "provider.messages.openai_compatible.request", {
 		payload: openAIPayload,
 		provider
 	});
 	const upstreamResponse = await forwardProviderChatCompletions(providerConfig, openAIPayload, c.req.raw.headers, getProviderFetch$1(c));
 	if (!upstreamResponse.ok) {
-		logger$4.error("Failed to create openai-compatible responses", upstreamResponse);
+		logger$5.error("Failed to create openai-compatible responses", upstreamResponse);
 		throw new HTTPError("Failed to create openai-compatible responses", upstreamResponse);
 	}
 	const contentType = upstreamResponse.headers.get("content-type") ?? "";
@@ -6297,13 +6501,13 @@ const setContextCacheControl = (part) => {
 	part.cache_control = { ...OPENAI_COMPATIBLE_CONTEXT_CACHE_CONTROL };
 };
 const streamProviderMessages = ({ c, instrumentation, providerConfig, upstreamResponse }) => {
-	logger$4.debug("provider.messages.streaming");
+	logger$5.debug("provider.messages.streaming");
 	return streamSSE(c, async (stream) => {
 		let usage = {};
 		try {
 			let completed = false;
 			for await (const chunk of events(upstreamResponse)) {
-				logger$4.debug("provider.messages.raw_stream_event:", chunk.data);
+				logger$5.debug("provider.messages.raw_stream_event:", chunk.data);
 				const eventName = chunk.event;
 				if (eventName === "ping") {
 					await stream.writeSSE({
@@ -6339,14 +6543,14 @@ const streamProviderMessages = ({ c, instrumentation, providerConfig, upstreamRe
 			instrumentation?.onComplete?.(usage);
 		} catch (error) {
 			const details = await extractErrorObservability(error);
-			logger$4.warn("provider.messages.streaming.error", error);
+			logger$5.warn("provider.messages.streaming.error", error);
 			instrumentation?.onError?.(details);
 			await writeProviderStreamError(stream, getUserVisibleErrorMessage(details));
 		}
 	});
 };
 const streamOpenAICompatibleProviderMessages = ({ c, instrumentation, upstreamResponse }) => {
-	logger$4.debug("provider.messages.openai_compatible.streaming");
+	logger$5.debug("provider.messages.openai_compatible.streaming");
 	return streamSSE(c, async (stream) => {
 		let usage = {};
 		const streamState = {
@@ -6359,7 +6563,7 @@ const streamOpenAICompatibleProviderMessages = ({ c, instrumentation, upstreamRe
 		try {
 			let completed = false;
 			for await (const chunk of events(upstreamResponse)) {
-				logger$4.debug("provider.messages.openai_compatible.raw_stream_event:", chunk.data);
+				logger$5.debug("provider.messages.openai_compatible.raw_stream_event:", chunk.data);
 				if (chunk.event === "ping") {
 					await stream.writeSSE({
 						event: "ping",
@@ -6377,7 +6581,7 @@ const streamOpenAICompatibleProviderMessages = ({ c, instrumentation, upstreamRe
 				const events = translateChunkToAnthropicEvents(parsed, streamState);
 				for (const event of events) {
 					const eventData = JSON.stringify(event);
-					debugLazy(logger$4, () => ["provider.messages.openai_compatible.translated_event:", eventData]);
+					debugLazy(logger$5, () => ["provider.messages.openai_compatible.translated_event:", eventData]);
 					await stream.writeSSE({
 						event: event.type,
 						data: eventData
@@ -6387,7 +6591,7 @@ const streamOpenAICompatibleProviderMessages = ({ c, instrumentation, upstreamRe
 			}
 			for (const event of flushPendingAnthropicStreamEvents(streamState)) {
 				const eventData = JSON.stringify(event);
-				debugLazy(logger$4, () => ["provider.messages.openai_compatible.translated_event:", eventData]);
+				debugLazy(logger$5, () => ["provider.messages.openai_compatible.translated_event:", eventData]);
 				await stream.writeSSE({
 					event: event.type,
 					data: eventData
@@ -6398,7 +6602,7 @@ const streamOpenAICompatibleProviderMessages = ({ c, instrumentation, upstreamRe
 			instrumentation?.onComplete?.(usage);
 		} catch (error) {
 			const details = await extractErrorObservability(error);
-			logger$4.warn("provider.messages.openai_compatible.streaming.error", error);
+			logger$5.warn("provider.messages.openai_compatible.streaming.error", error);
 			instrumentation?.onError?.(details);
 			await writeProviderStreamError(stream, getUserVisibleErrorMessage(details));
 		}
@@ -6409,7 +6613,7 @@ const parseOpenAICompatibleStreamChunk = (data) => {
 	try {
 		parsed = JSON.parse(data);
 	} catch (error) {
-		logger$4.error("provider.messages.openai_compatible.parse_chunk_error", {
+		logger$5.error("provider.messages.openai_compatible.parse_chunk_error", {
 			data,
 			error
 		});
@@ -6466,7 +6670,7 @@ const parseProviderStreamEvent = (data, providerConfig) => {
 			usage: {}
 		};
 	} catch (error) {
-		logger$4.error("provider.messages.streaming.adjust_tokens_error", {
+		logger$5.error("provider.messages.streaming.adjust_tokens_error", {
 			error,
 			originalData: data
 		});
@@ -6476,7 +6680,7 @@ const parseProviderStreamEvent = (data, providerConfig) => {
 const respondProviderMessagesJson = (c, options) => {
 	const { body, instrumentation, providerConfig } = options;
 	adjustInputTokens(providerConfig, body.usage);
-	debugJson(logger$4, "provider.messages.no_stream result:", body);
+	debugJson(logger$5, "provider.messages.no_stream result:", body);
 	const response = c.json(body);
 	instrumentation?.onComplete?.(normalizeAnthropicUsage(body.usage));
 	return response;
@@ -6484,7 +6688,7 @@ const respondProviderMessagesJson = (c, options) => {
 const respondOpenAICompatibleProviderMessagesJson = (c, options) => {
 	const { body, instrumentation } = options;
 	const anthropicResponse = translateToAnthropic(body);
-	debugJson(logger$4, "provider.messages.openai_compatible.no_stream result:", anthropicResponse);
+	debugJson(logger$5, "provider.messages.openai_compatible.no_stream result:", anthropicResponse);
 	const response = c.json(anthropicResponse);
 	instrumentation?.onComplete?.(normalizeOpenAIUsage(body.usage));
 	return response;
@@ -6514,7 +6718,7 @@ const mergeAnthropicUsage = (current, next) => ({
 const adjustInputTokens = (providerConfig, usage) => {
 	if (!providerConfig.adjustInputTokens || !usage) return;
 	usage.input_tokens = Math.max(0, (usage.input_tokens ?? 0) - (usage.cache_read_input_tokens ?? 0) - (usage.cache_creation_input_tokens ?? 0));
-	debugJson(logger$4, "provider.messages.adjusted_usage:", usage);
+	debugJson(logger$5, "provider.messages.adjusted_usage:", usage);
 };
 //#endregion
 //#region src/routes/messages/responses-stream-translation.ts
@@ -6991,6 +7195,7 @@ const stringifyToolSearchArguments = (argumentsValue) => {
 };
 const DEFAULT_RESPONSES_COMPACT_THRESHOLD_RATIO = .9;
 const responsesUtilsDependencies = {
+	getModelResponsesApiCompactThreshold: getModelResponsesApiCompactThreshold$1,
 	isResponsesApiContextManagementEnabled,
 	isResponsesApiWebSocketEnabled
 };
@@ -7021,7 +7226,8 @@ const isAgentRole = (item) => {
 const hasVisionInput$1 = (payload) => {
 	return getPayloadItems(payload).some((item) => containsVisionContent(item));
 };
-"" + [
+const DATA_URL_PREFIX = "data:";
+const REDACTED_IMAGE_PLACEHOLDER_DATA_URL = "data:image/png;base64," + [
 	"iVBORw0KGgoAAAANSUhEUgAAAGAAAAAgCAMAAADaHo1mAAADAFBMVEX///8fKTfR1dsAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
 	"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
 	"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
@@ -7038,10 +7244,71 @@ const hasVisionInput$1 = (payload) => {
 	"ucSQ4s8JkKDDIYr3IuR8vEWgqroKP9b1bYKk2wfgeVmqATQLXdXamsXdEKkz3QXEEeTTuWWImMhW6qci94/+hwSVf99HqVoD",
 	"OAuj2SEAAAAASUVORK5CYII="
 ].join("");
+const sanitizeOversizedInputImages = (payload, maxPromptImageSize) => {
+	const limit = typeof maxPromptImageSize === "number" && maxPromptImageSize > 0 ? maxPromptImageSize : void 0;
+	if (limit === void 0 || !Array.isArray(payload.input)) return 0;
+	return sanitizeInputImages(payload.input, (image) => image.decodedBytes > limit);
+};
+const sanitizeInputImages = (input, shouldReplace) => {
+	let count = 0;
+	for (const image of collectInputImageDataUrls(input)) {
+		if (!shouldReplace(image)) continue;
+		replaceInputImageWithPlaceholder(image);
+		count += 1;
+	}
+	return count;
+};
+const collectInputImageDataUrls = (input, images = []) => {
+	for (const item of input) collectInputItemImageDataUrls(item, images);
+	return images;
+};
+const collectInputItemImageDataUrls = (item, images) => {
+	if (isResponseInputMessage(item)) collectContentImageDataUrls(item.content, images);
+	else if (isResponseFunctionCallOutputItem(item)) collectContentImageDataUrls(item.output, images);
+};
+const collectContentImageDataUrls = (content, images) => {
+	if (!Array.isArray(content)) return;
+	for (const block of content) {
+		const image = getInputImageDataUrl(block);
+		if (image) images.push(image);
+	}
+};
+const getInputImageDataUrl = (content) => {
+	if (!isResponseInputImage(content) || typeof content.image_url !== "string") return null;
+	const imageUrl = content.image_url;
+	if (!imageUrl.startsWith(DATA_URL_PREFIX)) return null;
+	return {
+		decodedBytes: estimateDataUrlByteLength(imageUrl),
+		record: content
+	};
+};
+const estimateDataUrlByteLength = (value) => {
+	return Math.max(0, Math.floor(value.length * 3 / 4));
+};
+const replaceInputImageWithPlaceholder = (image) => {
+	image.record.type = "input_image";
+	image.record.image_url = REDACTED_IMAGE_PLACEHOLDER_DATA_URL;
+	image.record.detail = "low";
+	delete image.record.file_id;
+};
+const isResponseInputMessage = (item) => {
+	return typeof item === "object" && item !== null && "role" in item && typeof item.role === "string";
+};
+const isResponseFunctionCallOutputItem = (item) => {
+	return typeof item === "object" && item !== null && "type" in item && item.type === "function_call_output";
+};
+const isResponseInputImage = (content) => {
+	return typeof content === "object" && content !== null && "type" in content && content.type === "input_image";
+};
 const resolveResponsesCompactThreshold = (maxPromptTokens, compactThresholdRatio = DEFAULT_RESPONSES_COMPACT_THRESHOLD_RATIO) => {
 	if (typeof maxPromptTokens === "number" && maxPromptTokens > 0) return Math.floor(maxPromptTokens * compactThresholdRatio);
 	return 2e5 * compactThresholdRatio;
 };
+const getModelResponsesApiCompactThreshold = (model) => {
+	const threshold = responsesUtilsDependencies.getModelResponsesApiCompactThreshold(model);
+	if (typeof threshold !== "number" || !Number.isFinite(threshold) || threshold <= 0) return;
+	return threshold;
+};
 const createCompactionContextManagement = (compactThreshold) => [{
 	type: "compaction",
 	compact_threshold: compactThreshold
@@ -7049,7 +7316,7 @@ const createCompactionContextManagement = (compactThreshold) => [{
 const applyResponsesApiContextManagement = (payload, maxPromptTokens, compactThresholdRatio = DEFAULT_RESPONSES_COMPACT_THRESHOLD_RATIO) => {
 	if (payload.context_management !== void 0) return;
 	if (!responsesUtilsDependencies.isResponsesApiContextManagementEnabled()) return;
-	payload.context_management = createCompactionContextManagement(resolveResponsesCompactThreshold(maxPromptTokens, compactThresholdRatio));
+	payload.context_management = createCompactionContextManagement(getModelResponsesApiCompactThreshold(payload.model) ?? resolveResponsesCompactThreshold(maxPromptTokens, compactThresholdRatio));
 };
 const compactInputByLatestCompaction = (payload) => {
 	if (!Array.isArray(payload.input) || payload.input.length === 0) return;
@@ -7291,7 +7558,7 @@ const extractBalancedJson = (text) => {
 };
 //#endregion
 //#region src/routes/messages/handler.ts
-const logger$3 = createHandlerLogger("messages-handler");
+const logger$4 = createHandlerLogger("messages-handler");
 const CHAT_COMPLETIONS_ENDPOINT = "/chat/completions";
 const RESPONSES_ENDPOINT$1 = "/responses";
 const MESSAGES_ENDPOINT = "/v1/messages";
@@ -7337,7 +7604,7 @@ async function handleProviderAliasCompletion(c, options) {
 	let requestRecorded = false;
 	const insertProviderAliasLog = (record) => {
 		if (requestRecorded) {
-			logger$3.warn("provider alias request already recorded", { requestId });
+			logger$4.warn("provider alias request already recorded", { requestId });
 			return;
 		}
 		requestRecorded = true;
@@ -7412,14 +7679,14 @@ async function handleCompletion(c) {
 	const userAgent = c.req.header("user-agent") ?? void 0;
 	normalizeSystemMessages(anthropicPayload);
 	sanitizeIdeTools(anthropicPayload);
-	debugJson(logger$3, "Anthropic request payload:", anthropicPayload);
+	debugJson(logger$4, "Anthropic request payload:", anthropicPayload);
 	const markerInspection = inspectSubagentMarkerFromFirstUser(anthropicPayload);
 	const subagentMarker = markerInspection.kind === "valid" ? markerInspection.marker : null;
 	const isSubagentRequest = subagentMarker !== null;
 	const invalidSubagentMarkerSelectionReason = markerInspection.kind === "invalid" ? "subagent_marker_invalid_fallback" : void 0;
-	if (subagentMarker) debugJson(logger$3, "Detected Subagent marker:", subagentMarker);
+	if (subagentMarker) debugJson(logger$4, "Detected Subagent marker:", subagentMarker);
 	const sessionId = getRootSessionId(anthropicPayload, c);
-	logger$3.debug("Extracted session ID:", sessionId);
+	logger$4.debug("Extracted session ID:", sessionId);
 	const ownershipLookupSessionId = markerInspection.kind === "valid" ? normalizeStableSessionId(markerInspection.marker.session_id) : void 0;
 	const ownershipWriteSessionId = markerInspection.kind === "none" ? sessionId : void 0;
 	const anthropicBeta = c.req.header("anthropic-beta");
@@ -7427,7 +7694,7 @@ async function handleCompletion(c) {
 	const isCompact = compactType !== 0;
 	const originalRequestModel = anthropicPayload.model;
 	if (anthropicBeta && isWarmupProbeRequest(anthropicPayload)) anthropicPayload.model = getSmallModel();
-	if (compactType !== 0) logger$3.debug("Compact request type:", compactType);
+	if (compactType !== 0) logger$4.debug("Compact request type:", compactType);
 	const lastMessageCacheControl = getLastMessageContentCacheControl(anthropicPayload.messages.at(-1));
 	if (compactType === 1 && shouldCompactUseSmallModel()) anthropicPayload.model = getSmallModel();
 	if (compactType === 0) {
@@ -7436,7 +7703,7 @@ async function handleCompletion(c) {
 	}
 	applyLastMessageCacheControl(anthropicPayload, lastMessageCacheControl);
 	const upstreamRequestId = generateRequestIdFromPayload(anthropicPayload, sessionId);
-	logger$3.debug("Generated request ID:", upstreamRequestId);
+	logger$4.debug("Generated request ID:", upstreamRequestId);
 	const clientModel = anthropicPayload.model;
 	anthropicPayload.model = resolveModelAlias(anthropicPayload.model);
 	const routingModel = anthropicPayload.model;
@@ -7593,7 +7860,7 @@ async function handleCompletion(c) {
 }
 const handleWithChatCompletions = async (params) => {
 	const { c, openAIPayload, subagentMarker, sessionId, selectedModel, instr, compactType } = params;
-	debugJson(logger$3, "Translated OpenAI request payload:", openAIPayload);
+	debugJson(logger$4, "Translated OpenAI request payload:", openAIPayload);
 	const ctx = toAccountContext(instr.account);
 	const effectiveInitiator = resolveEffectiveInitiator(getChatInitiator(openAIPayload.messages), {
 		isCompact: compactType !== 0,
@@ -7624,9 +7891,9 @@ const handleWithChatCompletions = async (params) => {
 		response,
 		instr
 	});
-	logger$3.debug("Streaming response from Copilot");
+	logger$4.debug("Streaming response from Copilot");
 	const fallbackEnabled = isMessageStartInputTokensFallbackEnabled();
-	const estimatedInputTokens = fallbackEnabled ? await estimateInputTokens(openAIPayload, selectedModel, logger$3) : void 0;
+	const estimatedInputTokens = fallbackEnabled ? await estimateInputTokens(openAIPayload, selectedModel, logger$4) : void 0;
 	const historicalUsage = fallbackEnabled && instr.promptCacheKey && instr.safetyIdentifier ? instr.store.getLastCompletedUsageBySession({
 		promptCacheKey: instr.promptCacheKey,
 		safetyIdentifier: instr.safetyIdentifier,
@@ -7648,7 +7915,7 @@ const handleWithResponsesApi = async (params) => {
 	});
 	applyResponsesApiContextManagement(responsesPayload, selectedModel.capabilities.limits.max_prompt_tokens);
 	compactInputByLatestCompaction(responsesPayload);
-	debugJson(logger$3, "Translated Responses payload:", responsesPayload);
+	debugJson(logger$4, "Translated Responses payload:", responsesPayload);
 	const { vision, initiator } = getResponsesRequestOptions(responsesPayload);
 	const transport = getResponsesTransportForModel(selectedModel, { compactType }) ?? "http";
 	const effectiveInitiator = resolveEffectiveInitiator(initiator, {
@@ -7679,9 +7946,9 @@ const handleWithResponsesApi = async (params) => {
 		});
 	}
 	if (responsesPayload.stream && isAsyncIterable(response)) {
-		logger$3.debug("Streaming response from Copilot (Responses API)");
+		logger$4.debug("Streaming response from Copilot (Responses API)");
 		const fallbackEnabled = isMessageStartInputTokensFallbackEnabled();
-		const estimatedInputTokens = fallbackEnabled ? await estimateInputTokens(openAIPayload, selectedModel, logger$3) : void 0;
+		const estimatedInputTokens = fallbackEnabled ? await estimateInputTokens(openAIPayload, selectedModel, logger$4) : void 0;
 		const historicalUsage = fallbackEnabled && instr.promptCacheKey && instr.safetyIdentifier ? instr.store.getLastCompletedUsageBySession({
 			promptCacheKey: instr.promptCacheKey,
 			safetyIdentifier: instr.safetyIdentifier,
@@ -7779,9 +8046,9 @@ async function handleChatCompletionsNonStreaming(params) {
 	let upstreamErrorMessageRaw;
 	const finishedAtMs = Date.now();
 	try {
-		logger$3.debug("Non-streaming response from Copilot:", JSON.stringify(response));
+		logger$4.debug("Non-streaming response from Copilot:", JSON.stringify(response));
 		const anthropicResponse = translateToAnthropic(response);
-		debugJson(logger$3, "Translated Anthropic response:", anthropicResponse);
+		debugJson(logger$4, "Translated Anthropic response:", anthropicResponse);
 		return c.json(anthropicResponse);
 	} catch (error) {
 		const details = await extractErrorObservability(error);
@@ -7832,7 +8099,7 @@ async function streamChatCompletionsAndLog(params) {
 	try {
 		for await (const rawEvent of response) {
 			if (ttfbMs === void 0) ttfbMs = Date.now() - instr.startedAtMs;
-			logger$3.debug("Copilot raw stream event:", JSON.stringify(rawEvent));
+			logger$4.debug("Copilot raw stream event:", JSON.stringify(rawEvent));
 			const { data: rawData } = rawEvent;
 			const data = typeof rawData === "string" ? rawData : await rawData;
 			if (data === "[DONE]") break;
@@ -7841,7 +8108,7 @@ async function streamChatCompletionsAndLog(params) {
 			if (chunk.usage) lastUsage = normalizeChatCompletionsUsage(chunk.usage);
 			const events = translateChunkToAnthropicEvents(chunk, streamState);
 			for (const event of events) {
-				logger$3.debug("Translated Anthropic event:", JSON.stringify(event));
+				logger$4.debug("Translated Anthropic event:", JSON.stringify(event));
 				await stream.writeSSE({
 					event: event.type,
 					data: JSON.stringify(event)
@@ -7854,7 +8121,7 @@ async function streamChatCompletionsAndLog(params) {
 		errorStatus = details.errorStatus;
 		errorMessage = details.errorMessage;
 		upstreamErrorMessageRaw = details.upstreamErrorMessageRaw;
-		logger$3.warn("Streaming error:", error);
+		logger$4.warn("Streaming error:", error);
 		if (shouldMarkAccountFailed(details)) accountsManager.markAccountFailed(instr.account.id, "Unauthorized (401)");
 		await writeAnthropicStreamError(stream, getUserVisibleErrorMessage(details));
 	} finally {
@@ -7915,9 +8182,9 @@ async function handleResponsesNonStreaming(params) {
 		usage = extractResponsesUsageFromResult(result);
 		const responseOwnerKeys = extractResponsesResultOwnerKeys(result);
 		instr.responsesItemOwnerRecordedKeys = responseOwnerKeys;
-		logger$3.debug("Non-streaming Responses result:", JSON.stringify(result).slice(-400));
+		logger$4.debug("Non-streaming Responses result:", JSON.stringify(result).slice(-400));
 		const anthropicResponse = translateResponsesResultToAnthropic(result);
-		debugJson(logger$3, "Translated Anthropic response:", anthropicResponse);
+		debugJson(logger$4, "Translated Anthropic response:", anthropicResponse);
 		const response = c.json(anthropicResponse);
 		if (result.status === "completed") accountsManager.recordResponsesItemOwnership(responseOwnerKeys, instr.account.id);
 		return response;
@@ -7951,7 +8218,7 @@ async function handleResponsesNonStreaming(params) {
 async function ensureResponsesStreamCompleted(params) {
 	const { stream, streamState, setStreamError } = params;
 	if (streamState.messageCompleted) return;
-	logger$3.warn("Responses stream ended without completion; sending error event");
+	logger$4.warn("Responses stream ended without completion; sending error event");
 	const msg = "Responses stream ended without completion";
 	const errorEvent = buildErrorEvent(msg);
 	setStreamError("StreamIncomplete", msg);
@@ -7968,7 +8235,7 @@ async function writeAnthropicStreamError(stream, message) {
 			data: JSON.stringify(errorEvent)
 		});
 	} catch (streamError) {
-		logger$3.warn("Failed to write Anthropic stream error event:", streamError);
+		logger$4.warn("Failed to write Anthropic stream error event:", streamError);
 	}
 }
 function collectResponsesStreamOwnerKeys(event, responseOwnerKeys) {
@@ -8011,7 +8278,7 @@ function getResponsesStreamEventError(event) {
 async function writeTranslatedAnthropicStreamEvents(stream, events) {
 	for (const event of events) {
 		const eventData = JSON.stringify(event);
-		logger$3.debug("Translated Anthropic event:", eventData);
+		logger$4.debug("Translated Anthropic event:", eventData);
 		await stream.writeSSE({
 			event: event.type,
 			data: eventData
@@ -8040,7 +8307,7 @@ async function streamResponsesAndLog$1(params) {
 			}
 			const data = chunk.data;
 			if (!data) continue;
-			logger$3.debug("Responses raw stream event:", data);
+			logger$4.debug("Responses raw stream event:", data);
 			const parsed = JSON.parse(data);
 			const streamEventError = getResponsesStreamEventError(parsed);
 			if (streamEventError) {
@@ -8054,7 +8321,7 @@ async function streamResponsesAndLog$1(params) {
 			if (u.usageJson) lastUsage = u;
 			await writeTranslatedAnthropicStreamEvents(stream, translateResponsesStreamEvent(parsed, streamState));
 			if (streamState.messageCompleted) {
-				logger$3.debug("Message completed, ending stream");
+				logger$4.debug("Message completed, ending stream");
 				break;
 			}
 		}
@@ -8073,7 +8340,7 @@ async function streamResponsesAndLog$1(params) {
 		errorStatus = details.errorStatus;
 		errorMessage = details.errorMessage;
 		upstreamErrorMessageRaw = details.upstreamErrorMessageRaw;
-		logger$3.warn("Streaming error:", error);
+		logger$4.warn("Streaming error:", error);
 		invalidateAffinityOnOwnershipMismatch(details.ownershipMismatch, instr);
 		if (shouldMarkAccountFailed(details)) accountsManager.markAccountFailed(instr.account.id, "Unauthorized (401)");
 		await writeAnthropicStreamError(stream, getUserVisibleErrorMessage(details));
@@ -8128,7 +8395,7 @@ async function handleMessagesNonStreaming(params) {
 	let upstreamErrorMessageRaw;
 	const finishedAtMs = Date.now();
 	try {
-		logger$3.debug("Non-streaming Messages result:", JSON.stringify(response).slice(-400));
+		logger$4.debug("Non-streaming Messages result:", JSON.stringify(response).slice(-400));
 		return c.json(response);
 	} catch (error) {
 		const details = await extractErrorObservability(error);
@@ -8165,7 +8432,7 @@ const parseMessagesStreamUsage = (data) => {
 		if (parsed.type !== "message_delta" || !parsed.usage) return null;
 		return normalizeMessagesUsage(parsed.usage);
 	} catch (error) {
-		logger$3.warn("Failed to parse messages stream event", error);
+		logger$4.warn("Failed to parse messages stream event", error);
 		throw new Error("Failed to parse messages stream event", { cause: error });
 	}
 };
@@ -8183,7 +8450,7 @@ async function streamMessagesAndLog(params) {
 			const eventNameRaw = rawEvent.event;
 			const eventName = typeof eventNameRaw === "string" && eventNameRaw.length > 0 ? eventNameRaw : "message";
 			const data = rawEvent.data ?? "";
-			logger$3.debug("Messages raw stream event:", data);
+			logger$4.debug("Messages raw stream event:", data);
 			const usage = parseMessagesStreamUsage(data);
 			if (usage) lastUsage = usage;
 			await stream.writeSSE({
@@ -8197,7 +8464,7 @@ async function streamMessagesAndLog(params) {
 		errorStatus = details.errorStatus;
 		errorMessage = details.errorMessage;
 		upstreamErrorMessageRaw = details.upstreamErrorMessageRaw;
-		logger$3.warn("Streaming error:", error);
+		logger$4.warn("Streaming error:", error);
 		if (shouldMarkAccountFailed(details)) accountsManager.markAccountFailed(instr.account.id, "Unauthorized (401)");
 		await writeAnthropicStreamError(stream, getUserVisibleErrorMessage(details));
 	} finally {
@@ -8223,7 +8490,7 @@ async function streamMessagesAndLog(params) {
 const handleWithMessagesApi = async (params) => {
 	const { c, anthropicPayload, anthropicBetaHeader, subagentMarker, sessionId, instr, selectedModel, compactType } = params;
 	prepareMessagesApiPayload(anthropicPayload, selectedModel);
-	debugJson(logger$3, "Translated Messages payload:", anthropicPayload);
+	debugJson(logger$4, "Translated Messages payload:", anthropicPayload);
 	const ctx = toAccountContext(instr.account);
 	const effectiveInitiator = resolveEffectiveInitiator(getMessagesInitiator(anthropicPayload), {
 		isCompact: compactType !== 0,
@@ -8251,7 +8518,7 @@ const handleWithMessagesApi = async (params) => {
 		});
 	}
 	if (isAsyncIterable(response)) {
-		logger$3.debug("Streaming response from Copilot (Messages API)");
+		logger$4.debug("Streaming response from Copilot (Messages API)");
 		return streamSSE(c, (stream) => streamMessagesAndLog({
 			stream,
 			response,
@@ -8416,7 +8683,7 @@ function getModels() {
 }
 //#endregion
 //#region src/routes/provider/models/route.ts
-const logger$2 = createHandlerLogger("provider-models-handler");
+const logger$3 = createHandlerLogger("provider-models-handler");
 const getProviderFetch = (c) => c.get("providerFetch") ?? fetch;
 const resolveProviderConfig = (c, provider) => {
 	return (c.get("providerConfigResolver") ?? getProviderConfig)(provider);
@@ -8439,13 +8706,13 @@ providerModelRoutes.get("/", async (c) => {
 			});
 		}
 		const upstreamResponse = await forwardProviderModels(providerConfig, c.req.raw.headers, getProviderFetch(c));
-		logger$2.debug("provider.models.response", {
+		logger$3.debug("provider.models.response", {
 			provider,
 			statusCode: upstreamResponse.status
 		});
 		return createProviderProxyResponse(upstreamResponse);
 	} catch (error) {
-		logger$2.error("provider.models.error", {
+		logger$3.error("provider.models.error", {
 			provider,
 			error
 		});
@@ -8453,6 +8720,141 @@ providerModelRoutes.get("/", async (c) => {
 	}
 });
 //#endregion
+//#region src/lib/codex-rate-limit.ts
+const codexRateLimitScopes = ["primary", "secondary"];
+const formatCodexRateLimitResetAt = (resetAt) => {
+	const date = /* @__PURE__ */ new Date(resetAt * 1e3);
+	return Number.isNaN(date.getTime()) ? String(resetAt) : date.toLocaleString();
+};
+const logCodexRateLimitsEvent = (event) => {
+	if (!event || typeof event !== "object") return;
+	const eventRecord = event;
+	if (eventRecord.type !== "codex.rate_limits") return;
+	const rateLimits = eventRecord.rate_limits;
+	if (!rateLimits || typeof rateLimits !== "object") return;
+	const planType = typeof eventRecord.plan_type === "string" ? eventRecord.plan_type : null;
+	const rateLimitRecord = rateLimits;
+	const allowed = typeof rateLimitRecord.allowed === "boolean" ? rateLimitRecord.allowed : null;
+	const limitReached = typeof rateLimitRecord.limit_reached === "boolean" ? rateLimitRecord.limit_reached : null;
+	for (const scope of codexRateLimitScopes) {
+		const window = rateLimitRecord[scope];
+		if (!isCodexRateLimitWindow(window)) continue;
+		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 isCodexRateLimitWindow = (value) => {
+	if (!value || typeof value !== "object") return false;
+	const record = value;
+	return typeof record.reset_after_seconds === "number" && typeof record.reset_at === "number" && typeof record.used_percent === "number" && typeof record.window_minutes === "number";
+};
+//#endregion
+//#region src/routes/provider/responses/handler.ts
+const logger$2 = createHandlerLogger("provider-responses-handler");
+async function handleProviderResponsesForProvider(c, options) {
+	const { payload, provider } = options;
+	debugJson(logger$2, "Responses request payload:", {
+		payload,
+		provider
+	});
+	const providerConfig = await resolveProviderConfig$3(provider);
+	if (providerConfig?.type !== "openai-responses") return c.json({ error: {
+		message: `Provider '${provider}' does not support the /v1/responses endpoint`,
+		type: "invalid_request_error"
+	} }, 400);
+	applyResponsesApiContextManagement(payload, (providerConfig.name === "codex" ? getModels().data.find((model) => model.id === payload.model) : void 0)?.capabilities.limits.max_prompt_tokens ?? 0, .8);
+	const contextManagement = payload.context_management;
+	debugJson(logger$2, "Translated Responses request payload:", {
+		contextManagement,
+		provider
+	});
+	compactInputByLatestCompaction(payload);
+	if (providerConfig.name === "codex") {
+		const upstreamResponse = await forwardCodexResponses(payload, c.req.raw.headers, providerConfig.baseUrl);
+		const recordUsage = createProviderResponsesUsageRecorder(payload, provider);
+		if (payload.stream && isResponsesStream(upstreamResponse)) return streamProviderResponses(c, upstreamResponse, {
+			normalizeCodex: true,
+			provider,
+			recordUsage
+		});
+		const responseBody = upstreamResponse;
+		recordUsage(normalizeResponsesUsage(responseBody.usage));
+		return c.json(responseBody);
+	}
+	const upstreamResponse = await forwardProviderResponses(providerConfig, payload, c.req.raw.headers);
+	if (!upstreamResponse.ok) throw new HTTPError(`Failed to create ${provider} responses`, upstreamResponse);
+	const recordUsage = createProviderResponsesUsageRecorder(payload, provider);
+	if (payload.stream) return streamProviderResponses(c, getResponsesEvents(upstreamResponse), {
+		normalizeCodex: false,
+		provider,
+		recordUsage
+	});
+	recordUsage(normalizeResponsesUsage((await upstreamResponse.clone().json()).usage));
+	return createProviderProxyResponse(upstreamResponse);
+}
+const createProviderResponsesUsageRecorder = (_payload, _provider) => {
+	return (_usage) => {};
+};
+const streamProviderResponses = (c, upstreamResponse, options) => {
+	return streamSSE(c, async (stream) => {
+		let usage = {};
+		try {
+			for await (const chunk of upstreamResponse) {
+				debugJson(logger$2, "Responses stream chunk:", chunk);
+				let responseChunk = chunk;
+				let event = null;
+				if (chunk.data && chunk.data !== "[DONE]") {
+					event = parseProviderResponsesStreamEvent(chunk.data, {
+						normalizeCodex: options.normalizeCodex,
+						provider: options.provider
+					});
+					if (event && options.normalizeCodex) responseChunk = {
+						...chunk,
+						data: JSON.stringify(event),
+						event: event.type
+					};
+				}
+				if (event) {
+					const nextUsage = getResponsesStreamEventUsage(event);
+					if (nextUsage) usage = nextUsage;
+				}
+				await stream.writeSSE({
+					data: responseChunk.data ?? "",
+					event: responseChunk.event
+				});
+			}
+		} finally {
+			options.recordUsage(usage);
+		}
+	});
+};
+const parseProviderResponsesStreamEvent = (data, options) => {
+	try {
+		const parsed = JSON.parse(data);
+		if (options.normalizeCodex) logCodexRateLimitsEvent(parsed);
+		return parsed;
+	} catch (error) {
+		logger$2.error("provider.responses.parse_chunk_error", {
+			provider: options.provider,
+			data,
+			error
+		});
+		return null;
+	}
+};
+const getResponsesStreamEventUsage = (event) => {
+	if (event.type === "response.completed" || event.type === "response.failed" || event.type === "response.incomplete") return normalizeResponsesUsage(event.response.usage);
+	return null;
+};
+const getResponsesEvents = (response) => events(response);
+const isResponsesStream = (value) => {
+	return Boolean(value) && typeof value[Symbol.asyncIterator] === "function";
+};
+//#endregion
 //#region src/routes/responses/stream-id-sync.ts
 const createStreamIdTracker = () => ({ outputItems: /* @__PURE__ */ new Map() });
 const fixStreamIds = (data, event, tracker) => {
@@ -8493,16 +8895,31 @@ const handleItemId = (parsed, tracker) => {
 const logger$1 = createHandlerLogger("responses-handler");
 const RESPONSES_ENDPOINT = "/responses";
 const handleResponses = async (c) => {
+	const payload = await c.req.json();
+	debugJson(logger$1, "Responses request payload:", payload);
+	const requestedModel = payload.model;
+	payload.model = resolveMappedModel(payload.model);
+	if (payload.model !== requestedModel) consola.debug(`Resolved model mapping: ${requestedModel} -> ${payload.model}`);
+	const providerModelAlias = parseProviderModelAlias(payload.model);
+	if (providerModelAlias) {
+		payload.model = providerModelAlias.model;
+		return await handleProviderResponsesForProvider(c, {
+			payload,
+			provider: providerModelAlias.provider
+		});
+	}
+	const subagentMarker = getCodexResponsesSubagentMarker(c);
+	if (subagentMarker) debugJson(logger$1, "Detected Codex subagent headers:", subagentMarker);
+	const incomingSessionId = subagentMarker ? getIncomingResponsesSessionId(c) : void 0;
 	await checkRateLimit(state);
 	const store = getRequestHistoryStore();
 	const request = buildRequestContext(c);
-	const payload = await c.req.json();
 	const clientModel = payload.model;
-	debugJson(logger$1, "Responses request payload:", payload);
 	if (!isResponsesApiWebSearchEnabled()) removeWebSearchTool(payload);
 	compactInputByLatestCompaction(payload);
 	const streamRequested = Boolean(payload.stream);
-	const { initiator: initialInitiator } = getResponsesRequestOptions(payload);
+	const { initiator: inferredInitiator } = getResponsesRequestOptions(payload);
+	const initialInitiator = subagentMarker ? "agent" : inferredInitiator;
 	const userId = payload.metadata?.user_id;
 	const requestBodyPromptCacheKey = typeof payload.prompt_cache_key === "string" ? payload.prompt_cache_key : null;
 	const { safetyIdentifier, sessionId: metadataSessionId } = parseUserIdMetadata(userId);
@@ -8524,8 +8941,8 @@ const handleResponses = async (c) => {
 			message: "This model is only available via an alias. Please use the alias model name."
 		});
 	}
-	const upstreamRequestId = generateRequestIdFromPayload({ messages: payload.input }, normalizedPromptCacheKey);
 	const headerSessionId = c.req.header("x-session-id") ?? null;
+	const upstreamRequestId = generateRequestIdFromPayload({ messages: payload.input }, incomingSessionId ?? normalizedPromptCacheKey);
 	const affinityKey = resolveAffinityKey({
 		promptCacheKey: requestBodyPromptCacheKey,
 		metadataSessionId,
@@ -8556,16 +8973,19 @@ const handleResponses = async (c) => {
 		model: selectedModel.id
 	};
 	removeUnsupportedTools(upstreamPayload);
+	const sanitizedImageCount = sanitizeOversizedInputImages(upstreamPayload, selectedModel.capabilities.limits.vision?.max_prompt_image_size);
+	if (sanitizedImageCount > 0) logger$1.warn(`Omitted ${sanitizedImageCount} oversized input image(s) before forwarding to Copilot Responses`);
 	applyResponsesApiContextManagement(upstreamPayload, selectedModel.capabilities.limits.max_prompt_tokens);
 	compactInputByLatestCompaction(upstreamPayload);
 	const premiumRemainingBefore = account.premiumRemaining;
 	const premiumUnlimitedBefore = account.unlimited;
 	const transport = getResponsesTransportForModel(selectedModel) ?? "http";
-	const { vision, initiator } = getResponsesRequestOptions(upstreamPayload);
+	const { vision, initiator: inferredUpstreamInitiator } = getResponsesRequestOptions(upstreamPayload);
+	const initiator = subagentMarker ? "agent" : inferredUpstreamInitiator;
 	request.initiator = initiator;
 	if (state.manualApprove) await awaitApproval();
 	const accountCtx = toAccountContext(account);
-	const upstreamSessionId = getUUID(normalizedPromptCacheKey ?? headerSessionId ?? upstreamRequestId);
+	const upstreamSessionId = getUUID(incomingSessionId ?? normalizedPromptCacheKey ?? headerSessionId ?? upstreamRequestId);
 	request.upstreamRequestId = upstreamRequestId;
 	request.upstreamSessionId = upstreamSessionId;
 	const bridgeId = c.req.header("x-responses-bridge-id") ?? void 0;
@@ -8579,6 +8999,7 @@ const handleResponses = async (c) => {
 		accountCtx,
 		vision,
 		initiator,
+		subagentMarker,
 		premiumRemainingBefore,
 		premiumUnlimitedBefore,
 		transport,
@@ -8594,6 +9015,7 @@ const handleResponses = async (c) => {
 		accountCtx,
 		vision,
 		initiator,
+		subagentMarker,
 		premiumRemainingBefore,
 		premiumUnlimitedBefore,
 		transport,
@@ -8705,12 +9127,13 @@ function extractUsageFromChunkData(data) {
 	}
 }
 async function handleStreamingResponses(params) {
-	const { c, store, request, payload, selection, clientModel, accountCtx, vision, initiator, premiumRemainingBefore, premiumUnlimitedBefore, transport, bridgeId } = params;
+	const { c, store, request, payload, selection, clientModel, accountCtx, vision, initiator, subagentMarker, premiumRemainingBefore, premiumUnlimitedBefore, transport, bridgeId } = params;
 	let response;
 	try {
 		response = await createResponses(payload, {
 			vision,
 			initiator,
+			subagentMarker,
 			upstreamRequestId: request.upstreamRequestId,
 			sessionId: request.upstreamSessionId,
 			requestId: request.requestId,
@@ -8903,7 +9326,7 @@ async function streamResponsesAndLog(params) {
 	}
 }
 async function handleNonStreamingResponses(params) {
-	const { c, store, request, payload, selection, clientModel, accountCtx, vision, initiator, premiumRemainingBefore, premiumUnlimitedBefore, transport, bridgeId } = params;
+	const { c, store, request, payload, selection, clientModel, accountCtx, vision, initiator, subagentMarker, premiumRemainingBefore, premiumUnlimitedBefore, transport, bridgeId } = params;
 	const { account, reservation, selectedModel, endpoint, costUnits } = selection;
 	let usage = {};
 	let errorState = { httpStatus: 200 };
@@ -8912,6 +9335,7 @@ async function handleNonStreamingResponses(params) {
 		const response = await createResponses(payload, {
 			vision,
 			initiator,
+			subagentMarker,
 			upstreamRequestId: request.upstreamRequestId,
 			sessionId: request.upstreamSessionId,
 			requestId: request.requestId,
@@ -8978,6 +9402,31 @@ const removeUnsupportedTools = (payload) => {
 	});
 	if (dropped.length > 0) logger$1.debug("Removed unsupported tools:", dropped);
 };
+const getTrimmedHeader = (c, name) => {
+	const value = c.req.header(name)?.trim();
+	return value ? value : void 0;
+};
+const getIncomingResponsesSessionId = (c) => getTrimmedHeader(c, "session-id") ?? getTrimmedHeader(c, "x-session-id");
+const codexSubagentHeaderValues = new Set([
+	"collab_spawn",
+	"compact",
+	"memory_consolidation",
+	"review"
+]);
+const getCodexResponsesSubagentMarker = (c) => {
+	const agentType = getTrimmedHeader(c, "x-openai-subagent");
+	if (!agentType || !codexSubagentHeaderValues.has(agentType)) return null;
+	const threadId = getTrimmedHeader(c, "thread-id");
+	const rootSessionId = getIncomingResponsesSessionId(c);
+	const parentThreadId = getTrimmedHeader(c, "x-codex-parent-thread-id");
+	if (!threadId && !rootSessionId && !parentThreadId) return null;
+	const agentId = threadId ?? parentThreadId ?? rootSessionId;
+	return {
+		agent_id: agentId,
+		agent_type: agentType,
+		session_id: threadId ?? rootSessionId ?? agentId
+	};
+};
 //#endregion
 //#region src/routes/responses/route.ts
 const responsesRoutes = new Hono();
@@ -9079,4 +9528,4 @@ createServer();
 //#endregion
 export { createServer };
 
-//# sourceMappingURL=server-DJ3_UGc4.js.map
+//# sourceMappingURL=server-C7pCkArb.js.map