@jeffreycao/copilot-api 1.10.19 → 1.10.21

package/dist/{server-N7maSIWC.js → server-DcJiCgxI.js}

@@ -1749,37 +1749,6 @@ function getAnthropicToolUseBlocks(toolCalls) {
 	}));
 }
 //#endregion
-//#region src/routes/provider/messages/count-tokens-handler.ts
-const logger$6 = createHandlerLogger("provider-count-tokens-handler");
-async function handleProviderCountTokens(c) {
-	const provider = c.req.param("provider");
-	return await handleProviderCountTokensForProvider(c, {
-		payload: await c.req.json(),
-		provider
-	});
-}
-async function handleProviderCountTokensForProvider(c, options) {
-	const { payload: anthropicPayload, provider } = options;
-	const modelId = anthropicPayload.model.trim();
-	const providerConfig = await resolveProviderConfig(provider);
-	if (!providerConfig) return c.json({ error: {
-		message: `Provider '${provider}' not found or disabled`,
-		type: "invalid_request_error"
-	} }, 404);
-	const modelConfig = providerConfig.models?.[modelId];
-	const tokenCount = await getTokenCount(translateToOpenAI(anthropicPayload, providerConfig.type === "openai-compatible" || providerConfig.type === "openai-responses" ? {
-		supportPdf: modelConfig?.supportPdf,
-		toolContentSupportType: modelConfig?.toolContentSupportType ?? []
-	} : void 0), createFallbackModel(modelId));
-	const finalTokenCount = tokenCount.input + tokenCount.output;
-	logger$6.debug("provider.count_tokens.success", {
-		provider,
-		model: anthropicPayload.model,
-		input_tokens: finalTokenCount
-	});
-	return c.json({ input_tokens: finalTokenCount });
-}
-//#endregion
 //#region src/lib/models.ts
 const findEndpointModel = (sdkModelId) => {
 	const models = state.models?.data ?? [];
@@ -1829,893 +1798,1275 @@ const normalizeSdkModelId = (sdkModelId) => {
 		version: pattern5[1]
 	};
 };
-//#endregion
-//#region src/routes/messages/count-tokens-handler.ts
-const resolveCountTokensModel = (modelId, findModel = findEndpointModel) => {
-	const selectedModel = findModel(modelId);
-	if (selectedModel) return {
-		fallback: false,
-		model: selectedModel
-	};
-	return {
-		fallback: true,
-		model: createFallbackModel(modelId.trim())
-	};
-};
-/**
-* Forwards token counting to Anthropic's real /v1/messages/count_tokens endpoint.
-* Returns the result on success, or null to fall through to estimation.
-*/
-async function countTokensViaAnthropic(c, payload) {
-	if (!payload.model.startsWith("claude")) return null;
-	const apiKey = getAnthropicApiKey();
-	if (!apiKey) return null;
-	const model = payload.model.replaceAll(".", "-");
-	const res = await fetch("https://api.anthropic.com/v1/messages/count_tokens", {
-		method: "POST",
-		headers: {
-			"content-type": "application/json",
-			"x-api-key": apiKey,
-			"anthropic-version": "2023-06-01",
-			"anthropic-beta": "token-counting-2024-11-01"
-		},
-		body: JSON.stringify({
-			...payload,
-			model
-		})
+const SYSTEM_REMINDER_START = "<system-reminder>";
+const SYSTEM_REMINDER_END = "</system-reminder>";
+const SUBAGENT_START_HOOK_ADDITIONAL_PREFIX = "SubagentStart hook additional";
+const IDE_EXECUTE_CODE_TOOL = "mcp__ide__executeCode";
+const IDE_GET_DIAGNOSTICS_TOOL = "mcp__ide__getDiagnostics";
+const IDE_GET_DIAGNOSTICS_DESCRIPTION = "Get language diagnostics from VS Code. Returns errors, warnings, information, and hints for files in the workspace.";
+const PDF_FILE_READ_PREFIX = "PDF file read:";
+const createTextBlock = (text) => ({
+	type: "text",
+	text
+});
+const appendTextSegment = (base, addition) => {
+	if (base.length === 0) return addition;
+	if (addition.length === 0) return base;
+	return `${base}\n\n${addition}`;
+};
+const ensureSystemReminderText = (text) => {
+	if (text.startsWith(SYSTEM_REMINDER_START)) return text;
+	return `${SYSTEM_REMINDER_START}\n${text.trim()}\n${SYSTEM_REMINDER_END}`;
+};
+const normalizeSystemStringForMerge = (text) => {
+	if (!text.startsWith(SUBAGENT_START_HOOK_ADDITIONAL_PREFIX)) return ensureSystemReminderText(text);
+	const lineBreakMatch = /\r?\n/.exec(text);
+	if (!lineBreakMatch) return [createTextBlock(ensureSystemReminderText(text))];
+	const firstLine = text.slice(0, lineBreakMatch.index);
+	const rest = text.slice(lineBreakMatch.index + lineBreakMatch[0].length);
+	return [createTextBlock(ensureSystemReminderText(firstLine)), ...rest.length > 0 ? [createTextBlock(ensureSystemReminderText(rest))] : []];
+};
+const normalizeSystemContentForMerge = (content) => {
+	if (typeof content === "string") return normalizeSystemStringForMerge(content);
+	return content.map((block) => block.text.startsWith(SYSTEM_REMINDER_START) ? block : {
+		...block,
+		text: ensureSystemReminderText(block.text)
 	});
-	if (!res.ok) {
-		consola.warn("Anthropic count_tokens failed:", res.status, await res.text().catch(() => ""), "- falling back to estimation");
-		return null;
-	}
-	const result = await res.json();
-	consola.info("Token count (Anthropic API):", result.input_tokens);
-	return c.json(result);
-}
-/**
-* Handles token counting for Anthropic messages.
-*
-* When an Anthropic API key is available (via config or ANTHROPIC_API_KEY env var)
-* and the model is a Claude model, forwards to Anthropic's free /v1/messages/count_tokens
-* endpoint for accurate counts. Otherwise falls back to GPT tokenizer estimation.
-*/
-async function handleCountTokens(c) {
-	const anthropicPayload = await c.req.json();
-	anthropicPayload.model = resolveMappedModel(anthropicPayload.model);
-	const providerModelAlias = parseProviderModelAlias(anthropicPayload.model);
-	if (providerModelAlias) {
-		anthropicPayload.model = providerModelAlias.model;
-		return await handleProviderCountTokensForProvider(c, {
-			payload: anthropicPayload,
-			provider: providerModelAlias.provider
-		});
+};
+const toSystemTextBlocks = (content) => {
+	return typeof content === "string" ? [createTextBlock(content)] : [...content];
+};
+const mergeSystemPromptContent = (current, addition) => {
+	if (current === void 0) return typeof addition === "string" ? addition : [...addition];
+	if (typeof current === "string" && typeof addition === "string") return appendTextSegment(current, addition);
+	return [...toSystemTextBlocks(current), ...toSystemTextBlocks(addition)];
+};
+const prependSystemContentToUserMessage = (message, addition) => {
+	if (typeof message.content === "string" && typeof addition === "string") {
+		message.content = appendTextSegment(addition, message.content);
+		return;
 	}
-	const anthropicResult = await countTokensViaAnthropic(c, anthropicPayload);
-	if (anthropicResult) return anthropicResult;
-	const anthropicBeta = c.req.header("anthropic-beta");
-	const openAIPayload = translateToOpenAI(anthropicPayload);
-	const requestedModel = anthropicPayload.model;
-	const resolve = resolveCountTokensModel(requestedModel);
-	const selectedModel = resolve.model;
-	anthropicPayload.model = selectedModel.id;
-	if (resolve.fallback) consola.warn(`Model '${requestedModel}' not found, using o200k_base fallback tokenizer`);
-	const tokenCount = await getTokenCount(openAIPayload, selectedModel);
-	if (anthropicPayload.tools && anthropicPayload.tools.length > 0) {
-		let addToolSystemPromptCount = false;
-		if (anthropicBeta) {
-			const toolsLength = anthropicPayload.tools.length;
-			addToolSystemPromptCount = !anthropicPayload.tools.some((tool) => tool.name.startsWith("mcp__") || tool.name === "Skill" && toolsLength === 1);
-		}
-		if (addToolSystemPromptCount) {
-			if (anthropicPayload.model.startsWith("claude")) tokenCount.input = tokenCount.input + 346;
-			else if (anthropicPayload.model.startsWith("grok")) tokenCount.input = tokenCount.input + 120;
+	if (Array.isArray(message.content)) {
+		const lastToolResultIndex = message.content.findLastIndex((block) => block.type === "tool_result");
+		if (lastToolResultIndex >= 0) {
+			message.content = [
+				...message.content.slice(0, lastToolResultIndex + 1),
+				...toSystemTextBlocks(addition),
+				...message.content.slice(lastToolResultIndex + 1)
+			];
+			return;
 		}
 	}
-	let finalTokenCount = tokenCount.input + tokenCount.output;
-	if (anthropicPayload.model.startsWith("claude")) finalTokenCount = Math.round(finalTokenCount * getClaudeTokenMultiplier());
-	consola.info("Token count:", finalTokenCount);
-	return c.json({ input_tokens: finalTokenCount });
-}
-//#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();
+	message.content = [...toSystemTextBlocks(addition), ...typeof message.content === "string" ? [createTextBlock(message.content)] : message.content];
 };
-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 normalizeSystemMessages = (payload) => {
+	if (!payload.messages.some((msg) => msg.role === "system")) return;
+	const normalizedMessages = [];
+	let system = payload.system;
+	for (const message of payload.messages) {
+		if (message.role === "system") {
+			const normalizedContent = normalizeSystemContentForMerge(message.content);
+			const previousMessage = normalizedMessages.at(-1);
+			if (previousMessage?.role === "user") prependSystemContentToUserMessage(previousMessage, normalizedContent);
+			else if (!previousMessage) system = mergeSystemPromptContent(system, normalizedContent);
+			continue;
+		}
+		normalizedMessages.push(message);
 	}
+	payload.messages = normalizedMessages;
+	payload.system = system;
 };
-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";
+const isVersionAtLeast = (version, minimumMajor, minimumMinor) => {
+	const [majorPart, minorPart = "0"] = version.split(".");
+	const major = Number.parseInt(majorPart, 10);
+	const minor = Number.parseInt(minorPart, 10);
+	if (!Number.isInteger(major) || !Number.isInteger(minor)) return false;
+	return major > minimumMajor || major === minimumMajor && minor >= minimumMinor;
 };
-//#endregion
-//#region src/routes/messages/stream-translation.ts
-function isToolBlockOpen(state) {
-	if (!state.contentBlockOpen) return false;
-	return Object.values(state.toolCalls).some((tc) => tc.anthropicBlockIndex === state.contentBlockIndex);
-}
-function translateChunkToAnthropicEvents(chunk, state) {
-	const events = [];
-	if (chunk.choices.length === 0) {
-		completePendingMessage(state, events, chunk);
-		return events;
+const shouldSummarizeThinkingDisplayForModel = (model) => {
+	const normalized = normalizeSdkModelId(model);
+	return Boolean(normalized && isVersionAtLeast(normalized.version, 4, 7));
+};
+const getBlockCacheControl = (block) => {
+	if (!block || block.type === "thinking") return;
+	const cacheControl = block.cache_control;
+	if (!cacheControl || typeof cacheControl !== "object") return;
+	return cacheControl;
+};
+const getLastMessageContentCacheControl = (lastMessage) => {
+	if (!lastMessage || !Array.isArray(lastMessage.content)) return;
+	const cacheControl = getBlockCacheControl(lastMessage.content.at(-1));
+	return cacheControl ? { ...cacheControl } : void 0;
+};
+const applyLastMessageCacheControl = (anthropicPayload, lastMessageCacheControl) => {
+	const cacheControl = lastMessageCacheControl ?? { type: "ephemeral" };
+	const lastMessage = anthropicPayload.messages.at(-1);
+	if (!lastMessage || !Array.isArray(lastMessage.content)) return;
+	const lastBlock = lastMessage.content.at(-1);
+	if (!lastBlock || lastBlock.type === "thinking" || lastBlock.cache_control) return;
+	lastBlock.cache_control = { ...cacheControl };
+};
+const getCompactCandidateText = (message) => {
+	if (message.role !== "user") return "";
+	if (typeof message.content === "string") return message.content;
+	return message.content.filter((block) => block.type === "text").map((block) => block.text.startsWith("<system-reminder>") ? "" : block.text).filter((text) => text.length > 0).join("\n\n");
+};
+const isCompactMessage = (lastMessage) => {
+	const text = getCompactCandidateText(lastMessage);
+	if (!text) return false;
+	return text.includes("CRITICAL: Respond with TEXT ONLY. Do NOT call any tools.") && text.includes("Your task is to create a detailed summary of the conversation so far") && compactMessageSections.some((section) => text.includes(section));
+};
+const isCompactAutoContinueMessage = (lastMessage) => {
+	const text = getCompactCandidateText(lastMessage);
+	return Boolean(text) && compactAutoContinuePromptStarts.some((promptStart) => text.startsWith(promptStart));
+};
+const getCompactType = (anthropicPayload) => {
+	const lastMessage = anthropicPayload.messages.at(-1);
+	if (lastMessage && isCompactMessage(lastMessage)) return 1;
+	if (lastMessage && isCompactAutoContinueMessage(lastMessage)) return 2;
+	const system = anthropicPayload.system;
+	if (typeof system === "string") return compactSystemPromptStarts.some((promptStart) => system.startsWith(promptStart)) ? 1 : 0;
+	if (!Array.isArray(system)) return 0;
+	if (system.some((msg) => typeof msg.text === "string" && compactSystemPromptStarts.some((promptStart) => msg.text.startsWith(promptStart)))) return 1;
+	return 0;
+};
+const mergeContentWithText = (tr, textBlock) => {
+	if (typeof tr.content === "string") return {
+		...tr,
+		content: `${tr.content}\n\n${textBlock.text}`
+	};
+	if (hasToolRef(tr)) return tr;
+	return {
+		...tr,
+		content: [...tr.content, stripContentBlockCacheControl(textBlock)]
+	};
+};
+const mergeContentWithTexts = (tr, textBlocks) => {
+	if (typeof tr.content === "string") {
+		const appendedTexts = textBlocks.map((tb) => tb.text).join("\n\n");
+		return {
+			...tr,
+			content: `${tr.content}\n\n${appendedTexts}`
+		};
 	}
-	const choice = chunk.choices[0];
-	const { delta } = choice;
-	handleMessageStart(state, events, chunk);
-	handleThinkingText(delta, state, events);
-	handleContent(delta, state, events);
-	handleToolCalls(delta, state, events);
-	handleFinish(choice, state, {
-		events,
-		chunk
-	});
-	return events;
-}
-function flushPendingAnthropicStreamEvents(state) {
-	const events = [];
-	completePendingMessage(state, events);
-	return events;
-}
-function completePendingMessage(state, events, chunk) {
-	if (!state.pendingMessageDelta) return;
-	if (chunk?.usage) state.pendingMessageDelta.usage = getAnthropicUsageFromOpenAIChunk(chunk);
-	events.push(state.pendingMessageDelta, { type: "message_stop" });
-	state.pendingMessageDelta = void 0;
-}
-function handleFinish(choice, state, context) {
-	const { events, chunk } = context;
-	if (choice.finish_reason && choice.finish_reason.length > 0) {
-		if (state.contentBlockOpen) {
-			const toolBlockOpen = isToolBlockOpen(state);
-			context.events.push({
-				type: "content_block_stop",
-				index: state.contentBlockIndex
-			});
-			state.contentBlockOpen = false;
-			state.contentBlockIndex++;
-			if (!toolBlockOpen) handleReasoningOpaque(choice.delta, events, state);
-		}
-		flushDeferredContent(state, events);
-		state.pendingMessageDelta = {
-			type: "message_delta",
-			delta: {
-				stop_reason: mapOpenAIStopReasonToAnthropic(choice.finish_reason),
-				stop_sequence: null
-			},
-			usage: getAnthropicUsageFromOpenAIChunk(chunk)
-		};
-		if (chunk.usage) completePendingMessage(state, events, chunk);
-	}
-}
-function getAnthropicUsageFromOpenAIChunk(chunk) {
-	const { cachedTokens, cacheCreationTokens, inputTokens } = getOpenAIChunkUsageTokens(chunk);
+	if (hasToolRef(tr)) return tr;
 	return {
-		input_tokens: inputTokens,
-		output_tokens: chunk.usage?.completion_tokens ?? 0,
-		...chunk.usage?.prompt_tokens_details?.cache_creation_input_tokens !== void 0 && { cache_creation_input_tokens: cacheCreationTokens },
-		...chunk.usage?.prompt_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: cachedTokens }
+		...tr,
+		content: [...tr.content, ...textBlocks.map(stripContentBlockCacheControl)]
+	};
+};
+const mergeContentWithAttachments = (tr, attachments) => {
+	const cleanAttachments = attachments.map(stripContentBlockCacheControl);
+	if (typeof tr.content === "string") return {
+		...tr,
+		content: [{
+			type: "text",
+			text: tr.content
+		}, ...cleanAttachments]
 	};
-}
-function getOpenAIChunkUsageTokens(chunk) {
-	const promptTokens = chunk.usage?.prompt_tokens ?? 0;
-	const cachedTokens = chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0;
-	const cacheCreationTokens = chunk.usage?.prompt_tokens_details?.cache_creation_input_tokens ?? 0;
 	return {
-		cacheCreationTokens,
-		cachedTokens,
-		inputTokens: Math.max(0, promptTokens - cachedTokens - cacheCreationTokens)
+		...tr,
+		content: [...tr.content, ...cleanAttachments]
 	};
-}
-function handleToolCalls(delta, state, events) {
-	if (delta.tool_calls && delta.tool_calls.length > 0) {
-		closeThinkingBlockIfOpen(state, events);
-		handleReasoningOpaqueInToolCalls(state, events, delta);
-		for (const toolCall of delta.tool_calls) {
-			if (toolCall.id && toolCall.function?.name) {
-				if (state.contentBlockOpen) {
-					events.push({
-						type: "content_block_stop",
-						index: state.contentBlockIndex
-					});
-					state.contentBlockIndex++;
-					state.contentBlockOpen = false;
-				}
-				const anthropicBlockIndex = state.contentBlockIndex;
-				state.toolCalls[toolCall.index] = {
-					id: toolCall.id,
-					name: toolCall.function.name,
-					anthropicBlockIndex
-				};
-				events.push({
-					type: "content_block_start",
-					index: anthropicBlockIndex,
-					content_block: {
-						type: "tool_use",
-						id: toolCall.id,
-						name: toolCall.function.name,
-						input: {}
-					}
-				});
-				state.contentBlockOpen = true;
-			}
-			if (toolCall.function?.arguments) {
-				const toolCallInfo = state.toolCalls[toolCall.index];
-				if (toolCallInfo) events.push({
-					type: "content_block_delta",
-					index: toolCallInfo.anthropicBlockIndex,
-					delta: {
-						type: "input_json_delta",
-						partial_json: toolCall.function.arguments
-					}
-				});
+};
+const stripContentBlockCacheControl = (block) => {
+	if (!Object.hasOwn(block, "cache_control")) return block;
+	const copy = { ...block };
+	delete copy.cache_control;
+	return copy;
+};
+const isAttachmentBlock = (block) => {
+	return block.type === "image" || block.type === "document";
+};
+const getMergeableToolResultIndices = (toolResults) => {
+	return toolResults.flatMap((block, index) => block.is_error || hasToolRef(block) ? [] : [index]);
+};
+const mergeAttachmentsIntoToolResults = (toolResults, attachmentsByToolResultIndex) => {
+	if (attachmentsByToolResultIndex.size === 0) return toolResults;
+	return toolResults.map((block, index) => {
+		const matchedAttachments = attachmentsByToolResultIndex.get(index);
+		if (!matchedAttachments) return block;
+		return mergeContentWithAttachments(block, [...matchedAttachments].sort((left, right) => left.order - right.order).map(({ attachment }) => attachment));
+	});
+};
+const assignAttachmentsToToolResults = (target, attachments, options) => {
+	const { toolResultIndices } = options;
+	const fallbackToolResultIndices = options.fallbackToolResultIndices ?? toolResultIndices;
+	if (attachments.length === 0) return;
+	if (toolResultIndices.length > 0 && toolResultIndices.length === attachments.length) {
+		for (const [index, toolResultIndex] of toolResultIndices.entries()) {
+			const currentAttachments = target.get(toolResultIndex);
+			if (currentAttachments) {
+				currentAttachments.push(attachments[index]);
+				continue;
 			}
+			target.set(toolResultIndex, [attachments[index]]);
 		}
+		return;
 	}
-}
-function handleReasoningOpaqueInToolCalls(state, events, delta) {
-	if (state.contentBlockOpen && !isToolBlockOpen(state)) {
-		events.push({
-			type: "content_block_stop",
-			index: state.contentBlockIndex
-		});
-		state.contentBlockIndex++;
-		state.contentBlockOpen = false;
+	const lastToolResultIndex = fallbackToolResultIndices.at(-1);
+	if (lastToolResultIndex === void 0) return;
+	const currentAttachments = target.get(lastToolResultIndex);
+	if (currentAttachments) {
+		currentAttachments.push(...attachments);
+		return;
 	}
-	handleReasoningOpaque(delta, events, state);
-}
-function handleContent(delta, state, events) {
-	if (delta.content && delta.content.length > 0) {
-		closeThinkingBlockIfOpen(state, events);
-		if (isToolBlockOpen(state) || hasToolCallDelta(delta)) {
-			state.deferredContent = `${state.deferredContent ?? ""}${delta.content}`;
-			return;
+	target.set(lastToolResultIndex, [...attachments]);
+};
+const startsWithPdfFileRead = (toolResult) => {
+	if (typeof toolResult.content === "string") return toolResult.content.startsWith(PDF_FILE_READ_PREFIX);
+	if (toolResult.content.some((block) => block.type === "document")) return false;
+	if (toolResult.content.length === 0) return false;
+	const firstBlock = toolResult.content[0];
+	if (firstBlock.type !== "text") return false;
+	return firstBlock.text.startsWith(PDF_FILE_READ_PREFIX);
+};
+const collectMergeableUserContent = (content) => {
+	const toolResults = [];
+	const textBlocks = [];
+	const attachments = [];
+	for (const [order, block] of content.entries()) {
+		if (block.type === "tool_result") {
+			toolResults.push(block);
+			continue;
 		}
-		if (!state.contentBlockOpen) {
-			events.push({
-				type: "content_block_start",
-				index: state.contentBlockIndex,
-				content_block: {
-					type: "text",
-					text: ""
-				}
+		if (block.type === "text") {
+			textBlocks.push(block);
+			continue;
+		}
+		if (isAttachmentBlock(block)) {
+			attachments.push({
+				attachment: block,
+				order
 			});
-			state.contentBlockOpen = true;
+			continue;
 		}
-		events.push({
-			type: "content_block_delta",
-			index: state.contentBlockIndex,
-			delta: {
-				type: "text_delta",
-				text: delta.content
-			}
-		});
+		return null;
 	}
-	if (delta.content === "" && delta.reasoning_opaque && delta.reasoning_opaque.length > 0 && state.thinkingBlockOpen) {
-		events.push({
-			type: "content_block_delta",
-			index: state.contentBlockIndex,
-			delta: {
-				type: "signature_delta",
-				signature: delta.reasoning_opaque
-			}
-		}, {
-			type: "content_block_stop",
-			index: state.contentBlockIndex
-		});
-		state.contentBlockIndex++;
-		state.thinkingBlockOpen = false;
+	return {
+		toolResults,
+		textBlocks,
+		attachments
+	};
+};
+const mergeAttachmentsForToolResults = (toolResults, attachments) => {
+	if (attachments.length === 0) return toolResults;
+	const documentBlocks = attachments.filter(({ attachment }) => attachment.type === "document");
+	const mergeableToolResultIndices = getMergeableToolResultIndices(toolResults);
+	const pdfReadToolResultIndices = mergeableToolResultIndices.filter((index) => startsWithPdfFileRead(toolResults[index]));
+	const attachmentsByToolResultIndex = /* @__PURE__ */ new Map();
+	let remainingAttachments = attachments;
+	let countMatchToolResultIndices = mergeableToolResultIndices;
+	if (documentBlocks.length > 0 && pdfReadToolResultIndices.length > 0) {
+		const matchedDocumentCount = Math.min(pdfReadToolResultIndices.length, documentBlocks.length);
+		const matchedDocuments = documentBlocks.slice(0, matchedDocumentCount);
+		const matchedDocumentOrders = new Set(matchedDocuments.map(({ order }) => order));
+		const matchedPdfToolResultIndices = pdfReadToolResultIndices.slice(0, matchedDocumentCount);
+		const matchedPdfToolResultIndexSet = new Set(matchedPdfToolResultIndices);
+		assignAttachmentsToToolResults(attachmentsByToolResultIndex, matchedDocuments, { toolResultIndices: matchedPdfToolResultIndices });
+		countMatchToolResultIndices = mergeableToolResultIndices.filter((index) => !matchedPdfToolResultIndexSet.has(index));
+		remainingAttachments = attachments.filter(({ attachment, order }) => attachment.type !== "document" || !matchedDocumentOrders.has(order));
 	}
-}
-function hasToolCallDelta(delta) {
-	return Boolean(delta.tool_calls && delta.tool_calls.length > 0);
-}
-function flushDeferredContent(state, events) {
-	if (!state.deferredContent) return;
-	if (!state.contentBlockOpen) {
-		events.push({
-			type: "content_block_start",
-			index: state.contentBlockIndex,
-			content_block: {
-				type: "text",
-				text: ""
-			}
-		});
-		state.contentBlockOpen = true;
-	}
-	events.push({
-		type: "content_block_delta",
-		index: state.contentBlockIndex,
-		delta: {
-			type: "text_delta",
-			text: state.deferredContent
-		}
-	}, {
-		type: "content_block_stop",
-		index: state.contentBlockIndex
+	assignAttachmentsToToolResults(attachmentsByToolResultIndex, remainingAttachments, {
+		toolResultIndices: countMatchToolResultIndices,
+		fallbackToolResultIndices: mergeableToolResultIndices
 	});
-	state.deferredContent = void 0;
-	state.contentBlockOpen = false;
-	state.contentBlockIndex++;
-}
-function handleMessageStart(state, events, chunk) {
-	if (!state.messageStartSent) {
-		const { cachedTokens, cacheCreationTokens, inputTokens } = getOpenAIChunkUsageTokens(chunk);
-		events.push({
-			type: "message_start",
-			message: {
-				id: chunk.id,
-				type: "message",
-				role: "assistant",
-				content: [],
-				model: chunk.model,
-				stop_reason: null,
-				stop_sequence: null,
-				usage: {
-					input_tokens: inputTokens,
-					output_tokens: 0,
-					...chunk.usage?.prompt_tokens_details?.cache_creation_input_tokens !== void 0 && { cache_creation_input_tokens: cacheCreationTokens },
-					...chunk.usage?.prompt_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: cachedTokens }
-				}
-			}
-		});
-		state.messageStartSent = true;
+	return mergeAttachmentsIntoToolResults(toolResults, attachmentsByToolResultIndex);
+};
+const mergeUserMessageContent = (content) => {
+	const mergeableContent = collectMergeableUserContent(content);
+	if (!mergeableContent) return null;
+	const { toolResults, textBlocks, attachments } = mergeableContent;
+	if (toolResults.length === 0 || textBlocks.length === 0 && attachments.length === 0) return null;
+	return mergeAttachmentsForToolResults(textBlocks.length === 0 ? toolResults : mergeToolResult(toolResults, textBlocks), attachments);
+};
+const mergeToolResult = (toolResults, textBlocks) => {
+	if (toolResults.length === textBlocks.length) return toolResults.map((tr, i) => mergeContentWithText(tr, textBlocks[i]));
+	const lastIndex = toolResults.length - 1;
+	return toolResults.map((tr, i) => i === lastIndex ? mergeContentWithTexts(tr, textBlocks) : tr);
+};
+const stripToolReferenceTurnBoundary = (anthropicPayload) => {
+	for (const msg of anthropicPayload.messages) {
+		if (msg.role !== "user" || !Array.isArray(msg.content)) continue;
+		if (!msg.content.some((block) => block.type === "tool_result" && hasToolRef(block))) continue;
+		msg.content = msg.content.filter((block) => block.type !== "text" || block.text.trim() !== "Tool loaded.");
 	}
-}
-function handleReasoningOpaque(delta, events, state) {
-	if (delta.reasoning_opaque && delta.reasoning_opaque.length > 0) {
-		events.push({
-			type: "content_block_start",
-			index: state.contentBlockIndex,
-			content_block: {
-				type: "thinking",
-				thinking: ""
-			}
-		}, {
-			type: "content_block_delta",
-			index: state.contentBlockIndex,
-			delta: {
-				type: "thinking_delta",
-				thinking: THINKING_TEXT$1
-			}
-		}, {
-			type: "content_block_delta",
-			index: state.contentBlockIndex,
-			delta: {
-				type: "signature_delta",
-				signature: delta.reasoning_opaque
-			}
-		}, {
-			type: "content_block_stop",
-			index: state.contentBlockIndex
-		});
-		state.contentBlockIndex++;
+};
+const mergeToolResultForClaude = (anthropicPayload, options) => {
+	const lastMessageIndex = anthropicPayload.messages.length - 1;
+	for (const [index, msg] of anthropicPayload.messages.entries()) {
+		if (options?.skipLastMessage && index === lastMessageIndex) continue;
+		if (msg.role !== "user" || !Array.isArray(msg.content)) continue;
+		const mergedContent = mergeUserMessageContent(msg.content);
+		if (mergedContent) msg.content = mergedContent;
 	}
-}
-function handleThinkingText(delta, state, events) {
-	const reasoningText = delta.reasoning_text ?? delta.reasoning_content;
-	if (reasoningText && reasoningText.length > 0) {
-		if (state.contentBlockOpen) {
-			delta.content = reasoningText;
-			delta.reasoning_text = void 0;
-			delta.reasoning_content = void 0;
-			return;
-		}
-		if (!state.thinkingBlockOpen) {
-			events.push({
-				type: "content_block_start",
-				index: state.contentBlockIndex,
-				content_block: {
-					type: "thinking",
-					thinking: ""
-				}
-			});
-			state.thinkingBlockOpen = true;
+};
+const sanitizeIdeTools = (payload) => {
+	if (!payload.tools || payload.tools.length === 0) return;
+	payload.tools = payload.tools.flatMap((tool) => {
+		if (tool.name === IDE_EXECUTE_CODE_TOOL && !tool.defer_loading) return [];
+		if (tool.name === IDE_GET_DIAGNOSTICS_TOOL) return [{
+			...tool,
+			description: IDE_GET_DIAGNOSTICS_DESCRIPTION
+		}];
+		return [tool];
+	});
+};
+const hasToolRef = (block) => {
+	return Array.isArray(block.content) && block.content.some((c) => c.type === "tool_reference");
+};
+const stripCacheControl = (payload) => {
+	if (Array.isArray(payload.system)) for (const block of payload.system) {
+		const cacheControl = block.cache_control;
+		if (cacheControl && typeof cacheControl === "object") {
+			const { scope, ...rest } = cacheControl;
+			block.cache_control = rest;
 		}
-		events.push({
-			type: "content_block_delta",
-			index: state.contentBlockIndex,
-			delta: {
-				type: "thinking_delta",
-				thinking: reasoningText
-			}
-		});
 	}
-}
-function closeThinkingBlockIfOpen(state, events) {
-	if (state.thinkingBlockOpen) {
-		events.push({
-			type: "content_block_delta",
-			index: state.contentBlockIndex,
-			delta: {
-				type: "signature_delta",
-				signature: ""
-			}
-		}, {
-			type: "content_block_stop",
-			index: state.contentBlockIndex
-		});
-		state.contentBlockIndex++;
-		state.thinkingBlockOpen = false;
+};
+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;
+		return block.thinking && block.thinking !== "Thinking..." && block.signature && !block.signature.includes("@");
+	});
+};
+const prepareMessagesApiPayload = (payload, selectedModel) => {
+	stripCacheControl(payload);
+	filterAssistantThinkingBlocks(payload);
+	const hasThinking = Boolean(payload.thinking);
+	const toolChoice = payload.tool_choice;
+	const disableThink = toolChoice?.type === "any" || toolChoice?.type === "tool";
+	if (selectedModel?.capabilities.supports.adaptive_thinking && !disableThink) {
+		payload.thinking = { type: "adaptive" };
+		if (!hasThinking) payload.thinking.display = "summarized";
+		if (shouldSummarizeThinkingDisplayForModel(payload.model)) payload.thinking.display = "summarized";
+		let effort = getReasoningEffortForModel(payload.model);
+		if (effort === "none" || effort === "minimal") effort = "low";
+		const reasoningEffort = selectedModel.capabilities.supports.reasoning_effort;
+		if (reasoningEffort && !reasoningEffort.includes(effort)) effort = reasoningEffort.at(-1);
+		payload.output_config = { effort };
 	}
+};
+//#endregion
+//#region src/routes/provider/messages/count-tokens-handler.ts
+const logger$6 = createHandlerLogger("provider-count-tokens-handler");
+async function handleProviderCountTokens(c) {
+	const provider = c.req.param("provider");
+	return await handleProviderCountTokensForProvider(c, {
+		payload: await c.req.json(),
+		provider
+	});
+}
+async function handleProviderCountTokensForProvider(c, options) {
+	const { payload: anthropicPayload, provider } = options;
+	normalizeSystemMessages(anthropicPayload);
+	const modelId = anthropicPayload.model.trim();
+	const providerConfig = await resolveProviderConfig(provider);
+	if (!providerConfig) return c.json({ error: {
+		message: `Provider '${provider}' not found or disabled`,
+		type: "invalid_request_error"
+	} }, 404);
+	const modelConfig = providerConfig.models?.[modelId];
+	const tokenCount = await getTokenCount(translateToOpenAI(anthropicPayload, providerConfig.type === "openai-compatible" || providerConfig.type === "openai-responses" ? {
+		supportPdf: modelConfig?.supportPdf,
+		toolContentSupportType: modelConfig?.toolContentSupportType ?? []
+	} : void 0), createFallbackModel(modelId));
+	const finalTokenCount = tokenCount.input + tokenCount.output;
+	logger$6.debug("provider.count_tokens.success", {
+		provider,
+		model: anthropicPayload.model,
+		input_tokens: finalTokenCount
+	});
+	return c.json({ input_tokens: finalTokenCount });
 }
 //#endregion
-//#region src/services/copilot/create-responses.ts
-const createResponses = async (payload, { vision, initiator, subagentMarker, requestId, sessionId, compactType, transport = "http" }) => {
-	if (!state.copilotToken) throw new Error("Copilot token not found");
-	const headers = {
-		...copilotHeaders(state, requestId, vision),
-		"x-initiator": initiator
+//#region src/routes/messages/count-tokens-handler.ts
+const resolveCountTokensModel = (modelId, findModel = findEndpointModel) => {
+	const selectedModel = findModel(modelId);
+	if (selectedModel) return {
+		fallback: false,
+		model: selectedModel
+	};
+	return {
+		fallback: true,
+		model: createFallbackModel(modelId.trim())
 	};
-	prepareInteractionHeaders(sessionId, Boolean(subagentMarker), headers);
-	prepareForCompact(headers, compactType);
-	payload.service_tier = void 0;
-	consola.log(`<-- model: ${payload.model}`);
-	const effectiveTransport = compactType === 1 ? "http" : transport;
-	if (payload.stream === true && effectiveTransport === "websocket") return createPooledResponsesWebSocketStream(prepareResponsesWebSocketRequest(payload, headers, {
-		requestId,
-		subagentMarker
-	}));
-	return await createHttpResponses(payload, headers);
 };
-const createHttpResponses = async (payload, headers) => {
-	const response = await fetch(`${copilotBaseUrl(state)}/responses`, {
+/**
+* Forwards token counting to Anthropic's real /v1/messages/count_tokens endpoint.
+* Returns the result on success, or null to fall through to estimation.
+*/
+async function countTokensViaAnthropic(c, payload) {
+	if (!payload.model.startsWith("claude")) return null;
+	const apiKey = getAnthropicApiKey();
+	if (!apiKey) return null;
+	const model = payload.model.replaceAll(".", "-");
+	const res = await fetch("https://api.anthropic.com/v1/messages/count_tokens", {
 		method: "POST",
-		headers,
-		body: JSON.stringify(payload)
+		headers: {
+			"content-type": "application/json",
+			"x-api-key": apiKey,
+			"anthropic-version": "2023-06-01",
+			"anthropic-beta": "token-counting-2024-11-01"
+		},
+		body: JSON.stringify({
+			...payload,
+			model
+		})
 	});
-	logCopilotRateLimits(response.headers);
-	if (!response.ok) {
-		consola.error("Failed to create responses", response);
-		throw new HTTPError("Failed to create responses", response);
+	if (!res.ok) {
+		consola.warn("Anthropic count_tokens failed:", res.status, await res.text().catch(() => ""), "- falling back to estimation");
+		return null;
 	}
-	if (payload.stream) return events(response);
-	return await response.json();
-};
-const prepareResponsesWebSocketRequest = (payload, preparedHeaders, options) => {
-	const initiator = getResponsesWebSocketInitiator(preparedHeaders);
-	return {
-		headers: copilotWebSocketHeaders(preparedHeaders),
-		poolKey: buildResponsesWebSocketPoolKey(payload, options),
-		payload: buildResponsesWebSocketPayload(payload, initiator),
-		url: buildResponsesWebSocketUrl(copilotBaseUrl(state))
-	};
-};
-const buildResponsesWebSocketPoolKey = (payload, { requestId, subagentMarker }) => {
-	const tokenFingerprint = state.copilotToken ? createHash("sha256").update(state.copilotToken).digest("hex").slice(0, 16) : "missing-token";
-	const subagentKey = subagentMarker ? [
-		subagentMarker.session_id,
-		subagentMarker.agent_id,
-		subagentMarker.agent_type
-	].join(":") : "main";
-	return [
-		tokenFingerprint,
-		payload.model,
-		requestId,
-		subagentKey
-	].map(encodePoolKeyPart).join("|");
-};
-const getResponsesWebSocketInitiator = (preparedHeaders) => {
-	return getHeaderValue(preparedHeaders, "x-initiator")?.toLowerCase() === "agent" ? "agent" : "user";
-};
-const createPooledResponsesWebSocketStream = (request) => createPooledWebSocketStream(request, {
-	createChunk: createResponsesWebSocketStreamChunk,
-	isTerminalChunk: isTerminalResponsesStreamChunk,
-	openErrorMessage: "Failed to create responses websocket",
-	streamErrorMessage: "Responses websocket stream error",
-	terminalChunkMissingMessage: "Responses websocket ended without a terminal response"
-});
-const buildResponsesWebSocketPayload = (payload, initiator) => {
-	const websocketPayload = {
-		...payload,
-		type: "response.create",
-		initiator
-	};
-	delete websocketPayload.stream;
-	delete websocketPayload["background"];
-	delete websocketPayload.service_tier;
-	return websocketPayload;
-};
-const buildResponsesWebSocketUrl = (baseUrl) => {
-	return createWebSocketUrl(`${baseUrl.replace(/\/+$/u, "")}/responses`);
-};
-const getHeaderValue = (headers, headerName) => {
-	const normalizedHeaderName = headerName.toLowerCase();
-	return Object.entries(headers).find(([key]) => key.toLowerCase() === normalizedHeaderName)?.[1];
-};
-const encodePoolKeyPart = (value) => encodeURIComponent(value);
-const createResponsesWebSocketStreamChunk = (data) => {
-	if (data === "[DONE]") return { data };
-	try {
-		const parsed = JSON.parse(data);
-		if (parsed.type === "response.completed") logCopilotQuotaSnapshots(parsed.copilot_quota_snapshots);
-		return {
-			data: JSON.stringify(parsed),
-			event: typeof parsed.type === "string" ? parsed.type : void 0,
-			id: typeof parsed.id === "string" ? parsed.id : void 0
-		};
-	} catch {
-		return { data };
+	const result = await res.json();
+	consola.info("Token count (Anthropic API):", result.input_tokens);
+	return c.json(result);
+}
+/**
+* Handles token counting for Anthropic messages.
+*
+* When an Anthropic API key is available (via config or ANTHROPIC_API_KEY env var)
+* and the model is a Claude model, forwards to Anthropic's free /v1/messages/count_tokens
+* endpoint for accurate counts. Otherwise falls back to GPT tokenizer estimation.
+*/
+async function handleCountTokens(c) {
+	const anthropicPayload = await c.req.json();
+	anthropicPayload.model = resolveMappedModel(anthropicPayload.model);
+	normalizeSystemMessages(anthropicPayload);
+	const providerModelAlias = parseProviderModelAlias(anthropicPayload.model);
+	if (providerModelAlias) {
+		anthropicPayload.model = providerModelAlias.model;
+		return await handleProviderCountTokensForProvider(c, {
+			payload: anthropicPayload,
+			provider: providerModelAlias.provider
+		});
 	}
-};
-const isTerminalResponsesStreamChunk = (chunk) => {
-	if (!chunk.data || chunk.data === "[DONE]") return false;
-	try {
-		const parsed = JSON.parse(chunk.data);
-		return parsed.type === "response.completed" || parsed.type === "response.failed" || parsed.type === "response.incomplete" || parsed.type === "error";
-	} catch {
-		return false;
+	const anthropicResult = await countTokensViaAnthropic(c, anthropicPayload);
+	if (anthropicResult) return anthropicResult;
+	const anthropicBeta = c.req.header("anthropic-beta");
+	const openAIPayload = translateToOpenAI(anthropicPayload);
+	const requestedModel = anthropicPayload.model;
+	const resolve = resolveCountTokensModel(requestedModel);
+	const selectedModel = resolve.model;
+	anthropicPayload.model = selectedModel.id;
+	if (resolve.fallback) consola.warn(`Model '${requestedModel}' not found, using o200k_base fallback tokenizer`);
+	const tokenCount = await getTokenCount(openAIPayload, selectedModel);
+	if (anthropicPayload.tools && anthropicPayload.tools.length > 0) {
+		let addToolSystemPromptCount = false;
+		if (anthropicBeta) {
+			const toolsLength = anthropicPayload.tools.length;
+			addToolSystemPromptCount = !anthropicPayload.tools.some((tool) => tool.name.startsWith("mcp__") || tool.name === "Skill" && toolsLength === 1);
+		}
+		if (addToolSystemPromptCount) {
+			if (anthropicPayload.model.startsWith("claude")) tokenCount.input = tokenCount.input + 346;
+			else if (anthropicPayload.model.startsWith("grok")) tokenCount.input = tokenCount.input + 120;
+		}
 	}
-};
+	let finalTokenCount = tokenCount.input + tokenCount.output;
+	if (anthropicPayload.model.startsWith("claude")) finalTokenCount = Math.round(finalTokenCount * getClaudeTokenMultiplier());
+	consola.info("Token count:", finalTokenCount);
+	return c.json({ input_tokens: finalTokenCount });
+}
 //#endregion
-//#region src/routes/messages/responses-translation.ts
-const MESSAGE_TYPE = "message";
-const COMPACTION_SIGNATURE_PREFIX = "cm1#";
-const COMPACTION_SIGNATURE_SEPARATOR = "@";
-const THINKING_TEXT = "Thinking...";
-const buildPromptCacheKey = (basePromptCacheKey, subagentAgentId) => {
-	if (!basePromptCacheKey) return null;
-	const normalizedSubagentAgentId = subagentAgentId?.trim() || null;
-	if (!normalizedSubagentAgentId) return basePromptCacheKey;
-	return `${basePromptCacheKey}:agent:${normalizedSubagentAgentId}`;
-};
-const translateAnthropicMessagesToResponsesPayload = (payload, subagentAgentId) => {
-	const input = [];
-	const applyPhase = shouldApplyPhase(payload.model);
-	const toolSearchEnabled = shouldEnableResponsesToolSearch({
-		model: payload.model,
-		tools: payload.tools
-	});
-	const translationState = {
-		originalTools: payload.tools ?? [],
-		toolSearchEnabled,
-		toolUseNameById: /* @__PURE__ */ new Map()
-	};
-	for (const message of payload.messages) input.push(...translateMessage(message, payload.model, applyPhase, translationState));
-	const hasOriginalTools = Array.isArray(payload.tools) && payload.tools.length > 0;
-	const translatedTools = convertAnthropicTools(payload.tools, toolSearchEnabled);
-	const toolChoice = convertAnthropicToolChoice(payload.tool_choice, toolSearchEnabled);
-	const { sessionId: metadataPromptCacheKey } = parseUserIdMetadata(payload.metadata?.user_id);
-	const sessionAffinity = requestContext.getStore()?.sessionAffinity?.trim() || null;
-	const promptCacheKey = buildPromptCacheKey(metadataPromptCacheKey ?? sessionAffinity, subagentAgentId);
-	const responsesPayload = {
-		model: payload.model,
-		input,
-		instructions: translateSystemPrompt(payload.system, payload.model),
-		temperature: 1,
-		top_p: payload.top_p ?? null,
-		max_output_tokens: Math.max(payload.max_tokens, 12800),
-		tools: translatedTools,
-		tool_choice: toolChoice,
-		metadata: payload.metadata ? { ...payload.metadata } : null,
-		stream: payload.stream ?? null,
-		store: false,
-		parallel_tool_calls: true,
-		reasoning: {
-			effort: getReasoningEffortForModel(payload.model),
-			summary: "detailed"
-		},
-		include: ["reasoning.encrypted_content"]
-	};
-	if (hasOriginalTools) responsesPayload.prompt_cache_key = promptCacheKey;
-	return responsesPayload;
-};
-const encodeCompactionCarrierSignature = (compaction) => {
-	return `${COMPACTION_SIGNATURE_PREFIX}${compaction.encrypted_content}${COMPACTION_SIGNATURE_SEPARATOR}${compaction.id}`;
+//#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 decodeCompactionCarrierSignature = (signature) => {
-	if (signature.startsWith(COMPACTION_SIGNATURE_PREFIX)) {
-		const raw = signature.slice(4);
-		const separatorIndex = raw.indexOf(COMPACTION_SIGNATURE_SEPARATOR);
-		if (separatorIndex <= 0 || separatorIndex === raw.length - 1) return;
-		const encrypted_content = raw.slice(0, separatorIndex);
-		const id = raw.slice(separatorIndex + 1);
-		if (!encrypted_content) return;
-		return {
-			id,
-			encrypted_content
-		};
+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 translateMessage = (message, model, applyPhase, state) => {
-	if (message.role === "user") return translateUserMessage(message, state);
-	return translateAssistantMessage(message, model, applyPhase, state);
-};
-const translateUserMessage = (message, state) => {
-	if (typeof message.content === "string") return [createMessage("user", message.content)];
-	if (!Array.isArray(message.content)) return [];
-	const items = [];
-	const pendingContent = [];
-	for (const block of message.content) {
-		if (block.type === "tool_result") {
-			flushPendingContent(pendingContent, items, { role: "user" });
-			items.push(createToolCallOutput(block, state));
-			continue;
-		}
-		const converted = translateUserContentBlock(block);
-		if (converted.length > 0) pendingContent.push(...converted);
-	}
-	flushPendingContent(pendingContent, items, { role: "user" });
-	return items;
+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";
 };
-const translateAssistantMessage = (message, model, applyPhase, state) => {
-	const assistantPhase = resolveAssistantPhase(model, message.content, applyPhase);
-	if (typeof message.content === "string") return [createMessage("assistant", message.content, assistantPhase)];
-	if (!Array.isArray(message.content)) return [];
-	const items = [];
-	const pendingContent = [];
-	for (const block of message.content) {
-		if (block.type === "tool_use") {
-			state.toolUseNameById.set(block.id, block.name);
-			flushPendingContent(pendingContent, items, {
-				role: "assistant",
-				phase: assistantPhase
+//#endregion
+//#region src/routes/messages/stream-translation.ts
+function isToolBlockOpen(state) {
+	if (!state.contentBlockOpen) return false;
+	return Object.values(state.toolCalls).some((tc) => tc.anthropicBlockIndex === state.contentBlockIndex);
+}
+function translateChunkToAnthropicEvents(chunk, state) {
+	const events = [];
+	if (chunk.choices.length === 0) {
+		completePendingMessage(state, events, chunk);
+		return events;
+	}
+	const choice = chunk.choices[0];
+	const { delta } = choice;
+	handleMessageStart(state, events, chunk);
+	handleThinkingText(delta, state, events);
+	handleContent(delta, state, events);
+	handleToolCalls(delta, state, events);
+	handleFinish(choice, state, {
+		events,
+		chunk
+	});
+	return events;
+}
+function flushPendingAnthropicStreamEvents(state) {
+	const events = [];
+	completePendingMessage(state, events);
+	return events;
+}
+function completePendingMessage(state, events, chunk) {
+	if (!state.pendingMessageDelta) return;
+	if (chunk?.usage) state.pendingMessageDelta.usage = getAnthropicUsageFromOpenAIChunk(chunk);
+	events.push(state.pendingMessageDelta, { type: "message_stop" });
+	state.pendingMessageDelta = void 0;
+}
+function handleFinish(choice, state, context) {
+	const { events, chunk } = context;
+	if (choice.finish_reason && choice.finish_reason.length > 0) {
+		if (state.contentBlockOpen) {
+			const toolBlockOpen = isToolBlockOpen(state);
+			context.events.push({
+				type: "content_block_stop",
+				index: state.contentBlockIndex
 			});
-			items.push(createToolCall(block, state));
-			continue;
+			state.contentBlockOpen = false;
+			state.contentBlockIndex++;
+			if (!toolBlockOpen) handleReasoningOpaque(choice.delta, events, state);
 		}
-		if (block.type === "thinking" && block.signature) {
-			const compactionContent = createCompactionContent(block);
-			if (compactionContent) {
-				flushPendingContent(pendingContent, items, {
-					role: "assistant",
-					phase: assistantPhase
+		flushDeferredContent(state, events);
+		state.pendingMessageDelta = {
+			type: "message_delta",
+			delta: {
+				stop_reason: mapOpenAIStopReasonToAnthropic(choice.finish_reason),
+				stop_sequence: null
+			},
+			usage: getAnthropicUsageFromOpenAIChunk(chunk)
+		};
+		if (chunk.usage) completePendingMessage(state, events, chunk);
+	}
+}
+function getAnthropicUsageFromOpenAIChunk(chunk) {
+	const { cachedTokens, cacheCreationTokens, inputTokens } = getOpenAIChunkUsageTokens(chunk);
+	return {
+		input_tokens: inputTokens,
+		output_tokens: chunk.usage?.completion_tokens ?? 0,
+		...chunk.usage?.prompt_tokens_details?.cache_creation_input_tokens !== void 0 && { cache_creation_input_tokens: cacheCreationTokens },
+		...chunk.usage?.prompt_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: cachedTokens }
+	};
+}
+function getOpenAIChunkUsageTokens(chunk) {
+	const promptTokens = chunk.usage?.prompt_tokens ?? 0;
+	const cachedTokens = chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0;
+	const cacheCreationTokens = chunk.usage?.prompt_tokens_details?.cache_creation_input_tokens ?? 0;
+	return {
+		cacheCreationTokens,
+		cachedTokens,
+		inputTokens: Math.max(0, promptTokens - cachedTokens - cacheCreationTokens)
+	};
+}
+function handleToolCalls(delta, state, events) {
+	if (delta.tool_calls && delta.tool_calls.length > 0) {
+		closeThinkingBlockIfOpen(state, events);
+		handleReasoningOpaqueInToolCalls(state, events, delta);
+		for (const toolCall of delta.tool_calls) {
+			if (toolCall.id && toolCall.function?.name) {
+				if (state.contentBlockOpen) {
+					events.push({
+						type: "content_block_stop",
+						index: state.contentBlockIndex
+					});
+					state.contentBlockIndex++;
+					state.contentBlockOpen = false;
+				}
+				const anthropicBlockIndex = state.contentBlockIndex;
+				state.toolCalls[toolCall.index] = {
+					id: toolCall.id,
+					name: toolCall.function.name,
+					anthropicBlockIndex
+				};
+				events.push({
+					type: "content_block_start",
+					index: anthropicBlockIndex,
+					content_block: {
+						type: "tool_use",
+						id: toolCall.id,
+						name: toolCall.function.name,
+						input: {}
+					}
 				});
-				items.push(compactionContent);
-				continue;
+				state.contentBlockOpen = true;
 			}
-			if (block.signature.includes("@")) {
-				flushPendingContent(pendingContent, items, {
-					role: "assistant",
-					phase: assistantPhase
+			if (toolCall.function?.arguments) {
+				const toolCallInfo = state.toolCalls[toolCall.index];
+				if (toolCallInfo) events.push({
+					type: "content_block_delta",
+					index: toolCallInfo.anthropicBlockIndex,
+					delta: {
+						type: "input_json_delta",
+						partial_json: toolCall.function.arguments
+					}
 				});
-				items.push(createReasoningContent(block));
-				continue;
 			}
 		}
-		const converted = translateAssistantContentBlock(block);
-		if (converted) pendingContent.push(converted);
 	}
-	flushPendingContent(pendingContent, items, {
-		role: "assistant",
-		phase: assistantPhase
-	});
-	return items;
-};
-const translateUserContentBlock = (block) => {
-	switch (block.type) {
-		case "text": return [createTextContent(block.text)];
-		case "image": return [createImageContent(block)];
-		case "document": return [createFileContent(block)];
-		default: return [];
+}
+function handleReasoningOpaqueInToolCalls(state, events, delta) {
+	if (state.contentBlockOpen && !isToolBlockOpen(state)) {
+		events.push({
+			type: "content_block_stop",
+			index: state.contentBlockIndex
+		});
+		state.contentBlockIndex++;
+		state.contentBlockOpen = false;
 	}
-};
-const translateAssistantContentBlock = (block) => {
-	switch (block.type) {
-		case "text": return createOutPutTextContent(block.text);
-		default: return;
+	handleReasoningOpaque(delta, events, state);
+}
+function handleContent(delta, state, events) {
+	if (delta.content && delta.content.length > 0) {
+		closeThinkingBlockIfOpen(state, events);
+		if (isToolBlockOpen(state) || hasToolCallDelta(delta)) {
+			state.deferredContent = `${state.deferredContent ?? ""}${delta.content}`;
+			return;
+		}
+		if (!state.contentBlockOpen) {
+			events.push({
+				type: "content_block_start",
+				index: state.contentBlockIndex,
+				content_block: {
+					type: "text",
+					text: ""
+				}
+			});
+			state.contentBlockOpen = true;
+		}
+		events.push({
+			type: "content_block_delta",
+			index: state.contentBlockIndex,
+			delta: {
+				type: "text_delta",
+				text: delta.content
+			}
+		});
 	}
-};
-const flushPendingContent = (pendingContent, target, message) => {
-	if (pendingContent.length === 0) return;
-	const messageContent = [...pendingContent];
-	target.push(createMessage(message.role, messageContent, message.phase));
-	pendingContent.length = 0;
-};
-const createMessage = (role, content, phase) => ({
-	type: MESSAGE_TYPE,
-	role,
-	content,
-	...role === "assistant" && phase ? { phase } : {}
-});
-const resolveAssistantPhase = (_model, content, applyPhase) => {
-	if (!applyPhase) return;
-	if (typeof content === "string") return "final_answer";
-	if (!Array.isArray(content)) return;
-	if (!content.some((block) => block.type === "text")) return;
-	return content.some((block) => block.type === "tool_use") ? "commentary" : "final_answer";
-};
-const shouldApplyPhase = (_model) => {
-	return true;
-};
-const createTextContent = (text) => ({
-	type: "input_text",
-	text
-});
-const createOutPutTextContent = (text) => ({
-	type: "output_text",
-	text
-});
-const createImageContent = (block) => ({
-	type: "input_image",
-	image_url: `data:${block.source.media_type};base64,${block.source.data}`,
-	detail: "auto"
-});
-const createFileContent = (block) => ({
-	type: "input_file",
-	file_data: `data:${block.source.media_type};base64,${block.source.data}`,
-	filename: block.title ?? "document.pdf"
-});
-const createReasoningContent = (block) => {
-	const { encryptedContent, id } = parseReasoningSignature(block.signature);
-	const thinking = block.thinking === "Thinking..." ? "" : block.thinking;
-	return {
-		id,
-		type: "reasoning",
-		summary: thinking ? [{
-			type: "summary_text",
-			text: thinking
-		}] : [],
-		encrypted_content: encryptedContent
-	};
-};
-const createCompactionContent = (block) => {
-	const compaction = decodeCompactionCarrierSignature(block.signature);
-	if (!compaction) return;
-	return {
-		id: compaction.id,
-		type: "compaction",
-		encrypted_content: compaction.encrypted_content
+	if (delta.content === "" && delta.reasoning_opaque && delta.reasoning_opaque.length > 0 && state.thinkingBlockOpen) {
+		events.push({
+			type: "content_block_delta",
+			index: state.contentBlockIndex,
+			delta: {
+				type: "signature_delta",
+				signature: delta.reasoning_opaque
+			}
+		}, {
+			type: "content_block_stop",
+			index: state.contentBlockIndex
+		});
+		state.contentBlockIndex++;
+		state.thinkingBlockOpen = false;
+	}
+}
+function hasToolCallDelta(delta) {
+	return Boolean(delta.tool_calls && delta.tool_calls.length > 0);
+}
+function flushDeferredContent(state, events) {
+	if (!state.deferredContent) return;
+	if (!state.contentBlockOpen) {
+		events.push({
+			type: "content_block_start",
+			index: state.contentBlockIndex,
+			content_block: {
+				type: "text",
+				text: ""
+			}
+		});
+		state.contentBlockOpen = true;
+	}
+	events.push({
+		type: "content_block_delta",
+		index: state.contentBlockIndex,
+		delta: {
+			type: "text_delta",
+			text: state.deferredContent
+		}
+	}, {
+		type: "content_block_stop",
+		index: state.contentBlockIndex
+	});
+	state.deferredContent = void 0;
+	state.contentBlockOpen = false;
+	state.contentBlockIndex++;
+}
+function handleMessageStart(state, events, chunk) {
+	if (!state.messageStartSent) {
+		const { cachedTokens, cacheCreationTokens, inputTokens } = getOpenAIChunkUsageTokens(chunk);
+		events.push({
+			type: "message_start",
+			message: {
+				id: chunk.id,
+				type: "message",
+				role: "assistant",
+				content: [],
+				model: chunk.model,
+				stop_reason: null,
+				stop_sequence: null,
+				usage: {
+					input_tokens: inputTokens,
+					output_tokens: 0,
+					...chunk.usage?.prompt_tokens_details?.cache_creation_input_tokens !== void 0 && { cache_creation_input_tokens: cacheCreationTokens },
+					...chunk.usage?.prompt_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: cachedTokens }
+				}
+			}
+		});
+		state.messageStartSent = true;
+	}
+}
+function handleReasoningOpaque(delta, events, state) {
+	if (delta.reasoning_opaque && delta.reasoning_opaque.length > 0) {
+		events.push({
+			type: "content_block_start",
+			index: state.contentBlockIndex,
+			content_block: {
+				type: "thinking",
+				thinking: ""
+			}
+		}, {
+			type: "content_block_delta",
+			index: state.contentBlockIndex,
+			delta: {
+				type: "thinking_delta",
+				thinking: THINKING_TEXT$1
+			}
+		}, {
+			type: "content_block_delta",
+			index: state.contentBlockIndex,
+			delta: {
+				type: "signature_delta",
+				signature: delta.reasoning_opaque
+			}
+		}, {
+			type: "content_block_stop",
+			index: state.contentBlockIndex
+		});
+		state.contentBlockIndex++;
+	}
+}
+function handleThinkingText(delta, state, events) {
+	const reasoningText = delta.reasoning_text ?? delta.reasoning_content;
+	if (reasoningText && reasoningText.length > 0) {
+		if (state.contentBlockOpen) {
+			delta.content = reasoningText;
+			delta.reasoning_text = void 0;
+			delta.reasoning_content = void 0;
+			return;
+		}
+		if (!state.thinkingBlockOpen) {
+			events.push({
+				type: "content_block_start",
+				index: state.contentBlockIndex,
+				content_block: {
+					type: "thinking",
+					thinking: ""
+				}
+			});
+			state.thinkingBlockOpen = true;
+		}
+		events.push({
+			type: "content_block_delta",
+			index: state.contentBlockIndex,
+			delta: {
+				type: "thinking_delta",
+				thinking: reasoningText
+			}
+		});
+	}
+}
+function closeThinkingBlockIfOpen(state, events) {
+	if (state.thinkingBlockOpen) {
+		events.push({
+			type: "content_block_delta",
+			index: state.contentBlockIndex,
+			delta: {
+				type: "signature_delta",
+				signature: ""
+			}
+		}, {
+			type: "content_block_stop",
+			index: state.contentBlockIndex
+		});
+		state.contentBlockIndex++;
+		state.thinkingBlockOpen = false;
+	}
+}
+//#endregion
+//#region src/services/copilot/create-responses.ts
+const createResponses = async (payload, { vision, initiator, subagentMarker, requestId, sessionId, compactType, transport = "http" }) => {
+	if (!state.copilotToken) throw new Error("Copilot token not found");
+	const headers = {
+		...copilotHeaders(state, requestId, vision),
+		"x-initiator": initiator
 	};
+	prepareInteractionHeaders(sessionId, Boolean(subagentMarker), headers);
+	prepareForCompact(headers, compactType);
+	payload.service_tier = void 0;
+	consola.log(`<-- model: ${payload.model}`);
+	const effectiveTransport = compactType === 1 ? "http" : transport;
+	if (payload.stream === true && effectiveTransport === "websocket") return createPooledResponsesWebSocketStream(prepareResponsesWebSocketRequest(payload, headers, {
+		requestId,
+		subagentMarker
+	}));
+	return await createHttpResponses(payload, headers);
 };
-const parseReasoningSignature = (signature) => {
-	const splitIndex = signature.lastIndexOf("@");
-	if (splitIndex <= 0 || splitIndex === signature.length - 1) return {
-		encryptedContent: signature,
-		id: ""
-	};
+const createHttpResponses = async (payload, headers) => {
+	const response = await fetch(`${copilotBaseUrl(state)}/responses`, {
+		method: "POST",
+		headers,
+		body: JSON.stringify(payload)
+	});
+	logCopilotRateLimits(response.headers);
+	if (!response.ok) {
+		consola.error("Failed to create responses", response);
+		throw new HTTPError("Failed to create responses", response);
+	}
+	if (payload.stream) return events(response);
+	return await response.json();
+};
+const prepareResponsesWebSocketRequest = (payload, preparedHeaders, options) => {
+	const initiator = getResponsesWebSocketInitiator(preparedHeaders);
 	return {
-		encryptedContent: signature.slice(0, splitIndex),
-		id: signature.slice(splitIndex + 1)
+		headers: copilotWebSocketHeaders(preparedHeaders),
+		poolKey: buildResponsesWebSocketPoolKey(payload, options),
+		payload: buildResponsesWebSocketPayload(payload, initiator),
+		url: buildResponsesWebSocketUrl(copilotBaseUrl(state))
 	};
 };
-const createFunctionToolCall = (block, state) => ({
-	type: "function_call",
-	call_id: block.id,
-	name: block.name,
-	arguments: JSON.stringify(block.input),
-	status: "completed",
-	...state.toolSearchEnabled && isDeferredToolName(block.name) ? { namespace: block.name } : {}
-});
-const createToolSearchCall = (block) => ({
-	type: "tool_search_call",
-	call_id: block.id,
-	arguments: normalizeToolSearchBridgeArguments(block.input),
-	execution: "client",
-	status: "completed"
-});
-const createToolCall = (block, state) => {
-	if (state.toolSearchEnabled && isBridgeToolSearchName(block.name)) return createToolSearchCall(block);
-	return createFunctionToolCall(block, state);
+const buildResponsesWebSocketPoolKey = (payload, { requestId, subagentMarker }) => {
+	const tokenFingerprint = state.copilotToken ? createHash("sha256").update(state.copilotToken).digest("hex").slice(0, 16) : "missing-token";
+	const subagentKey = subagentMarker ? [
+		subagentMarker.session_id,
+		subagentMarker.agent_id,
+		subagentMarker.agent_type
+	].join(":") : "main";
+	return [
+		tokenFingerprint,
+		payload.model,
+		requestId,
+		subagentKey
+	].map(encodePoolKeyPart).join("|");
 };
-const createFunctionCallOutput = (block) => ({
-	type: "function_call_output",
-	call_id: block.tool_use_id,
-	output: convertToolResultContent(block.content),
-	status: block.is_error ? "incomplete" : "completed"
+const getResponsesWebSocketInitiator = (preparedHeaders) => {
+	return getHeaderValue(preparedHeaders, "x-initiator")?.toLowerCase() === "agent" ? "agent" : "user";
+};
+const createPooledResponsesWebSocketStream = (request) => createPooledWebSocketStream(request, {
+	createChunk: createResponsesWebSocketStreamChunk,
+	isTerminalChunk: isTerminalResponsesStreamChunk,
+	openErrorMessage: "Failed to create responses websocket",
+	streamErrorMessage: "Responses websocket stream error",
+	terminalChunkMissingMessage: "Responses websocket ended without a terminal response"
 });
-const createToolCallOutput = (block, state) => {
-	const toolUseName = state.toolUseNameById.get(block.tool_use_id);
-	if (state.toolSearchEnabled && isBridgeToolSearchName(toolUseName ?? "")) return createToolSearchOutput(block, state.originalTools);
-	return createFunctionCallOutput(block);
+const buildResponsesWebSocketPayload = (payload, initiator) => {
+	const websocketPayload = {
+		...payload,
+		type: "response.create",
+		initiator
+	};
+	delete websocketPayload.stream;
+	delete websocketPayload["background"];
+	delete websocketPayload.service_tier;
+	return websocketPayload;
 };
-const createToolSearchOutput = (block, originalTools) => {
-	const referencedToolNames = resolveToolSearchReferencedToolNames(block.content, originalTools);
-	return {
-		type: "tool_search_output",
-		call_id: block.tool_use_id,
-		tools: referencedToolNames.map((toolName) => convertDeferredToolToNamespace(resolveDeferredTool(toolName, originalTools))),
-		execution: "client",
-		status: block.is_error ? "incomplete" : "completed"
-	};
+const buildResponsesWebSocketUrl = (baseUrl) => {
+	return createWebSocketUrl(`${baseUrl.replace(/\/+$/u, "")}/responses`);
 };
-const resolveToolSearchReferencedToolNames = (content, originalTools) => {
-	const explicitReferences = extractToolReferenceNames(content);
-	if (explicitReferences.length > 0) return uniqueToolNames(explicitReferences);
-	const sentinel = extractMcpToolSearchSentinel(content);
-	if (sentinel) return selectDeferredToolsByNames(sentinel.names, originalTools).map((tool) => tool.name);
-	return [];
+const getHeaderValue = (headers, headerName) => {
+	const normalizedHeaderName = headerName.toLowerCase();
+	return Object.entries(headers).find(([key]) => key.toLowerCase() === normalizedHeaderName)?.[1];
 };
-const extractToolReferenceNames = (content) => {
-	if (!Array.isArray(content)) return [];
-	return content.flatMap((block) => block.type === "tool_reference" ? [block.tool_name] : []);
+const encodePoolKeyPart = (value) => encodeURIComponent(value);
+const createResponsesWebSocketStreamChunk = (data) => {
+	if (data === "[DONE]") return { data };
+	try {
+		const parsed = JSON.parse(data);
+		if (parsed.type === "response.completed") logCopilotQuotaSnapshots(parsed.copilot_quota_snapshots);
+		return {
+			data: JSON.stringify(parsed),
+			event: typeof parsed.type === "string" ? parsed.type : void 0,
+			id: typeof parsed.id === "string" ? parsed.id : void 0
+		};
+	} catch {
+		return { data };
+	}
 };
-const extractMcpToolSearchSentinel = (content) => {
-	if (typeof content === "string") return parseMcpToolSearchSentinel(content);
-	for (const block of content) {
-		if (block.type !== "text") continue;
-		const sentinel = parseMcpToolSearchSentinel(block.text);
-		if (sentinel) return sentinel;
+const isTerminalResponsesStreamChunk = (chunk) => {
+	if (!chunk.data || chunk.data === "[DONE]") return false;
+	try {
+		const parsed = JSON.parse(chunk.data);
+		return parsed.type === "response.completed" || parsed.type === "response.failed" || parsed.type === "response.incomplete" || parsed.type === "error";
+	} catch {
+		return false;
 	}
-	return null;
 };
-const resolveDeferredTool = (toolName, originalTools) => {
-	const tool = originalTools.find((candidate) => candidate.name === toolName);
-	if (tool && isDeferredToolName(tool.name)) return tool;
-	throw createInvalidRequestError(`Tool reference '${toolName}' has no corresponding deferred tool definition`);
+//#endregion
+//#region src/routes/messages/responses-translation.ts
+const MESSAGE_TYPE = "message";
+const COMPACTION_SIGNATURE_PREFIX = "cm1#";
+const COMPACTION_SIGNATURE_SEPARATOR = "@";
+const THINKING_TEXT = "Thinking...";
+const buildPromptCacheKey = (basePromptCacheKey, subagentAgentId) => {
+	if (!basePromptCacheKey) return null;
+	const normalizedSubagentAgentId = subagentAgentId?.trim() || null;
+	if (!normalizedSubagentAgentId) return basePromptCacheKey;
+	return `${basePromptCacheKey}:agent:${normalizedSubagentAgentId}`;
 };
-const uniqueToolNames = (toolNames) => [...new Set(toolNames)];
-const createInvalidRequestError = (message) => new HTTPError(message, new Response(JSON.stringify({ error: {
-	message,
-	type: "invalid_request_error"
-} }), {
-	status: 400,
-	headers: { "content-type": "application/json" }
-}));
-const translateSystemPrompt = (system, model) => {
-	if (!system) return null;
-	const extraPrompt = getExtraPromptForModel(model);
-	if (typeof system === "string") return system + extraPrompt;
-	const text = system.map((block, index) => {
-		if (index === 0) return block.text + "\n\n" + extraPrompt + "\n\n";
-		return block.text;
-	}).join(" ");
-	return text.length > 0 ? text : null;
+const translateAnthropicMessagesToResponsesPayload = (payload, subagentAgentId) => {
+	const input = [];
+	const applyPhase = shouldApplyPhase(payload.model);
+	const toolSearchEnabled = shouldEnableResponsesToolSearch({
+		model: payload.model,
+		tools: payload.tools
+	});
+	const translationState = {
+		originalTools: payload.tools ?? [],
+		toolSearchEnabled,
+		toolUseNameById: /* @__PURE__ */ new Map()
+	};
+	for (const message of payload.messages) input.push(...translateMessage(message, payload.model, applyPhase, translationState));
+	const hasOriginalTools = Array.isArray(payload.tools) && payload.tools.length > 0;
+	const translatedTools = convertAnthropicTools(payload.tools, toolSearchEnabled);
+	const toolChoice = convertAnthropicToolChoice(payload.tool_choice, toolSearchEnabled);
+	const { sessionId: metadataPromptCacheKey } = parseUserIdMetadata(payload.metadata?.user_id);
+	const sessionAffinity = requestContext.getStore()?.sessionAffinity?.trim() || null;
+	const promptCacheKey = buildPromptCacheKey(metadataPromptCacheKey ?? sessionAffinity, subagentAgentId);
+	const responsesPayload = {
+		model: payload.model,
+		input,
+		instructions: translateSystemPrompt(payload.system, payload.model),
+		temperature: 1,
+		top_p: payload.top_p ?? null,
+		max_output_tokens: Math.max(payload.max_tokens, 12800),
+		tools: translatedTools,
+		tool_choice: toolChoice,
+		metadata: payload.metadata ? { ...payload.metadata } : null,
+		stream: payload.stream ?? null,
+		store: false,
+		parallel_tool_calls: true,
+		reasoning: {
+			effort: getReasoningEffortForModel(payload.model),
+			summary: "detailed"
+		},
+		include: ["reasoning.encrypted_content"]
+	};
+	if (hasOriginalTools) responsesPayload.prompt_cache_key = promptCacheKey;
+	return responsesPayload;
 };
-const convertAnthropicTools = (tools, toolSearchEnabled) => {
-	if (!tools || tools.length === 0) return null;
-	const converted = [];
-	let addedToolSearch = false;
-	const searchableToolNames = toolSearchEnabled ? listDeferredToolNames(tools) : [];
-	for (const tool of tools) {
-		if (isBridgeToolSearchName(tool.name)) {
-			if (toolSearchEnabled && !addedToolSearch) {
-				converted.push(createResponsesToolSearchDefinition(searchableToolNames));
-				addedToolSearch = true;
-			}
+const encodeCompactionCarrierSignature = (compaction) => {
+	return `${COMPACTION_SIGNATURE_PREFIX}${compaction.encrypted_content}${COMPACTION_SIGNATURE_SEPARATOR}${compaction.id}`;
+};
+const decodeCompactionCarrierSignature = (signature) => {
+	if (signature.startsWith(COMPACTION_SIGNATURE_PREFIX)) {
+		const raw = signature.slice(4);
+		const separatorIndex = raw.indexOf(COMPACTION_SIGNATURE_SEPARATOR);
+		if (separatorIndex <= 0 || separatorIndex === raw.length - 1) return;
+		const encrypted_content = raw.slice(0, separatorIndex);
+		const id = raw.slice(separatorIndex + 1);
+		if (!encrypted_content) return;
+		return {
+			id,
+			encrypted_content
+		};
+	}
+};
+const translateMessage = (message, model, applyPhase, state) => {
+	if (message.role === "user") return translateUserMessage(message, state);
+	return translateAssistantMessage(message, model, applyPhase, state);
+};
+const translateUserMessage = (message, state) => {
+	if (typeof message.content === "string") return [createMessage("user", message.content)];
+	if (!Array.isArray(message.content)) return [];
+	const items = [];
+	const pendingContent = [];
+	for (const block of message.content) {
+		if (block.type === "tool_result") {
+			flushPendingContent(pendingContent, items, { role: "user" });
+			items.push(createToolCallOutput(block, state));
 			continue;
 		}
-		if (toolSearchEnabled && isDeferredToolName(tool.name)) {
-			converted.push(convertDeferredToolToNamespace(tool));
+		const converted = translateUserContentBlock(block);
+		if (converted.length > 0) pendingContent.push(...converted);
+	}
+	flushPendingContent(pendingContent, items, { role: "user" });
+	return items;
+};
+const translateAssistantMessage = (message, model, applyPhase, state) => {
+	const assistantPhase = resolveAssistantPhase(model, message.content, applyPhase);
+	if (typeof message.content === "string") return [createMessage("assistant", message.content, assistantPhase)];
+	if (!Array.isArray(message.content)) return [];
+	const items = [];
+	const pendingContent = [];
+	for (const block of message.content) {
+		if (block.type === "tool_use") {
+			state.toolUseNameById.set(block.id, block.name);
+			flushPendingContent(pendingContent, items, {
+				role: "assistant",
+				phase: assistantPhase
+			});
+			items.push(createToolCall(block, state));
 			continue;
 		}
-		converted.push(convertToolToFunction(tool));
+		if (block.type === "thinking" && block.signature) {
+			const compactionContent = createCompactionContent(block);
+			if (compactionContent) {
+				flushPendingContent(pendingContent, items, {
+					role: "assistant",
+					phase: assistantPhase
+				});
+				items.push(compactionContent);
+				continue;
+			}
+			if (block.signature.includes("@")) {
+				flushPendingContent(pendingContent, items, {
+					role: "assistant",
+					phase: assistantPhase
+				});
+				items.push(createReasoningContent(block));
+				continue;
+			}
+		}
+		const converted = translateAssistantContentBlock(block);
+		if (converted) pendingContent.push(converted);
 	}
-	return converted;
+	flushPendingContent(pendingContent, items, {
+		role: "assistant",
+		phase: assistantPhase
+	});
+	return items;
 };
-const createResponsesToolSearchDefinition = (searchableToolNames) => ({
-	type: "tool_search",
-	execution: "client",
-	description: "Load deferred tools by exact name before using them. Return only the searchable tool names you need for the next step.",
-	parameters: {
-		type: "object",
-		properties: { names: {
-			type: "array",
-			description: "Exact deferred tool names to load.",
-			items: {
-				type: "string",
-				enum: searchableToolNames
-			},
-			minItems: 1
-		} },
-		required: ["names"],
-		additionalProperties: false
+const translateUserContentBlock = (block) => {
+	switch (block.type) {
+		case "text": return [createTextContent(block.text)];
+		case "image": return [createImageContent(block)];
+		case "document": return [createFileContent(block)];
+		default: return [];
+	}
+};
+const translateAssistantContentBlock = (block) => {
+	switch (block.type) {
+		case "text": return createOutPutTextContent(block.text);
+		default: return;
 	}
+};
+const flushPendingContent = (pendingContent, target, message) => {
+	if (pendingContent.length === 0) return;
+	const messageContent = [...pendingContent];
+	target.push(createMessage(message.role, messageContent, message.phase));
+	pendingContent.length = 0;
+};
+const createMessage = (role, content, phase) => ({
+	type: MESSAGE_TYPE,
+	role,
+	content,
+	...role === "assistant" && phase ? { phase } : {}
 });
-const convertToolToFunction = (tool) => ({
-	type: "function",
-	name: tool.name,
+const resolveAssistantPhase = (_model, content, applyPhase) => {
+	if (!applyPhase) return;
+	if (typeof content === "string") return "final_answer";
+	if (!Array.isArray(content)) return;
+	if (!content.some((block) => block.type === "text")) return;
+	return content.some((block) => block.type === "tool_use") ? "commentary" : "final_answer";
+};
+const shouldApplyPhase = (_model) => {
+	return true;
+};
+const createTextContent = (text) => ({
+	type: "input_text",
+	text
+});
+const createOutPutTextContent = (text) => ({
+	type: "output_text",
+	text
+});
+const createImageContent = (block) => ({
+	type: "input_image",
+	image_url: `data:${block.source.media_type};base64,${block.source.data}`,
+	detail: "auto"
+});
+const createFileContent = (block) => ({
+	type: "input_file",
+	file_data: `data:${block.source.media_type};base64,${block.source.data}`,
+	filename: block.title ?? "document.pdf"
+});
+const createReasoningContent = (block) => {
+	const { encryptedContent, id } = parseReasoningSignature(block.signature);
+	const thinking = block.thinking === "Thinking..." ? "" : block.thinking;
+	return {
+		id,
+		type: "reasoning",
+		summary: thinking ? [{
+			type: "summary_text",
+			text: thinking
+		}] : [],
+		encrypted_content: encryptedContent
+	};
+};
+const createCompactionContent = (block) => {
+	const compaction = decodeCompactionCarrierSignature(block.signature);
+	if (!compaction) return;
+	return {
+		id: compaction.id,
+		type: "compaction",
+		encrypted_content: compaction.encrypted_content
+	};
+};
+const parseReasoningSignature = (signature) => {
+	const splitIndex = signature.lastIndexOf("@");
+	if (splitIndex <= 0 || splitIndex === signature.length - 1) return {
+		encryptedContent: signature,
+		id: ""
+	};
+	return {
+		encryptedContent: signature.slice(0, splitIndex),
+		id: signature.slice(splitIndex + 1)
+	};
+};
+const createFunctionToolCall = (block, state) => ({
+	type: "function_call",
+	call_id: block.id,
+	name: block.name,
+	arguments: JSON.stringify(block.input),
+	status: "completed",
+	...state.toolSearchEnabled && isDeferredToolName(block.name) ? { namespace: block.name } : {}
+});
+const createToolSearchCall = (block) => ({
+	type: "tool_search_call",
+	call_id: block.id,
+	arguments: normalizeToolSearchBridgeArguments(block.input),
+	execution: "client",
+	status: "completed"
+});
+const createToolCall = (block, state) => {
+	if (state.toolSearchEnabled && isBridgeToolSearchName(block.name)) return createToolSearchCall(block);
+	return createFunctionToolCall(block, state);
+};
+const createFunctionCallOutput = (block) => ({
+	type: "function_call_output",
+	call_id: block.tool_use_id,
+	output: convertToolResultContent(block.content),
+	status: block.is_error ? "incomplete" : "completed"
+});
+const createToolCallOutput = (block, state) => {
+	const toolUseName = state.toolUseNameById.get(block.tool_use_id);
+	if (state.toolSearchEnabled && isBridgeToolSearchName(toolUseName ?? "")) return createToolSearchOutput(block, state.originalTools);
+	return createFunctionCallOutput(block);
+};
+const createToolSearchOutput = (block, originalTools) => {
+	const referencedToolNames = resolveToolSearchReferencedToolNames(block.content, originalTools);
+	return {
+		type: "tool_search_output",
+		call_id: block.tool_use_id,
+		tools: referencedToolNames.map((toolName) => convertDeferredToolToNamespace(resolveDeferredTool(toolName, originalTools))),
+		execution: "client",
+		status: block.is_error ? "incomplete" : "completed"
+	};
+};
+const resolveToolSearchReferencedToolNames = (content, originalTools) => {
+	const explicitReferences = extractToolReferenceNames(content);
+	if (explicitReferences.length > 0) return uniqueToolNames(explicitReferences);
+	const sentinel = extractMcpToolSearchSentinel(content);
+	if (sentinel) return selectDeferredToolsByNames(sentinel.names, originalTools).map((tool) => tool.name);
+	return [];
+};
+const extractToolReferenceNames = (content) => {
+	if (!Array.isArray(content)) return [];
+	return content.flatMap((block) => block.type === "tool_reference" ? [block.tool_name] : []);
+};
+const extractMcpToolSearchSentinel = (content) => {
+	if (typeof content === "string") return parseMcpToolSearchSentinel(content);
+	for (const block of content) {
+		if (block.type !== "text") continue;
+		const sentinel = parseMcpToolSearchSentinel(block.text);
+		if (sentinel) return sentinel;
+	}
+	return null;
+};
+const resolveDeferredTool = (toolName, originalTools) => {
+	const tool = originalTools.find((candidate) => candidate.name === toolName);
+	if (tool && isDeferredToolName(tool.name)) return tool;
+	throw createInvalidRequestError(`Tool reference '${toolName}' has no corresponding deferred tool definition`);
+};
+const uniqueToolNames = (toolNames) => [...new Set(toolNames)];
+const createInvalidRequestError = (message) => new HTTPError(message, new Response(JSON.stringify({ error: {
+	message,
+	type: "invalid_request_error"
+} }), {
+	status: 400,
+	headers: { "content-type": "application/json" }
+}));
+const translateSystemPrompt = (system, model) => {
+	if (!system) return null;
+	const extraPrompt = getExtraPromptForModel(model);
+	if (typeof system === "string") return system + extraPrompt;
+	const text = system.map((block, index) => {
+		if (index === 0) return block.text + "\n\n" + extraPrompt + "\n\n";
+		return block.text;
+	}).join(" ");
+	return text.length > 0 ? text : null;
+};
+const convertAnthropicTools = (tools, toolSearchEnabled) => {
+	if (!tools || tools.length === 0) return null;
+	const converted = [];
+	let addedToolSearch = false;
+	const searchableToolNames = toolSearchEnabled ? listDeferredToolNames(tools) : [];
+	for (const tool of tools) {
+		if (isBridgeToolSearchName(tool.name)) {
+			if (toolSearchEnabled && !addedToolSearch) {
+				converted.push(createResponsesToolSearchDefinition(searchableToolNames));
+				addedToolSearch = true;
+			}
+			continue;
+		}
+		if (toolSearchEnabled && isDeferredToolName(tool.name)) {
+			converted.push(convertDeferredToolToNamespace(tool));
+			continue;
+		}
+		converted.push(convertToolToFunction(tool));
+	}
+	return converted;
+};
+const createResponsesToolSearchDefinition = (searchableToolNames) => ({
+	type: "tool_search",
+	execution: "client",
+	description: "Load deferred tools by exact name before using them. Return only the searchable tool names you need for the next step.",
+	parameters: {
+		type: "object",
+		properties: { names: {
+			type: "array",
+			description: "Exact deferred tool names to load.",
+			items: {
+				type: "string",
+				enum: searchableToolNames
+			},
+			minItems: 1
+		} },
+		required: ["names"],
+		additionalProperties: false
+	}
+});
+const convertToolToFunction = (tool) => ({
+	type: "function",
+	name: tool.name,
 	parameters: normalizeToolSchema(tool.input_schema),
 	strict: false,
 	...tool.description ? { description: tool.description } : {}
@@ -3663,11 +4014,12 @@ async function handleProviderMessagesForProvider(c, options) {
 	} }, 404);
 	try {
 		const modelConfig = providerConfig.models?.[payload.model];
-		applyModelDefaults(payload, modelConfig);
 		debugJson(logger$5, "provider.messages.request", {
 			payload,
 			provider
 		});
+		normalizeSystemMessages(payload);
+		applyModelDefaults(payload, modelConfig);
 		if (providerConfig.type === "openai-responses") return await handleOpenAIResponsesProviderMessages(c, {
 			modelConfig,
 			payload,
@@ -3678,736 +4030,465 @@ async function handleProviderMessagesForProvider(c, options) {
 			modelConfig,
 			payload,
 			provider,
-			providerConfig
-		});
-		applyMissingExtraBody(payload, { extraBody: modelConfig?.extraBody });
-		const upstreamResponse = await forwardProviderMessages(providerConfig, payload, c.req.raw.headers);
-		if (!upstreamResponse.ok) {
-			logger$5.error("Failed to create responses", upstreamResponse);
-			throw new HTTPError("Failed to create responses", upstreamResponse);
-		}
-		const contentType = upstreamResponse.headers.get("content-type") ?? "";
-		if (Boolean(payload.stream) && contentType.includes("text/event-stream")) return streamProviderMessages({
-			c,
-			payload,
-			provider,
-			providerConfig,
-			upstreamResponse
-		});
-		return respondProviderMessagesJson(c, {
-			body: await upstreamResponse.json(),
-			payload,
-			provider,
-			providerConfig
-		});
-	} catch (error) {
-		logger$5.error("provider.messages.error", {
-			provider,
-			error
-		});
-		throw error;
-	}
-}
-const handleOpenAIResponsesProviderMessages = async (c, options) => {
-	const { payload, provider, providerConfig } = options;
-	const selectedModel = providerConfig.name === "codex" ? getModels().data.find((model) => model.id === payload.model) : void 0;
-	const responsesPayload = translateAnthropicMessagesToResponsesPayload(payload);
-	applyResponsesApiContextManagement(responsesPayload, selectedModel?.capabilities.limits.max_prompt_tokens);
-	compactInputByLatestCompaction(responsesPayload);
-	debugJson(logger$5, "provider.messages.responses.request", {
-		payload: responsesPayload,
-		provider
-	});
-	if (providerConfig.name === "codex") {
-		const upstreamResponse = await forwardCodexResponses(responsesPayload, c.req.raw.headers, providerConfig.baseUrl);
-		if (responsesPayload.stream && isResponsesStream$1(upstreamResponse)) return streamResponsesProviderMessages({
-			c,
-			payload,
-			provider,
-			providerConfig,
-			upstreamResponse
-		});
-		return respondResponsesProviderMessagesJson(c, {
-			body: upstreamResponse,
-			payload,
-			provider,
-			providerConfig
-		});
-	}
-	const upstreamResponse = await forwardProviderResponses(providerConfig, responsesPayload, c.req.raw.headers);
-	if (!upstreamResponse.ok) {
-		logger$5.error("Failed to create provider responses", upstreamResponse);
-		throw new HTTPError("Failed to create provider responses", upstreamResponse);
-	}
-	if (responsesPayload.stream) return streamResponsesProviderMessages({
-		c,
-		payload,
-		provider,
-		providerConfig,
-		upstreamResponse: events(upstreamResponse)
-	});
-	return respondResponsesProviderMessagesJson(c, {
-		body: await upstreamResponse.json(),
-		payload,
-		provider,
-		providerConfig
-	});
-};
-const applyModelDefaults = (payload, modelConfig) => {
-	payload.temperature ??= modelConfig?.temperature;
-	payload.top_p ??= modelConfig?.topP;
-	payload.top_k ??= modelConfig?.topK;
-};
-const applyMissingExtraBody = (payload, options) => {
-	for (const [key, value] of Object.entries(options.extraBody ?? {})) if (!Object.hasOwn(payload, key)) payload[key] = value;
-};
-const getRequestThinkingBudget = (payload) => {
-	const budget = payload.thinking?.budget_tokens;
-	if (typeof budget !== "number" || !Number.isFinite(budget)) return;
-	return budget;
-};
-const applyOpenAICompatibleThinkingBudget = (payload, source) => {
-	const thinkingBudget = getRequestThinkingBudget(source);
-	if (thinkingBudget !== void 0) {
-		payload.thinking_budget = thinkingBudget;
-		return;
-	}
-	if (payload.thinking_budget === void 0) delete payload.thinking_budget;
-};
-const applyOpenAICompatibleExtraBodyThinkingBudget = (payload, options) => {
-	const { extraBody } = options;
-	if (!extraBody || !Object.hasOwn(extraBody, "thinking_budget")) return;
-	const rawPayload = payload;
-	rawPayload.thinking_budget = extraBody.thinking_budget;
-};
-const handleOpenAICompatibleProviderMessages = async (c, options) => {
-	const { modelConfig, payload, provider, providerConfig } = options;
-	const openAIPayload = createOpenAICompatiblePayload(payload, modelConfig);
-	debugJson(logger$5, "provider.messages.openai_compatible.request", {
-		payload: openAIPayload,
-		provider
-	});
-	const upstreamResponse = await forwardProviderChatCompletions(providerConfig, openAIPayload, c.req.raw.headers);
-	if (!upstreamResponse.ok) {
-		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") ?? "";
-	if (Boolean(openAIPayload.stream) && contentType.includes("text/event-stream")) return streamOpenAICompatibleProviderMessages({
-		c,
-		payload,
-		provider,
-		upstreamResponse
-	});
-	return respondOpenAICompatibleProviderMessagesJson(c, {
-		body: await upstreamResponse.json(),
-		payload,
-		provider
-	});
-};
-const createOpenAICompatiblePayload = (payload, modelConfig) => {
-	const openAIPayload = translateToOpenAI(payload, {
-		supportPdf: modelConfig?.supportPdf,
-		toolContentSupportType: modelConfig?.toolContentSupportType ?? []
-	});
-	applyOpenAICompatibleThinkingBudget(openAIPayload, payload);
-	if (payload.top_k !== void 0) openAIPayload.top_k = payload.top_k;
-	if (openAIPayload.stream) openAIPayload.stream_options = { include_usage: true };
-	normalizeOpenAICompatibleReasoningContent(openAIPayload);
-	applyOpenAICompatibleRequestOverrides(openAIPayload, {
-		extraBody: modelConfig?.extraBody,
-		source: payload
-	});
-	applyMissingExtraBody(openAIPayload, { extraBody: modelConfig?.extraBody });
-	applyOpenAICompatibleExtraBodyThinkingBudget(openAIPayload, { extraBody: modelConfig?.extraBody });
-	if (!Object.hasOwn(openAIPayload, "parallel_tool_calls")) openAIPayload.parallel_tool_calls = true;
-	if (modelConfig?.contextCache !== false) applyOpenAICompatibleContextCache(openAIPayload);
-	return openAIPayload;
-};
-const normalizeOpenAICompatibleReasoningContent = (payload) => {
-	for (const message of payload.messages) {
-		if (message.role !== "assistant") continue;
-		if (message.reasoning_content === void 0 && message.reasoning_text !== void 0) message.reasoning_content = message.reasoning_text;
-		delete message.reasoning_text;
-		delete message.reasoning_opaque;
-	}
-};
-const applyOpenAICompatibleRequestOverrides = (payload, options) => {
-	const allowedKeys = new Set(Object.keys(options.extraBody ?? {}));
-	for (const key of allowedKeys) if (Object.hasOwn(options.source, key)) payload[key] = options.source[key];
-};
-const applyOpenAICompatibleContextCache = (payload) => {
-	const messageIndexes = selectContextCacheMessageIndexes(payload.messages);
-	for (const messageIndex of messageIndexes) applyContextCacheControl(payload.messages[messageIndex]);
-};
-const selectContextCacheMessageIndexes = (messages) => {
-	const cacheableIndexes = messages.flatMap((message, index) => isContextCacheMarkerEligible(message) ? [index] : []);
-	const systemIndexes = cacheableIndexes.filter((index) => messages[index]?.role === "system").slice(0, 2);
-	const finalIndexes = cacheableIndexes.filter((index) => messages[index]?.role !== "system").slice(-2);
-	return uniqueIndexes$1([...systemIndexes, ...finalIndexes]).sort((a, b) => a - b);
-};
-const uniqueIndexes$1 = (indexes) => [...new Set(indexes)].slice(0, OPENAI_COMPATIBLE_CONTEXT_CACHE_MARKER_LIMIT);
-const isContextCacheMarkerEligible = (message) => {
-	if (!OPENAI_COMPATIBLE_CONTEXT_CACHE_ROLES.has(message.role)) return false;
-	if (typeof message.content === "string") return message.content.length > 0;
-	return Array.isArray(message.content) && message.content.length > 0;
-};
-const applyContextCacheControl = (message) => {
-	if (!message) return;
-	if (typeof message.content === "string") {
-		message.content = [{
-			type: "text",
-			text: message.content,
-			cache_control: { ...OPENAI_COMPATIBLE_CONTEXT_CACHE_CONTROL }
-		}];
-		return;
-	}
-	if (!Array.isArray(message.content)) return;
-	const lastPart = message.content.at(-1);
-	if (!lastPart) return;
-	setContextCacheControl(lastPart);
-};
-const setContextCacheControl = (part) => {
-	part.cache_control = { ...OPENAI_COMPATIBLE_CONTEXT_CACHE_CONTROL };
-};
-const streamProviderMessages = ({ c, payload, provider, providerConfig, upstreamResponse }) => {
-	logger$5.debug("provider.messages.streaming");
-	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
-	return streamSSE(c, async (stream) => {
-		let usage = {};
-		for await (const chunk of events(upstreamResponse)) {
-			logger$5.debug("provider.messages.raw_stream_event:", chunk.data);
-			const eventName = chunk.event;
-			if (eventName === "ping") {
-				await stream.writeSSE({
-					event: "ping",
-					data: "{\"type\":\"ping\"}"
-				});
-				continue;
-			}
-			let data = chunk.data;
-			if (!data) continue;
-			if (chunk.data === "[DONE]") break;
-			const parsed = parseProviderStreamEvent(data, providerConfig);
-			if (parsed) {
-				usage = mergeAnthropicUsage(usage, parsed.usage);
-				data = parsed.data;
-			}
-			await stream.writeSSE({
-				event: eventName,
-				data
-			});
-		}
-		recordUsage(usage);
-	});
-};
-const streamOpenAICompatibleProviderMessages = ({ c, payload, provider, upstreamResponse }) => {
-	logger$5.debug("provider.messages.openai_compatible.streaming");
-	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
-	return streamSSE(c, async (stream) => {
-		let usage = {};
-		const streamState = {
-			messageStartSent: false,
-			contentBlockIndex: 0,
-			contentBlockOpen: false,
-			toolCalls: {},
-			thinkingBlockOpen: false
-		};
-		for await (const chunk of events(upstreamResponse)) {
-			logger$5.debug("provider.messages.openai_compatible.raw_stream_event:", chunk.data);
-			if (chunk.event === "ping") {
-				await stream.writeSSE({
-					event: "ping",
-					data: "{\"type\":\"ping\"}"
-				});
-				continue;
-			}
-			if (!chunk.data || chunk.data === "[DONE]") {
-				if (chunk.data === "[DONE]") break;
-				continue;
-			}
-			const parsed = parseOpenAICompatibleStreamChunk(chunk.data);
-			if (!parsed) continue;
-			if (parsed.usage) usage = normalizeOpenAIUsage(parsed.usage);
-			const events = translateChunkToAnthropicEvents(parsed, streamState);
-			for (const event of events) {
-				const eventData = JSON.stringify(event);
-				debugLazy(logger$5, () => ["provider.messages.openai_compatible.translated_event:", eventData]);
-				await stream.writeSSE({
-					event: event.type,
-					data: eventData
-				});
-			}
-		}
-		for (const event of flushPendingAnthropicStreamEvents(streamState)) {
-			const eventData = JSON.stringify(event);
-			debugLazy(logger$5, () => ["provider.messages.openai_compatible.translated_event:", eventData]);
-			await stream.writeSSE({
-				event: event.type,
-				data: eventData
-			});
-		}
-		recordUsage(usage);
-	});
-};
-const streamResponsesProviderMessages = ({ c, payload, provider, providerConfig, upstreamResponse }) => {
-	logger$5.debug("provider.messages.responses.streaming", { provider });
-	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
-	return streamSSE(c, async (stream) => {
-		let usage = {};
-		const streamState = createResponsesStreamState({ toolSearchName: resolveBridgeToolSearchName(payload.tools) });
-		for await (const chunk of upstreamResponse) {
-			logger$5.debug("provider.messages.responses.raw_stream_event:", chunk.data);
-			if (chunk.event === "ping") {
-				await stream.writeSSE({
-					event: "ping",
-					data: "{\"type\":\"ping\"}"
-				});
-				continue;
-			}
-			if (!chunk.data || chunk.data === "[DONE]") {
-				if (chunk.data === "[DONE]") break;
-				continue;
-			}
-			const parsed = parseResponsesProviderStreamChunk(chunk.data, providerConfig);
-			if (!parsed) continue;
-			if (parsed.type === "response.completed" || parsed.type === "response.failed" || parsed.type === "response.incomplete") usage = normalizeResponsesUsage(parsed.response.usage);
-			const events = translateResponsesStreamEvent(parsed, streamState);
-			for (const event of events) {
-				const eventData = JSON.stringify(event);
-				debugLazy(logger$5, () => ["provider.messages.responses.translated_event:", eventData]);
-				await stream.writeSSE({
-					event: event.type,
-					data: eventData
-				});
-			}
-		}
-		if (!streamState.messageCompleted) {
-			const errorEvent = buildErrorEvent(`${provider} stream ended without a completion event`);
-			await stream.writeSSE({
-				event: errorEvent.type,
-				data: JSON.stringify(errorEvent)
-			});
-		}
-		recordUsage(usage);
-	});
-};
-const isResponsesStream$1 = (value) => {
-	return Boolean(value) && typeof value[Symbol.asyncIterator] === "function";
-};
-const parseOpenAICompatibleStreamChunk = (data) => {
-	try {
-		return JSON.parse(data);
-	} catch (error) {
-		logger$5.error("provider.messages.openai_compatible.parse_chunk_error", {
-			data,
-			error
+			providerConfig
+		});
+		applyMissingExtraBody(payload, { extraBody: modelConfig?.extraBody });
+		debugJson(logger$5, "Translated provider.messages.request", {
+			payload,
+			provider
+		});
+		const upstreamResponse = await forwardProviderMessages(providerConfig, payload, c.req.raw.headers);
+		if (!upstreamResponse.ok) {
+			logger$5.error("Failed to create responses", upstreamResponse);
+			throw new HTTPError("Failed to create responses", upstreamResponse);
+		}
+		const contentType = upstreamResponse.headers.get("content-type") ?? "";
+		if (Boolean(payload.stream) && contentType.includes("text/event-stream")) return streamProviderMessages({
+			c,
+			payload,
+			provider,
+			providerConfig,
+			upstreamResponse
+		});
+		return respondProviderMessagesJson(c, {
+			body: await upstreamResponse.json(),
+			payload,
+			provider,
+			providerConfig
 		});
-		return null;
-	}
-};
-const parseResponsesProviderStreamChunk = (data, providerConfig) => {
-	try {
-		const parsed = JSON.parse(data);
-		if (providerConfig.name === "codex") logCodexRateLimitsEvent(parsed);
-		return parsed;
 	} catch (error) {
-		logger$5.error("provider.messages.responses.parse_chunk_error", {
-			provider: providerConfig.name,
-			data,
+		logger$5.error("provider.messages.error", {
+			provider,
 			error
 		});
-		return null;
+		throw error;
 	}
-};
-const parseProviderStreamEvent = (data, providerConfig) => {
-	try {
-		const parsed = JSON.parse(data);
-		if (parsed.type === "message_start") {
-			adjustInputTokens(providerConfig, parsed.message.usage);
-			return {
-				data: JSON.stringify(parsed),
-				model: parsed.message.model,
-				usage: normalizeAnthropicUsage(parsed.message.usage)
-			};
-		}
-		if (parsed.type === "message_delta") {
-			adjustInputTokens(providerConfig, parsed.usage);
-			return {
-				data: JSON.stringify(parsed),
-				usage: normalizeAnthropicUsage(parsed.usage)
-			};
-		}
-		return {
-			data: JSON.stringify(parsed),
-			usage: {}
-		};
-	} catch (error) {
-		logger$5.error("provider.messages.streaming.adjust_tokens_error", {
-			error,
-			originalData: data
+}
+const handleOpenAIResponsesProviderMessages = async (c, options) => {
+	const { payload, provider, providerConfig } = options;
+	const selectedModel = providerConfig.name === "codex" ? getModels().data.find((model) => model.id === payload.model) : void 0;
+	const responsesPayload = translateAnthropicMessagesToResponsesPayload(payload);
+	applyResponsesApiContextManagement(responsesPayload, selectedModel?.capabilities.limits.max_prompt_tokens);
+	compactInputByLatestCompaction(responsesPayload);
+	debugJson(logger$5, "provider.messages.responses.request", {
+		payload: responsesPayload,
+		provider
+	});
+	if (providerConfig.name === "codex") {
+		const upstreamResponse = await forwardCodexResponses(responsesPayload, c.req.raw.headers, providerConfig.baseUrl);
+		if (responsesPayload.stream && isResponsesStream$1(upstreamResponse)) return streamResponsesProviderMessages({
+			c,
+			payload,
+			provider,
+			providerConfig,
+			upstreamResponse
+		});
+		return respondResponsesProviderMessagesJson(c, {
+			body: upstreamResponse,
+			payload,
+			provider,
+			providerConfig
 		});
-		return null;
 	}
+	const upstreamResponse = await forwardProviderResponses(providerConfig, responsesPayload, c.req.raw.headers);
+	if (!upstreamResponse.ok) {
+		logger$5.error("Failed to create provider responses", upstreamResponse);
+		throw new HTTPError("Failed to create provider responses", upstreamResponse);
+	}
+	if (responsesPayload.stream) return streamResponsesProviderMessages({
+		c,
+		payload,
+		provider,
+		providerConfig,
+		upstreamResponse: events(upstreamResponse)
+	});
+	return respondResponsesProviderMessagesJson(c, {
+		body: await upstreamResponse.json(),
+		payload,
+		provider,
+		providerConfig
+	});
 };
-const respondProviderMessagesJson = (c, options) => {
-	const { body, payload, provider, providerConfig } = options;
-	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
-	adjustInputTokens(providerConfig, body.usage);
-	recordUsage(normalizeAnthropicUsage(body.usage));
-	debugJson(logger$5, "provider.messages.no_stream result:", body);
-	return c.json(body);
-};
-const respondOpenAICompatibleProviderMessagesJson = (c, options) => {
-	const { body, payload, provider } = options;
-	createProviderMessagesUsageRecorder(payload, provider)(normalizeOpenAIUsage(body.usage));
-	const anthropicResponse = translateToAnthropic(body);
-	debugJson(logger$5, "provider.messages.openai_compatible.no_stream result:", anthropicResponse);
-	return c.json(anthropicResponse);
+const applyModelDefaults = (payload, modelConfig) => {
+	payload.temperature ??= modelConfig?.temperature;
+	payload.top_p ??= modelConfig?.topP;
+	payload.top_k ??= modelConfig?.topK;
 };
-const respondResponsesProviderMessagesJson = (c, options) => {
-	const { body, payload, provider, providerConfig } = options;
-	createProviderMessagesUsageRecorder(payload, provider)(normalizeResponsesUsage(body.usage));
-	const anthropicResponse = translateResponsesResultToAnthropic(body, { toolSearchName: resolveBridgeToolSearchName(payload.tools) });
-	debugJson(logger$5, "provider.messages.responses.no_stream result:", anthropicResponse);
-	if (providerConfig.name === "codex") logger$5.debug("provider.messages.codex.no_stream.result");
-	return c.json(anthropicResponse);
+const applyMissingExtraBody = (payload, options) => {
+	for (const [key, value] of Object.entries(options.extraBody ?? {})) if (!Object.hasOwn(payload, key)) payload[key] = value;
 };
-const createProviderMessagesUsageRecorder = (payload, provider) => createProviderTokenUsageRecorder({
-	endpoint: "provider_messages",
-	model: payload.model,
-	providerName: provider,
-	sessionId: parseUserIdMetadata(payload.metadata?.user_id).sessionId
-});
-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$5, "provider.messages.adjusted_usage:", usage);
+const getRequestThinkingBudget = (payload) => {
+	const budget = payload.thinking?.budget_tokens;
+	if (typeof budget !== "number" || !Number.isFinite(budget)) return;
+	return budget;
 };
-//#endregion
-//#region src/services/copilot/create-messages.ts
-const INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
-const allowedAnthropicBetas = new Set([
-	INTERLEAVED_THINKING_BETA,
-	"context-management-2025-06-27",
-	"advanced-tool-use-2025-11-20"
-]);
-const buildAnthropicBetaHeader = (anthropicBetaHeader, thinking, _model) => {
-	const isAdaptiveThinking = thinking?.type === "adaptive";
-	if (anthropicBetaHeader) {
-		const uniqueFilteredBetas = [...anthropicBetaHeader.split(",").map((item) => item.trim()).filter((item) => item.length > 0).filter((item) => allowedAnthropicBetas.has(item))];
-		if (uniqueFilteredBetas.length > 0) return uniqueFilteredBetas.join(",");
+const applyOpenAICompatibleThinkingBudget = (payload, source) => {
+	const thinkingBudget = getRequestThinkingBudget(source);
+	if (thinkingBudget !== void 0) {
+		payload.thinking_budget = thinkingBudget;
 		return;
 	}
-	if (thinking?.budget_tokens && !isAdaptiveThinking) return INTERLEAVED_THINKING_BETA;
+	if (payload.thinking_budget === void 0) delete payload.thinking_budget;
 };
-const createMessages = async (payload, anthropicBetaHeader, options) => {
-	if (!state.copilotToken) throw new Error("Copilot token not found");
-	const enableVision = payload.messages.some((message) => {
-		if (!Array.isArray(message.content)) return false;
-		return message.content.some((block) => block.type === "image" || block.type === "tool_result" && Array.isArray(block.content) && block.content.some((inner) => inner.type === "image"));
-	});
-	let isInitiateRequest = false;
-	const lastMessage = payload.messages.at(-1);
-	if (lastMessage?.role === "user") isInitiateRequest = Array.isArray(lastMessage.content) ? lastMessage.content.some((block) => block.type !== "tool_result") : true;
-	const headers = {
-		...copilotHeaders(state, options.requestId, enableVision),
-		"x-initiator": isInitiateRequest ? "user" : "agent"
-	};
-	prepareInteractionHeaders(options.sessionId, Boolean(options.subagentMarker), headers);
-	prepareForCompact(headers, options.compactType);
-	const { safetyIdentifier, sessionId } = parseUserIdMetadata(payload.metadata?.user_id);
-	if (safetyIdentifier && sessionId && payload.model !== "claude-opus-4.8") prepareMessageProxyHeaders(headers);
-	const anthropicBeta = buildAnthropicBetaHeader(anthropicBetaHeader, payload.thinking, payload.model);
-	if (anthropicBeta) headers["anthropic-beta"] = anthropicBeta;
-	consola.log(`<-- model: ${payload.model}`);
-	const response = await fetch(`${copilotBaseUrl(state)}/v1/messages`, {
-		method: "POST",
-		headers,
-		body: JSON.stringify(payload)
+const applyOpenAICompatibleExtraBodyThinkingBudget = (payload, options) => {
+	const { extraBody } = options;
+	if (!extraBody || !Object.hasOwn(extraBody, "thinking_budget")) return;
+	const rawPayload = payload;
+	rawPayload.thinking_budget = extraBody.thinking_budget;
+};
+const handleOpenAICompatibleProviderMessages = async (c, options) => {
+	const { modelConfig, payload, provider, providerConfig } = options;
+	const openAIPayload = createOpenAICompatiblePayload(payload, modelConfig);
+	debugJson(logger$5, "provider.messages.openai_compatible.request", {
+		payload: openAIPayload,
+		provider
 	});
-	logCopilotRateLimits(response.headers);
-	if (!response.ok) {
-		consola.error("Failed to create messages", response);
-		throw new HTTPError("Failed to create messages", response);
+	const upstreamResponse = await forwardProviderChatCompletions(providerConfig, openAIPayload, c.req.raw.headers);
+	if (!upstreamResponse.ok) {
+		logger$5.error("Failed to create openai-compatible responses", upstreamResponse);
+		throw new HTTPError("Failed to create openai-compatible responses", upstreamResponse);
 	}
-	if (payload.stream) return events(response);
-	return await response.json();
-};
-const IDE_EXECUTE_CODE_TOOL = "mcp__ide__executeCode";
-const IDE_GET_DIAGNOSTICS_TOOL = "mcp__ide__getDiagnostics";
-const IDE_GET_DIAGNOSTICS_DESCRIPTION = "Get language diagnostics from VS Code. Returns errors, warnings, information, and hints for files in the workspace.";
-const PDF_FILE_READ_PREFIX = "PDF file read:";
-const isVersionAtLeast = (version, minimumMajor, minimumMinor) => {
-	const [majorPart, minorPart = "0"] = version.split(".");
-	const major = Number.parseInt(majorPart, 10);
-	const minor = Number.parseInt(minorPart, 10);
-	if (!Number.isInteger(major) || !Number.isInteger(minor)) return false;
-	return major > minimumMajor || major === minimumMajor && minor >= minimumMinor;
-};
-const shouldSummarizeThinkingDisplayForModel = (model) => {
-	const normalized = normalizeSdkModelId(model);
-	return Boolean(normalized && isVersionAtLeast(normalized.version, 4, 7));
-};
-const getBlockCacheControl = (block) => {
-	if (!block || block.type === "thinking") return;
-	const cacheControl = block.cache_control;
-	if (!cacheControl || typeof cacheControl !== "object") return;
-	return cacheControl;
-};
-const getLastMessageContentCacheControl = (lastMessage) => {
-	if (!lastMessage || !Array.isArray(lastMessage.content)) return;
-	const cacheControl = getBlockCacheControl(lastMessage.content.at(-1));
-	return cacheControl ? { ...cacheControl } : void 0;
-};
-const applyLastMessageCacheControl = (anthropicPayload, lastMessageCacheControl) => {
-	const cacheControl = lastMessageCacheControl ?? { type: "ephemeral" };
-	const lastMessage = anthropicPayload.messages.at(-1);
-	if (!lastMessage || !Array.isArray(lastMessage.content)) return;
-	const lastBlock = lastMessage.content.at(-1);
-	if (!lastBlock || lastBlock.type === "thinking" || lastBlock.cache_control) return;
-	lastBlock.cache_control = { ...cacheControl };
+	const contentType = upstreamResponse.headers.get("content-type") ?? "";
+	if (Boolean(openAIPayload.stream) && contentType.includes("text/event-stream")) return streamOpenAICompatibleProviderMessages({
+		c,
+		payload,
+		provider,
+		upstreamResponse
+	});
+	return respondOpenAICompatibleProviderMessagesJson(c, {
+		body: await upstreamResponse.json(),
+		payload,
+		provider
+	});
 };
-const getCompactCandidateText = (message) => {
-	if (message.role !== "user") return "";
-	if (typeof message.content === "string") return message.content;
-	return message.content.filter((block) => block.type === "text").map((block) => block.text.startsWith("<system-reminder>") ? "" : block.text).filter((text) => text.length > 0).join("\n\n");
+const createOpenAICompatiblePayload = (payload, modelConfig) => {
+	const openAIPayload = translateToOpenAI(payload, {
+		supportPdf: modelConfig?.supportPdf,
+		toolContentSupportType: modelConfig?.toolContentSupportType ?? []
+	});
+	applyOpenAICompatibleThinkingBudget(openAIPayload, payload);
+	if (payload.top_k !== void 0) openAIPayload.top_k = payload.top_k;
+	if (openAIPayload.stream) openAIPayload.stream_options = { include_usage: true };
+	normalizeOpenAICompatibleReasoningContent(openAIPayload);
+	applyOpenAICompatibleRequestOverrides(openAIPayload, {
+		extraBody: modelConfig?.extraBody,
+		source: payload
+	});
+	applyMissingExtraBody(openAIPayload, { extraBody: modelConfig?.extraBody });
+	applyOpenAICompatibleExtraBodyThinkingBudget(openAIPayload, { extraBody: modelConfig?.extraBody });
+	if (!Object.hasOwn(openAIPayload, "parallel_tool_calls")) openAIPayload.parallel_tool_calls = true;
+	if (modelConfig?.contextCache !== false) applyOpenAICompatibleContextCache(openAIPayload);
+	return openAIPayload;
 };
-const isCompactMessage = (lastMessage) => {
-	const text = getCompactCandidateText(lastMessage);
-	if (!text) return false;
-	return text.includes("CRITICAL: Respond with TEXT ONLY. Do NOT call any tools.") && text.includes("Your task is to create a detailed summary of the conversation so far") && compactMessageSections.some((section) => text.includes(section));
+const normalizeOpenAICompatibleReasoningContent = (payload) => {
+	for (const message of payload.messages) {
+		if (message.role !== "assistant") continue;
+		if (message.reasoning_content === void 0 && message.reasoning_text !== void 0) message.reasoning_content = message.reasoning_text;
+		delete message.reasoning_text;
+		delete message.reasoning_opaque;
+	}
 };
-const isCompactAutoContinueMessage = (lastMessage) => {
-	const text = getCompactCandidateText(lastMessage);
-	return Boolean(text) && compactAutoContinuePromptStarts.some((promptStart) => text.startsWith(promptStart));
+const applyOpenAICompatibleRequestOverrides = (payload, options) => {
+	const allowedKeys = new Set(Object.keys(options.extraBody ?? {}));
+	for (const key of allowedKeys) if (Object.hasOwn(options.source, key)) payload[key] = options.source[key];
 };
-const getCompactType = (anthropicPayload) => {
-	const lastMessage = anthropicPayload.messages.at(-1);
-	if (lastMessage && isCompactMessage(lastMessage)) return 1;
-	if (lastMessage && isCompactAutoContinueMessage(lastMessage)) return 2;
-	const system = anthropicPayload.system;
-	if (typeof system === "string") return compactSystemPromptStarts.some((promptStart) => system.startsWith(promptStart)) ? 1 : 0;
-	if (!Array.isArray(system)) return 0;
-	if (system.some((msg) => typeof msg.text === "string" && compactSystemPromptStarts.some((promptStart) => msg.text.startsWith(promptStart)))) return 1;
-	return 0;
+const applyOpenAICompatibleContextCache = (payload) => {
+	const messageIndexes = selectContextCacheMessageIndexes(payload.messages);
+	for (const messageIndex of messageIndexes) applyContextCacheControl(payload.messages[messageIndex]);
 };
-const mergeContentWithText = (tr, textBlock) => {
-	if (typeof tr.content === "string") return {
-		...tr,
-		content: `${tr.content}\n\n${textBlock.text}`
-	};
-	if (hasToolRef(tr)) return tr;
-	return {
-		...tr,
-		content: [...tr.content, stripContentBlockCacheControl(textBlock)]
-	};
+const selectContextCacheMessageIndexes = (messages) => {
+	const cacheableIndexes = messages.flatMap((message, index) => isContextCacheMarkerEligible(message) ? [index] : []);
+	const systemIndexes = cacheableIndexes.filter((index) => messages[index]?.role === "system").slice(0, 2);
+	const finalIndexes = cacheableIndexes.filter((index) => messages[index]?.role !== "system").slice(-2);
+	return uniqueIndexes$1([...systemIndexes, ...finalIndexes]).sort((a, b) => a - b);
 };
-const mergeContentWithTexts = (tr, textBlocks) => {
-	if (typeof tr.content === "string") {
-		const appendedTexts = textBlocks.map((tb) => tb.text).join("\n\n");
-		return {
-			...tr,
-			content: `${tr.content}\n\n${appendedTexts}`
-		};
-	}
-	if (hasToolRef(tr)) return tr;
-	return {
-		...tr,
-		content: [...tr.content, ...textBlocks.map(stripContentBlockCacheControl)]
-	};
+const uniqueIndexes$1 = (indexes) => [...new Set(indexes)].slice(0, OPENAI_COMPATIBLE_CONTEXT_CACHE_MARKER_LIMIT);
+const isContextCacheMarkerEligible = (message) => {
+	if (!OPENAI_COMPATIBLE_CONTEXT_CACHE_ROLES.has(message.role)) return false;
+	if (typeof message.content === "string") return message.content.length > 0;
+	return Array.isArray(message.content) && message.content.length > 0;
 };
-const mergeContentWithAttachments = (tr, attachments) => {
-	const cleanAttachments = attachments.map(stripContentBlockCacheControl);
-	if (typeof tr.content === "string") return {
-		...tr,
-		content: [{
+const applyContextCacheControl = (message) => {
+	if (!message) return;
+	if (typeof message.content === "string") {
+		message.content = [{
 			type: "text",
-			text: tr.content
-		}, ...cleanAttachments]
-	};
-	return {
-		...tr,
-		content: [...tr.content, ...cleanAttachments]
-	};
-};
-const stripContentBlockCacheControl = (block) => {
-	if (!Object.hasOwn(block, "cache_control")) return block;
-	const copy = { ...block };
-	delete copy.cache_control;
-	return copy;
+			text: message.content,
+			cache_control: { ...OPENAI_COMPATIBLE_CONTEXT_CACHE_CONTROL }
+		}];
+		return;
+	}
+	if (!Array.isArray(message.content)) return;
+	const lastPart = message.content.at(-1);
+	if (!lastPart) return;
+	setContextCacheControl(lastPart);
 };
-const isAttachmentBlock = (block) => {
-	return block.type === "image" || block.type === "document";
+const setContextCacheControl = (part) => {
+	part.cache_control = { ...OPENAI_COMPATIBLE_CONTEXT_CACHE_CONTROL };
 };
-const getMergeableToolResultIndices = (toolResults) => {
-	return toolResults.flatMap((block, index) => block.is_error || hasToolRef(block) ? [] : [index]);
+const streamProviderMessages = ({ c, payload, provider, providerConfig, upstreamResponse }) => {
+	logger$5.debug("provider.messages.streaming");
+	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
+	return streamSSE(c, async (stream) => {
+		let usage = {};
+		for await (const chunk of events(upstreamResponse)) {
+			logger$5.debug("provider.messages.raw_stream_event:", chunk.data);
+			const eventName = chunk.event;
+			if (eventName === "ping") {
+				await stream.writeSSE({
+					event: "ping",
+					data: "{\"type\":\"ping\"}"
+				});
+				continue;
+			}
+			let data = chunk.data;
+			if (!data) continue;
+			if (chunk.data === "[DONE]") break;
+			const parsed = parseProviderStreamEvent(data, providerConfig);
+			if (parsed) {
+				usage = mergeAnthropicUsage(usage, parsed.usage);
+				data = parsed.data;
+			}
+			await stream.writeSSE({
+				event: eventName,
+				data
+			});
+		}
+		recordUsage(usage);
+	});
 };
-const mergeAttachmentsIntoToolResults = (toolResults, attachmentsByToolResultIndex) => {
-	if (attachmentsByToolResultIndex.size === 0) return toolResults;
-	return toolResults.map((block, index) => {
-		const matchedAttachments = attachmentsByToolResultIndex.get(index);
-		if (!matchedAttachments) return block;
-		return mergeContentWithAttachments(block, [...matchedAttachments].sort((left, right) => left.order - right.order).map(({ attachment }) => attachment));
+const streamOpenAICompatibleProviderMessages = ({ c, payload, provider, upstreamResponse }) => {
+	logger$5.debug("provider.messages.openai_compatible.streaming");
+	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
+	return streamSSE(c, async (stream) => {
+		let usage = {};
+		const streamState = {
+			messageStartSent: false,
+			contentBlockIndex: 0,
+			contentBlockOpen: false,
+			toolCalls: {},
+			thinkingBlockOpen: false
+		};
+		for await (const chunk of events(upstreamResponse)) {
+			logger$5.debug("provider.messages.openai_compatible.raw_stream_event:", chunk.data);
+			if (chunk.event === "ping") {
+				await stream.writeSSE({
+					event: "ping",
+					data: "{\"type\":\"ping\"}"
+				});
+				continue;
+			}
+			if (!chunk.data || chunk.data === "[DONE]") {
+				if (chunk.data === "[DONE]") break;
+				continue;
+			}
+			const parsed = parseOpenAICompatibleStreamChunk(chunk.data);
+			if (!parsed) continue;
+			if (parsed.usage) usage = normalizeOpenAIUsage(parsed.usage);
+			const events = translateChunkToAnthropicEvents(parsed, streamState);
+			for (const event of events) {
+				const eventData = JSON.stringify(event);
+				debugLazy(logger$5, () => ["provider.messages.openai_compatible.translated_event:", eventData]);
+				await stream.writeSSE({
+					event: event.type,
+					data: eventData
+				});
+			}
+		}
+		for (const event of flushPendingAnthropicStreamEvents(streamState)) {
+			const eventData = JSON.stringify(event);
+			debugLazy(logger$5, () => ["provider.messages.openai_compatible.translated_event:", eventData]);
+			await stream.writeSSE({
+				event: event.type,
+				data: eventData
+			});
+		}
+		recordUsage(usage);
 	});
 };
-const assignAttachmentsToToolResults = (target, attachments, options) => {
-	const { toolResultIndices } = options;
-	const fallbackToolResultIndices = options.fallbackToolResultIndices ?? toolResultIndices;
-	if (attachments.length === 0) return;
-	if (toolResultIndices.length > 0 && toolResultIndices.length === attachments.length) {
-		for (const [index, toolResultIndex] of toolResultIndices.entries()) {
-			const currentAttachments = target.get(toolResultIndex);
-			if (currentAttachments) {
-				currentAttachments.push(attachments[index]);
+const streamResponsesProviderMessages = ({ c, payload, provider, providerConfig, upstreamResponse }) => {
+	logger$5.debug("provider.messages.responses.streaming", { provider });
+	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
+	return streamSSE(c, async (stream) => {
+		let usage = {};
+		const streamState = createResponsesStreamState({ toolSearchName: resolveBridgeToolSearchName(payload.tools) });
+		for await (const chunk of upstreamResponse) {
+			logger$5.debug("provider.messages.responses.raw_stream_event:", chunk.data);
+			if (chunk.event === "ping") {
+				await stream.writeSSE({
+					event: "ping",
+					data: "{\"type\":\"ping\"}"
+				});
 				continue;
 			}
-			target.set(toolResultIndex, [attachments[index]]);
+			if (!chunk.data || chunk.data === "[DONE]") {
+				if (chunk.data === "[DONE]") break;
+				continue;
+			}
+			const parsed = parseResponsesProviderStreamChunk(chunk.data, providerConfig);
+			if (!parsed) continue;
+			if (parsed.type === "response.completed" || parsed.type === "response.failed" || parsed.type === "response.incomplete") usage = normalizeResponsesUsage(parsed.response.usage);
+			const events = translateResponsesStreamEvent(parsed, streamState);
+			for (const event of events) {
+				const eventData = JSON.stringify(event);
+				debugLazy(logger$5, () => ["provider.messages.responses.translated_event:", eventData]);
+				await stream.writeSSE({
+					event: event.type,
+					data: eventData
+				});
+			}
+		}
+		if (!streamState.messageCompleted) {
+			const errorEvent = buildErrorEvent(`${provider} stream ended without a completion event`);
+			await stream.writeSSE({
+				event: errorEvent.type,
+				data: JSON.stringify(errorEvent)
+			});
 		}
-		return;
-	}
-	const lastToolResultIndex = fallbackToolResultIndices.at(-1);
-	if (lastToolResultIndex === void 0) return;
-	const currentAttachments = target.get(lastToolResultIndex);
-	if (currentAttachments) {
-		currentAttachments.push(...attachments);
-		return;
+		recordUsage(usage);
+	});
+};
+const isResponsesStream$1 = (value) => {
+	return Boolean(value) && typeof value[Symbol.asyncIterator] === "function";
+};
+const parseOpenAICompatibleStreamChunk = (data) => {
+	try {
+		return JSON.parse(data);
+	} catch (error) {
+		logger$5.error("provider.messages.openai_compatible.parse_chunk_error", {
+			data,
+			error
+		});
+		return null;
 	}
-	target.set(lastToolResultIndex, [...attachments]);
 };
-const startsWithPdfFileRead = (toolResult) => {
-	if (typeof toolResult.content === "string") return toolResult.content.startsWith(PDF_FILE_READ_PREFIX);
-	if (toolResult.content.some((block) => block.type === "document")) return false;
-	if (toolResult.content.length === 0) return false;
-	const firstBlock = toolResult.content[0];
-	if (firstBlock.type !== "text") return false;
-	return firstBlock.text.startsWith(PDF_FILE_READ_PREFIX);
+const parseResponsesProviderStreamChunk = (data, providerConfig) => {
+	try {
+		const parsed = JSON.parse(data);
+		if (providerConfig.name === "codex") logCodexRateLimitsEvent(parsed);
+		return parsed;
+	} catch (error) {
+		logger$5.error("provider.messages.responses.parse_chunk_error", {
+			provider: providerConfig.name,
+			data,
+			error
+		});
+		return null;
+	}
 };
-const collectMergeableUserContent = (content) => {
-	const toolResults = [];
-	const textBlocks = [];
-	const attachments = [];
-	for (const [order, block] of content.entries()) {
-		if (block.type === "tool_result") {
-			toolResults.push(block);
-			continue;
-		}
-		if (block.type === "text") {
-			textBlocks.push(block);
-			continue;
+const parseProviderStreamEvent = (data, providerConfig) => {
+	try {
+		const parsed = JSON.parse(data);
+		if (parsed.type === "message_start") {
+			adjustInputTokens(providerConfig, parsed.message.usage);
+			return {
+				data: JSON.stringify(parsed),
+				model: parsed.message.model,
+				usage: normalizeAnthropicUsage(parsed.message.usage)
+			};
 		}
-		if (isAttachmentBlock(block)) {
-			attachments.push({
-				attachment: block,
-				order
-			});
-			continue;
+		if (parsed.type === "message_delta") {
+			adjustInputTokens(providerConfig, parsed.usage);
+			return {
+				data: JSON.stringify(parsed),
+				usage: normalizeAnthropicUsage(parsed.usage)
+			};
 		}
+		return {
+			data: JSON.stringify(parsed),
+			usage: {}
+		};
+	} catch (error) {
+		logger$5.error("provider.messages.streaming.adjust_tokens_error", {
+			error,
+			originalData: data
+		});
 		return null;
 	}
-	return {
-		toolResults,
-		textBlocks,
-		attachments
-	};
 };
-const mergeAttachmentsForToolResults = (toolResults, attachments) => {
-	if (attachments.length === 0) return toolResults;
-	const documentBlocks = attachments.filter(({ attachment }) => attachment.type === "document");
-	const mergeableToolResultIndices = getMergeableToolResultIndices(toolResults);
-	const pdfReadToolResultIndices = mergeableToolResultIndices.filter((index) => startsWithPdfFileRead(toolResults[index]));
-	const attachmentsByToolResultIndex = /* @__PURE__ */ new Map();
-	let remainingAttachments = attachments;
-	let countMatchToolResultIndices = mergeableToolResultIndices;
-	if (documentBlocks.length > 0 && pdfReadToolResultIndices.length > 0) {
-		const matchedDocumentCount = Math.min(pdfReadToolResultIndices.length, documentBlocks.length);
-		const matchedDocuments = documentBlocks.slice(0, matchedDocumentCount);
-		const matchedDocumentOrders = new Set(matchedDocuments.map(({ order }) => order));
-		const matchedPdfToolResultIndices = pdfReadToolResultIndices.slice(0, matchedDocumentCount);
-		const matchedPdfToolResultIndexSet = new Set(matchedPdfToolResultIndices);
-		assignAttachmentsToToolResults(attachmentsByToolResultIndex, matchedDocuments, { toolResultIndices: matchedPdfToolResultIndices });
-		countMatchToolResultIndices = mergeableToolResultIndices.filter((index) => !matchedPdfToolResultIndexSet.has(index));
-		remainingAttachments = attachments.filter(({ attachment, order }) => attachment.type !== "document" || !matchedDocumentOrders.has(order));
-	}
-	assignAttachmentsToToolResults(attachmentsByToolResultIndex, remainingAttachments, {
-		toolResultIndices: countMatchToolResultIndices,
-		fallbackToolResultIndices: mergeableToolResultIndices
-	});
-	return mergeAttachmentsIntoToolResults(toolResults, attachmentsByToolResultIndex);
+const respondProviderMessagesJson = (c, options) => {
+	const { body, payload, provider, providerConfig } = options;
+	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
+	adjustInputTokens(providerConfig, body.usage);
+	recordUsage(normalizeAnthropicUsage(body.usage));
+	debugJson(logger$5, "provider.messages.no_stream result:", body);
+	return c.json(body);
 };
-const mergeUserMessageContent = (content) => {
-	const mergeableContent = collectMergeableUserContent(content);
-	if (!mergeableContent) return null;
-	const { toolResults, textBlocks, attachments } = mergeableContent;
-	if (toolResults.length === 0 || textBlocks.length === 0 && attachments.length === 0) return null;
-	return mergeAttachmentsForToolResults(textBlocks.length === 0 ? toolResults : mergeToolResult(toolResults, textBlocks), attachments);
+const respondOpenAICompatibleProviderMessagesJson = (c, options) => {
+	const { body, payload, provider } = options;
+	createProviderMessagesUsageRecorder(payload, provider)(normalizeOpenAIUsage(body.usage));
+	const anthropicResponse = translateToAnthropic(body);
+	debugJson(logger$5, "provider.messages.openai_compatible.no_stream result:", anthropicResponse);
+	return c.json(anthropicResponse);
 };
-const mergeToolResult = (toolResults, textBlocks) => {
-	if (toolResults.length === textBlocks.length) return toolResults.map((tr, i) => mergeContentWithText(tr, textBlocks[i]));
-	const lastIndex = toolResults.length - 1;
-	return toolResults.map((tr, i) => i === lastIndex ? mergeContentWithTexts(tr, textBlocks) : tr);
+const respondResponsesProviderMessagesJson = (c, options) => {
+	const { body, payload, provider, providerConfig } = options;
+	createProviderMessagesUsageRecorder(payload, provider)(normalizeResponsesUsage(body.usage));
+	const anthropicResponse = translateResponsesResultToAnthropic(body, { toolSearchName: resolveBridgeToolSearchName(payload.tools) });
+	debugJson(logger$5, "provider.messages.responses.no_stream result:", anthropicResponse);
+	if (providerConfig.name === "codex") logger$5.debug("provider.messages.codex.no_stream.result");
+	return c.json(anthropicResponse);
 };
-const stripToolReferenceTurnBoundary = (anthropicPayload) => {
-	for (const msg of anthropicPayload.messages) {
-		if (msg.role !== "user" || !Array.isArray(msg.content)) continue;
-		if (!msg.content.some((block) => block.type === "tool_result" && hasToolRef(block))) continue;
-		msg.content = msg.content.filter((block) => block.type !== "text" || block.text.trim() !== "Tool loaded.");
-	}
+const createProviderMessagesUsageRecorder = (payload, provider) => createProviderTokenUsageRecorder({
+	endpoint: "provider_messages",
+	model: payload.model,
+	providerName: provider,
+	sessionId: parseUserIdMetadata(payload.metadata?.user_id).sessionId
+});
+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$5, "provider.messages.adjusted_usage:", usage);
 };
-const mergeToolResultForClaude = (anthropicPayload, options) => {
-	const lastMessageIndex = anthropicPayload.messages.length - 1;
-	for (const [index, msg] of anthropicPayload.messages.entries()) {
-		if (options?.skipLastMessage && index === lastMessageIndex) continue;
-		if (msg.role !== "user" || !Array.isArray(msg.content)) continue;
-		const mergedContent = mergeUserMessageContent(msg.content);
-		if (mergedContent) msg.content = mergedContent;
+//#endregion
+//#region src/services/copilot/create-messages.ts
+const INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
+const allowedAnthropicBetas = new Set([
+	INTERLEAVED_THINKING_BETA,
+	"context-management-2025-06-27",
+	"advanced-tool-use-2025-11-20"
+]);
+const buildAnthropicBetaHeader = (anthropicBetaHeader, thinking, _model) => {
+	const isAdaptiveThinking = thinking?.type === "adaptive";
+	if (anthropicBetaHeader) {
+		const uniqueFilteredBetas = [...anthropicBetaHeader.split(",").map((item) => item.trim()).filter((item) => item.length > 0).filter((item) => allowedAnthropicBetas.has(item))];
+		if (uniqueFilteredBetas.length > 0) return uniqueFilteredBetas.join(",");
+		return;
 	}
+	if (thinking?.budget_tokens && !isAdaptiveThinking) return INTERLEAVED_THINKING_BETA;
 };
-const sanitizeIdeTools = (payload) => {
-	if (!payload.tools || payload.tools.length === 0) return;
-	payload.tools = payload.tools.flatMap((tool) => {
-		if (tool.name === IDE_EXECUTE_CODE_TOOL && !tool.defer_loading) return [];
-		if (tool.name === IDE_GET_DIAGNOSTICS_TOOL) return [{
-			...tool,
-			description: IDE_GET_DIAGNOSTICS_DESCRIPTION
-		}];
-		return [tool];
+const createMessages = async (payload, anthropicBetaHeader, options) => {
+	if (!state.copilotToken) throw new Error("Copilot token not found");
+	const enableVision = payload.messages.some((message) => {
+		if (!Array.isArray(message.content)) return false;
+		return message.content.some((block) => block.type === "image" || block.type === "tool_result" && Array.isArray(block.content) && block.content.some((inner) => inner.type === "image"));
 	});
-};
-const hasToolRef = (block) => {
-	return Array.isArray(block.content) && block.content.some((c) => c.type === "tool_reference");
-};
-const stripCacheControl = (payload) => {
-	if (Array.isArray(payload.system)) for (const block of payload.system) {
-		const cacheControl = block.cache_control;
-		if (cacheControl && typeof cacheControl === "object") {
-			const { scope, ...rest } = cacheControl;
-			block.cache_control = rest;
-		}
-	}
-};
-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;
-		return block.thinking && block.thinking !== "Thinking..." && block.signature && !block.signature.includes("@");
+	let isInitiateRequest = false;
+	const lastMessage = payload.messages.at(-1);
+	if (lastMessage?.role === "user") isInitiateRequest = Array.isArray(lastMessage.content) ? lastMessage.content.some((block) => block.type !== "tool_result") : true;
+	const headers = {
+		...copilotHeaders(state, options.requestId, enableVision),
+		"x-initiator": isInitiateRequest ? "user" : "agent"
+	};
+	prepareInteractionHeaders(options.sessionId, Boolean(options.subagentMarker), headers);
+	prepareForCompact(headers, options.compactType);
+	const { safetyIdentifier, sessionId } = parseUserIdMetadata(payload.metadata?.user_id);
+	if (safetyIdentifier && sessionId && payload.model !== "claude-opus-4.8") prepareMessageProxyHeaders(headers);
+	const anthropicBeta = buildAnthropicBetaHeader(anthropicBetaHeader, payload.thinking, payload.model);
+	if (anthropicBeta) headers["anthropic-beta"] = anthropicBeta;
+	consola.log(`<-- model: ${payload.model}`);
+	const response = await fetch(`${copilotBaseUrl(state)}/v1/messages`, {
+		method: "POST",
+		headers,
+		body: JSON.stringify(payload)
 	});
-};
-const prepareMessagesApiPayload = (payload, selectedModel) => {
-	stripCacheControl(payload);
-	filterAssistantThinkingBlocks(payload);
-	const hasThinking = Boolean(payload.thinking);
-	const toolChoice = payload.tool_choice;
-	const disableThink = toolChoice?.type === "any" || toolChoice?.type === "tool";
-	if (selectedModel?.capabilities.supports.adaptive_thinking && !disableThink) {
-		payload.thinking = { type: "adaptive" };
-		if (!hasThinking) payload.thinking.display = "summarized";
-		if (shouldSummarizeThinkingDisplayForModel(payload.model)) payload.thinking.display = "summarized";
-		let effort = getReasoningEffortForModel(payload.model);
-		if (effort === "none" || effort === "minimal") effort = "low";
-		const reasoningEffort = selectedModel.capabilities.supports.reasoning_effort;
-		if (reasoningEffort && !reasoningEffort.includes(effort)) effort = reasoningEffort.at(-1);
-		payload.output_config = { effort };
+	logCopilotRateLimits(response.headers);
+	if (!response.ok) {
+		consola.error("Failed to create messages", response);
+		throw new HTTPError("Failed to create messages", response);
 	}
+	if (payload.stream) return events(response);
+	return await response.json();
 };
 //#endregion
 //#region src/routes/messages/api-flows.ts
@@ -4699,8 +4780,9 @@ async function handleCompletion(c) {
 			provider: providerModelAlias.provider
 		});
 	}
-	await checkRateLimit(state);
 	debugJson(logger$4, "Anthropic request payload:", anthropicPayload);
+	normalizeSystemMessages(anthropicPayload);
+	await checkRateLimit(state);
 	sanitizeIdeTools(anthropicPayload);
 	const subagentMarker = parseSubagentMarkerFromFirstUser(anthropicPayload);
 	if (subagentMarker) debugJson(logger$4, "Detected Subagent marker:", subagentMarker);
@@ -5211,4 +5293,4 @@ server.route("/:provider/v1/models", providerModelRoutes);
 //#endregion
 export { server };
 
-//# sourceMappingURL=server-N7maSIWC.js.map
+//# sourceMappingURL=server-DcJiCgxI.js.map