@jeffreycao/copilot-api 1.9.8 → 1.9.11

package/dist/{server-D4FT8suK.js → server-D4pg54e1.js}

@@ -1024,6 +1024,37 @@ embeddingRoutes.post("/", async (c) => {
 	}
 });
 
+//#endregion
+//#region src/lib/provider-model.ts
+const parseProviderModelAlias = (model) => {
+	const separatorIndex = model.indexOf("/");
+	if (separatorIndex <= 0 || separatorIndex === model.length - 1) return null;
+	const provider = model.slice(0, separatorIndex).trim();
+	const providerModel = model.slice(separatorIndex + 1).trim();
+	if (!provider || !providerModel) return null;
+	return {
+		model: providerModel,
+		provider
+	};
+};
+const createFallbackModel = (modelId) => ({
+	capabilities: {
+		family: "provider",
+		limits: {},
+		object: "model_capabilities",
+		supports: {},
+		tokenizer: "o200k_base",
+		type: "chat"
+	},
+	id: modelId,
+	model_picker_enabled: false,
+	name: modelId,
+	object: "model",
+	preview: false,
+	vendor: "provider",
+	version: "unknown"
+});
+
 //#endregion
 //#region src/lib/tokenizer.ts
 const ENCODING_MAP = {
@@ -1243,57 +1274,6 @@ const getTokenCount = async (payload, model) => {
 	};
 };
 
-//#endregion
-//#region src/lib/models.ts
-const findEndpointModel = (sdkModelId) => {
-	const models = state.models?.data ?? [];
-	const exactMatch = models.find((m) => m.id === sdkModelId);
-	if (exactMatch) return exactMatch;
-	const normalized = _normalizeSdkModelId(sdkModelId);
-	if (!normalized) return;
-	const modelName = `claude-${normalized.family}-${normalized.version}`;
-	const model = models.find((m) => m.id === modelName);
-	if (model) return model;
-};
-/**
-* Normalizes an SDK model ID to extract the model family and version.
-* this method from github copilot extension
-* Examples:
-* - "claude-opus-4-5-20251101" -> { family: "opus", version: "4.5" }
-* - "claude-3-5-sonnet-20241022" -> { family: "sonnet", version: "3.5" }
-* - "claude-sonnet-4-20250514" -> { family: "sonnet", version: "4" }
-* - "claude-haiku-3-5-20250514" -> { family: "haiku", version: "3.5" }
-* - "claude-haiku-4.5" -> { family: "haiku", version: "4.5" }
-*/
-const _normalizeSdkModelId = (sdkModelId) => {
-	const withoutDate = sdkModelId.toLowerCase().replace(/-\d{8}$/, "");
-	const pattern1 = withoutDate.match(/^claude-(\w+)-(\d+)-(\d+)$/);
-	if (pattern1) return {
-		family: pattern1[1],
-		version: `${pattern1[2]}.${pattern1[3]}`
-	};
-	const pattern2 = withoutDate.match(/^claude-(\d+)-(\d+)-(\w+)$/);
-	if (pattern2) return {
-		family: pattern2[3],
-		version: `${pattern2[1]}.${pattern2[2]}`
-	};
-	const pattern3 = withoutDate.match(/^claude-(\w+)-(\d+)\.(\d+)$/);
-	if (pattern3) return {
-		family: pattern3[1],
-		version: `${pattern3[2]}.${pattern3[3]}`
-	};
-	const pattern4 = withoutDate.match(/^claude-(\w+)-(\d+)$/);
-	if (pattern4) return {
-		family: pattern4[1],
-		version: pattern4[2]
-	};
-	const pattern5 = withoutDate.match(/^claude-(\d+)-(\w+)$/);
-	if (pattern5) return {
-		family: pattern5[2],
-		version: pattern5[1]
-	};
-};
-
 //#endregion
 //#region src/routes/messages/utils.ts
 function mapOpenAIStopReasonToAnthropic(finishReason) {
@@ -1308,7 +1288,7 @@ function mapOpenAIStopReasonToAnthropic(finishReason) {
 
 //#endregion
 //#region src/routes/messages/non-stream-translation.ts
-const THINKING_TEXT = "Thinking...";
+const THINKING_TEXT$1 = "Thinking...";
 const RICH_TOOL_RESULT_MOVED_TEXT = "Rich tool result content was moved to a user message because this upstream does not support it in tool messages.";
 const COPILOT_TOOL_CONTENT_SUPPORT_TYPE = ["array", "image"];
 function translateToOpenAI(payload, options = {}) {
@@ -1445,8 +1425,8 @@ function handleAssistantMessage(message, modelId, capabilities) {
 	}];
 	const toolUseBlocks = message.content.filter((block) => block.type === "tool_use");
 	let thinkingBlocks = message.content.filter((block) => block.type === "thinking");
-	if (modelId.startsWith("claude")) thinkingBlocks = thinkingBlocks.filter((b) => b.thinking && b.thinking !== THINKING_TEXT && b.signature && !b.signature.includes("@"));
-	const thinkingContents = thinkingBlocks.filter((b) => b.thinking && b.thinking !== THINKING_TEXT).map((b) => b.thinking);
+	if (modelId.startsWith("claude")) thinkingBlocks = thinkingBlocks.filter((b) => b.thinking && b.thinking !== THINKING_TEXT$1 && b.signature && !b.signature.includes("@"));
+	const thinkingContents = thinkingBlocks.filter((b) => b.thinking && b.thinking !== THINKING_TEXT$1).map((b) => b.thinking);
 	const allThinkingContent = thinkingContents.length > 0 ? thinkingContents.join("\n\n") : void 0;
 	const signature = thinkingBlocks.find((b) => b.signature)?.signature;
 	return toolUseBlocks.length > 0 ? [{
@@ -1496,7 +1476,7 @@ function mapContent(content, options = {}) {
 			});
 			break;
 	}
-	if (contentParts.length === 0) return null;
+	if (contentParts.length === 0) return "";
 	return contentParts;
 }
 function createDocumentTextPart() {
@@ -1607,7 +1587,7 @@ function getAnthropicThinkBlocks(reasoningText, reasoningOpaque) {
 	}];
 	if (reasoningOpaque && reasoningOpaque.length > 0) return [{
 		type: "thinking",
-		thinking: THINKING_TEXT,
+		thinking: THINKING_TEXT$1,
 		signature: reasoningOpaque
 	}];
 	return [];
@@ -1622,8 +1602,106 @@ function getAnthropicToolUseBlocks(toolCalls) {
 	}));
 }
 
+//#endregion
+//#region src/routes/provider/messages/count-tokens-handler.ts
+const logger$5 = createHandlerLogger("provider-count-tokens-handler");
+async function handleProviderCountTokens(c) {
+	const provider = c.req.param("provider");
+	const payload = await c.req.json();
+	return await handleProviderCountTokensForProvider(c, {
+		payload,
+		provider
+	});
+}
+async function handleProviderCountTokensForProvider(c, options) {
+	const { payload: anthropicPayload, provider } = options;
+	const modelId = anthropicPayload.model.trim();
+	const providerConfig = getProviderConfig(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 translationOptions = providerConfig.type === "openai-compatible" ? {
+		supportPdf: modelConfig?.supportPdf,
+		toolContentSupportType: modelConfig?.toolContentSupportType ?? []
+	} : void 0;
+	const openAIPayload = translateToOpenAI(anthropicPayload, translationOptions);
+	const selectedModel = createFallbackModel(modelId);
+	const tokenCount = await getTokenCount(openAIPayload, selectedModel);
+	const finalTokenCount = tokenCount.input + tokenCount.output;
+	logger$5.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 ?? [];
+	const exactMatch = models.find((m) => m.id === sdkModelId);
+	if (exactMatch) return exactMatch;
+	const normalized = _normalizeSdkModelId(sdkModelId);
+	if (!normalized) return;
+	const modelName = `claude-${normalized.family}-${normalized.version}`;
+	const model = models.find((m) => m.id === modelName);
+	if (model) return model;
+};
+/**
+* Normalizes an SDK model ID to extract the model family and version.
+* this method from github copilot extension
+* Examples:
+* - "claude-opus-4-5-20251101" -> { family: "opus", version: "4.5" }
+* - "claude-3-5-sonnet-20241022" -> { family: "sonnet", version: "3.5" }
+* - "claude-sonnet-4-20250514" -> { family: "sonnet", version: "4" }
+* - "claude-haiku-3-5-20250514" -> { family: "haiku", version: "3.5" }
+* - "claude-haiku-4.5" -> { family: "haiku", version: "4.5" }
+*/
+const _normalizeSdkModelId = (sdkModelId) => {
+	const withoutDate = sdkModelId.toLowerCase().replace(/-\d{8}$/, "");
+	const pattern1 = withoutDate.match(/^claude-(\w+)-(\d+)-(\d+)$/);
+	if (pattern1) return {
+		family: pattern1[1],
+		version: `${pattern1[2]}.${pattern1[3]}`
+	};
+	const pattern2 = withoutDate.match(/^claude-(\d+)-(\d+)-(\w+)$/);
+	if (pattern2) return {
+		family: pattern2[3],
+		version: `${pattern2[1]}.${pattern2[2]}`
+	};
+	const pattern3 = withoutDate.match(/^claude-(\w+)-(\d+)\.(\d+)$/);
+	if (pattern3) return {
+		family: pattern3[1],
+		version: `${pattern3[2]}.${pattern3[3]}`
+	};
+	const pattern4 = withoutDate.match(/^claude-(\w+)-(\d+)$/);
+	if (pattern4) return {
+		family: pattern4[1],
+		version: pattern4[2]
+	};
+	const pattern5 = withoutDate.match(/^claude-(\d+)-(\w+)$/);
+	if (pattern5) return {
+		family: pattern5[2],
+		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.
@@ -1662,2346 +1740,2334 @@ async function countTokensViaAnthropic(c, payload) {
 * endpoint for accurate counts. Otherwise falls back to GPT tokenizer estimation.
 */
 async function handleCountTokens(c) {
-	try {
-		const anthropicPayload = await c.req.json();
-		const anthropicResult = await countTokensViaAnthropic(c, anthropicPayload);
-		if (anthropicResult) return anthropicResult;
-		const anthropicBeta = c.req.header("anthropic-beta");
-		const openAIPayload = translateToOpenAI(anthropicPayload);
-		const selectedModel = findEndpointModel(anthropicPayload.model);
-		anthropicPayload.model = selectedModel?.id ?? anthropicPayload.model;
-		if (!selectedModel) {
-			consola.warn("Model not found, returning default token count");
-			return c.json({ input_tokens: 1 });
+	const anthropicPayload = await c.req.json();
+	const providerModelAlias = parseProviderModelAlias(anthropicPayload.model);
+	if (providerModelAlias) {
+		anthropicPayload.model = providerModelAlias.model;
+		return await handleProviderCountTokensForProvider(c, {
+			payload: anthropicPayload,
+			provider: providerModelAlias.provider
+		});
+	}
+	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);
 		}
-		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 (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 });
-	} catch (error) {
-		consola.error("Error counting tokens:", error);
-		return c.json({ input_tokens: 1 });
 	}
+	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/services/copilot/create-responses.ts
-const createResponses = async (payload, { vision, initiator, subagentMarker, requestId, sessionId, compactType }) => {
-	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 response = await fetch(`${copilotBaseUrl(state)}/responses`, {
-		method: "POST",
-		headers,
-		body: JSON.stringify(payload)
+//#region src/routes/messages/stream-translation.ts
+function isToolBlockOpen(state$1) {
+	if (!state$1.contentBlockOpen) return false;
+	return Object.values(state$1.toolCalls).some((tc) => tc.anthropicBlockIndex === state$1.contentBlockIndex);
+}
+function translateChunkToAnthropicEvents(chunk, state$1) {
+	const events$1 = [];
+	if (chunk.choices.length === 0) {
+		completePendingMessage(state$1, events$1, chunk);
+		return events$1;
+	}
+	const choice = chunk.choices[0];
+	const { delta } = choice;
+	handleMessageStart(state$1, events$1, chunk);
+	handleThinkingText(delta, state$1, events$1);
+	handleContent(delta, state$1, events$1);
+	handleToolCalls(delta, state$1, events$1);
+	handleFinish(choice, state$1, {
+		events: events$1,
+		chunk
 	});
-	logCopilotRateLimits(response.headers);
-	if (!response.ok) {
-		consola.error("Failed to create responses", response);
-		throw new HTTPError("Failed to create responses", response);
+	return events$1;
+}
+function flushPendingAnthropicStreamEvents(state$1) {
+	const events$1 = [];
+	completePendingMessage(state$1, events$1);
+	return events$1;
+}
+function completePendingMessage(state$1, events$1, chunk) {
+	if (!state$1.pendingMessageDelta) return;
+	if (chunk?.usage) state$1.pendingMessageDelta.usage = getAnthropicUsageFromOpenAIChunk(chunk);
+	events$1.push(state$1.pendingMessageDelta, { type: "message_stop" });
+	state$1.pendingMessageDelta = void 0;
+}
+function handleFinish(choice, state$1, context) {
+	const { events: events$1, chunk } = context;
+	if (choice.finish_reason && choice.finish_reason.length > 0) {
+		if (state$1.contentBlockOpen) {
+			const toolBlockOpen = isToolBlockOpen(state$1);
+			context.events.push({
+				type: "content_block_stop",
+				index: state$1.contentBlockIndex
+			});
+			state$1.contentBlockOpen = false;
+			state$1.contentBlockIndex++;
+			if (!toolBlockOpen) handleReasoningOpaque(choice.delta, events$1, state$1);
+		}
+		state$1.pendingMessageDelta = {
+			type: "message_delta",
+			delta: {
+				stop_reason: mapOpenAIStopReasonToAnthropic(choice.finish_reason),
+				stop_sequence: null
+			},
+			usage: getAnthropicUsageFromOpenAIChunk(chunk)
+		};
+		if (chunk.usage) completePendingMessage(state$1, events$1, chunk);
 	}
-	if (payload.stream) return events(response);
-	return await response.json();
-};
-
-//#endregion
-//#region src/routes/messages/responses-translation.ts
-const MESSAGE_TYPE = "message";
-const COMPACTION_SIGNATURE_PREFIX = "cm1#";
-const COMPACTION_SIGNATURE_SEPARATOR = "@";
-const THINKING_TEXT$1 = "Thinking...";
-const translateAnthropicMessagesToResponsesPayload = (payload) => {
-	const input = [];
-	const applyPhase = shouldApplyPhase(payload.model);
-	for (const message of payload.messages) input.push(...translateMessage(message, payload.model, applyPhase));
-	const translatedTools = convertAnthropicTools(payload.tools);
-	const toolChoice = convertAnthropicToolChoice(payload.tool_choice);
-	const { sessionId: promptCacheKey } = parseUserIdMetadata(payload.metadata?.user_id);
-	return {
-		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,
-		prompt_cache_key: promptCacheKey,
-		stream: payload.stream ?? null,
-		store: false,
-		parallel_tool_calls: true,
-		reasoning: {
-			effort: getReasoningEffortForModel(payload.model),
-			summary: "detailed"
-		},
-		include: ["reasoning.encrypted_content"]
+}
+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 }
 	};
-};
-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) => {
-	if (message.role === "user") return translateUserMessage(message);
-	return translateAssistantMessage(message, model, applyPhase);
-};
-const translateUserMessage = (message) => {
-	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(createFunctionCallOutput(block));
-			continue;
-		}
-		const converted = translateUserContentBlock(block);
-		if (converted.length > 0) pendingContent.push(...converted);
-	}
-	flushPendingContent(pendingContent, items, { role: "user" });
-	return items;
-};
-const translateAssistantMessage = (message, model, applyPhase) => {
-	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") {
-			flushPendingContent(pendingContent, items, {
-				role: "assistant",
-				phase: assistantPhase
-			});
-			items.push(createFunctionToolCall(block));
-			continue;
-		}
-		if (block.type === "thinking" && block.signature) {
-			const compactionContent = createCompactionContent(block);
-			if (compactionContent) {
-				flushPendingContent(pendingContent, items, {
-					role: "assistant",
-					phase: assistantPhase
+}
+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$1, events$1) {
+	if (delta.tool_calls && delta.tool_calls.length > 0) {
+		closeThinkingBlockIfOpen(state$1, events$1);
+		handleReasoningOpaqueInToolCalls(state$1, events$1, delta);
+		for (const toolCall of delta.tool_calls) {
+			if (toolCall.id && toolCall.function?.name) {
+				if (state$1.contentBlockOpen) {
+					events$1.push({
+						type: "content_block_stop",
+						index: state$1.contentBlockIndex
+					});
+					state$1.contentBlockIndex++;
+					state$1.contentBlockOpen = false;
+				}
+				const anthropicBlockIndex = state$1.contentBlockIndex;
+				state$1.toolCalls[toolCall.index] = {
+					id: toolCall.id,
+					name: toolCall.function.name,
+					anthropicBlockIndex
+				};
+				events$1.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$1.contentBlockOpen = true;
 			}
-			if (block.signature.includes("@")) {
-				flushPendingContent(pendingContent, items, {
-					role: "assistant",
-					phase: assistantPhase
+			if (toolCall.function?.arguments) {
+				const toolCallInfo = state$1.toolCalls[toolCall.index];
+				if (toolCallInfo) events$1.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$1, events$1, delta) {
+	if (state$1.contentBlockOpen && !isToolBlockOpen(state$1)) {
+		events$1.push({
+			type: "content_block_stop",
+			index: state$1.contentBlockIndex
+		});
+		state$1.contentBlockIndex++;
+		state$1.contentBlockOpen = false;
 	}
-};
-const translateAssistantContentBlock = (block) => {
-	switch (block.type) {
-		case "text": return createOutPutTextContent(block.text);
-		default: return;
+	handleReasoningOpaque(delta, events$1, state$1);
+}
+function handleContent(delta, state$1, events$1) {
+	if (delta.content && delta.content.length > 0) {
+		closeThinkingBlockIfOpen(state$1, events$1);
+		if (isToolBlockOpen(state$1)) {
+			events$1.push({
+				type: "content_block_stop",
+				index: state$1.contentBlockIndex
+			});
+			state$1.contentBlockIndex++;
+			state$1.contentBlockOpen = false;
+		}
+		if (!state$1.contentBlockOpen) {
+			events$1.push({
+				type: "content_block_start",
+				index: state$1.contentBlockIndex,
+				content_block: {
+					type: "text",
+					text: ""
+				}
+			});
+			state$1.contentBlockOpen = true;
+		}
+		events$1.push({
+			type: "content_block_delta",
+			index: state$1.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 getExtraPromptForModel(model).includes("## Intermediary updates");
-};
-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_TEXT$1 ? "" : 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) => ({
-	type: "function_call",
-	call_id: block.id,
-	name: block.name,
-	arguments: JSON.stringify(block.input),
-	status: "completed"
-});
-const createFunctionCallOutput = (block) => ({
-	type: "function_call_output",
-	call_id: block.tool_use_id,
-	output: convertToolResultContent(block.content),
-	status: block.is_error ? "incomplete" : "completed"
-});
-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) => {
-	if (!tools || tools.length === 0) return null;
-	return tools.map((tool) => ({
-		type: "function",
-		name: tool.name,
-		parameters: normalizeToolSchema(tool.input_schema),
-		strict: false,
-		...tool.description ? { description: tool.description } : {}
-	}));
-};
-const convertAnthropicToolChoice = (choice) => {
-	if (!choice) return "auto";
-	switch (choice.type) {
-		case "auto": return "auto";
-		case "any": return "required";
-		case "tool": return choice.name ? {
-			type: "function",
-			name: choice.name
-		} : "auto";
-		case "none": return "none";
-		default: return "auto";
-	}
-};
-const translateResponsesResultToAnthropic = (response) => {
-	const contentBlocks = mapOutputToAnthropicContent(response.output);
-	const usage = mapResponsesUsage(response);
-	let anthropicContent = fallbackContentBlocks(response.output_text);
-	if (contentBlocks.length > 0) anthropicContent = contentBlocks;
-	const stopReason = mapResponsesStopReason(response);
-	return {
-		id: response.id,
-		type: "message",
-		role: "assistant",
-		content: anthropicContent,
-		model: response.model,
-		stop_reason: stopReason,
-		stop_sequence: null,
-		usage
-	};
-};
-const mapOutputToAnthropicContent = (output) => {
-	const contentBlocks = [];
-	for (const item of output) switch (item.type) {
-		case "reasoning": {
-			const thinkingText = extractReasoningText(item);
-			if (thinkingText.length > 0) contentBlocks.push({
-				type: "thinking",
-				thinking: thinkingText,
-				signature: (item.encrypted_content ?? "") + "@" + item.id
-			});
-			break;
-		}
-		case "function_call": {
-			const toolUseBlock = createToolUseContentBlock(item);
-			if (toolUseBlock) contentBlocks.push(toolUseBlock);
-			break;
-		}
-		case "message": {
-			const combinedText = combineMessageTextContent(item.content);
-			if (combinedText.length > 0) contentBlocks.push({
-				type: "text",
-				text: combinedText
-			});
-			break;
-		}
-		case "compaction": {
-			const compactionBlock = createCompactionThinkingBlock(item);
-			if (compactionBlock) contentBlocks.push(compactionBlock);
-			break;
-		}
-		default: {
-			const combinedText = combineMessageTextContent(item.content);
-			if (combinedText.length > 0) contentBlocks.push({
-				type: "text",
-				text: combinedText
-			});
-		}
-	}
-	return contentBlocks;
-};
-const combineMessageTextContent = (content) => {
-	if (!Array.isArray(content)) return "";
-	let aggregated = "";
-	for (const block of content) {
-		if (isResponseOutputText(block)) {
-			aggregated += block.text;
-			continue;
-		}
-		if (isResponseOutputRefusal(block)) {
-			aggregated += block.refusal;
-			continue;
-		}
-		if (typeof block.text === "string") {
-			aggregated += block.text;
-			continue;
-		}
-		if (typeof block.reasoning === "string") {
-			aggregated += block.reasoning;
-			continue;
-		}
-	}
-	return aggregated;
-};
-const extractReasoningText = (item) => {
-	const segments = [];
-	const collectFromBlocks = (blocks) => {
-		if (!Array.isArray(blocks)) return;
-		for (const block of blocks) if (typeof block.text === "string") {
-			segments.push(block.text);
-			continue;
-		}
-	};
-	if (!item.summary || item.summary.length === 0) return THINKING_TEXT$1;
-	collectFromBlocks(item.summary);
-	return segments.join("").trim();
-};
-const createToolUseContentBlock = (call) => {
-	const toolId = call.call_id;
-	if (!call.name || !toolId) return null;
-	const input = parseFunctionCallArguments(call.arguments);
-	return {
-		type: "tool_use",
-		id: toolId,
-		name: call.name,
-		input
-	};
-};
-const createCompactionThinkingBlock = (item) => {
-	if (!item.id || !item.encrypted_content) return null;
-	return {
-		type: "thinking",
-		thinking: THINKING_TEXT$1,
-		signature: encodeCompactionCarrierSignature({
-			id: item.id,
-			encrypted_content: item.encrypted_content
-		})
-	};
-};
-const parseFunctionCallArguments = (rawArguments) => {
-	if (typeof rawArguments !== "string" || rawArguments.trim().length === 0) return {};
-	try {
-		const parsed = JSON.parse(rawArguments);
-		if (Array.isArray(parsed)) return { arguments: parsed };
-		if (parsed && typeof parsed === "object") return parsed;
-	} catch (error) {
-		consola.warn("Failed to parse function call arguments", {
-			error,
-			rawArguments
-		});
-	}
-	return { raw_arguments: rawArguments };
-};
-const fallbackContentBlocks = (outputText) => {
-	if (!outputText) return [];
-	return [{
-		type: "text",
-		text: outputText
-	}];
-};
-const mapResponsesStopReason = (response) => {
-	const { status, incomplete_details: incompleteDetails } = response;
-	if (status === "completed") {
-		if (response.output.some((item) => item.type === "function_call")) return "tool_use";
-		return "end_turn";
-	}
-	if (status === "incomplete") {
-		if (incompleteDetails?.reason === "max_output_tokens") return "max_tokens";
-		if (incompleteDetails?.reason === "content_filter") return "end_turn";
-	}
-	return null;
-};
-const mapResponsesUsage = (response) => {
-	const inputTokens = response.usage?.input_tokens ?? 0;
-	const outputTokens = response.usage?.output_tokens ?? 0;
-	const inputCachedTokens = response.usage?.input_tokens_details?.cached_tokens;
-	return {
-		input_tokens: inputTokens - (inputCachedTokens ?? 0),
-		output_tokens: outputTokens,
-		...response.usage?.input_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: response.usage.input_tokens_details.cached_tokens }
-	};
-};
-const isRecord = (value) => typeof value === "object" && value !== null;
-const isResponseOutputText = (block) => isRecord(block) && "type" in block && block.type === "output_text";
-const isResponseOutputRefusal = (block) => isRecord(block) && "type" in block && block.type === "refusal";
-const convertToolResultContent = (content) => {
-	if (typeof content === "string") return content;
-	if (Array.isArray(content)) {
-		const result = [];
-		for (const block of content) switch (block.type) {
-			case "text":
-				result.push(createTextContent(block.text));
-				break;
-			case "image":
-				result.push(createImageContent(block));
-				break;
-			case "document":
-				result.push(createFileContent(block));
-				break;
-			case "tool_reference":
-				result.push(createTextContent(`Tool ${block.tool_name} loaded`));
-				break;
-			default: break;
-		}
-		return result;
-	}
-	return "";
-};
-
-//#endregion
-//#region src/routes/messages/responses-stream-translation.ts
-const MAX_CONSECUTIVE_FUNCTION_CALL_WHITESPACE = 20;
-var FunctionCallArgumentsValidationError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "FunctionCallArgumentsValidationError";
-	}
-};
-const updateWhitespaceRunState = (previousCount, chunk) => {
-	let count = previousCount;
-	for (const char of chunk) {
-		if (char === "\r" || char === "\n" || char === "	") {
-			count += 1;
-			if (count > MAX_CONSECUTIVE_FUNCTION_CALL_WHITESPACE) return {
-				nextCount: count,
-				exceeded: true
-			};
-			continue;
-		}
-		if (char !== " ") count = 0;
-	}
-	return {
-		nextCount: count,
-		exceeded: false
-	};
-};
-const createResponsesStreamState = () => ({
-	messageStartSent: false,
-	messageCompleted: false,
-	nextContentBlockIndex: 0,
-	blockIndexByKey: /* @__PURE__ */ new Map(),
-	openBlocks: /* @__PURE__ */ new Set(),
-	blockHasDelta: /* @__PURE__ */ new Set(),
-	functionCallStateByOutputIndex: /* @__PURE__ */ new Map()
-});
-const translateResponsesStreamEvent = (rawEvent, state$1) => {
-	switch (rawEvent.type) {
-		case "response.created": return handleResponseCreated(rawEvent, state$1);
-		case "response.output_item.added": return handleOutputItemAdded$1(rawEvent, state$1);
-		case "response.reasoning_summary_text.delta": return handleReasoningSummaryTextDelta(rawEvent, state$1);
-		case "response.output_text.delta": return handleOutputTextDelta(rawEvent, state$1);
-		case "response.reasoning_summary_text.done": return handleReasoningSummaryTextDone(rawEvent, state$1);
-		case "response.output_text.done": return handleOutputTextDone(rawEvent, state$1);
-		case "response.output_item.done": return handleOutputItemDone$1(rawEvent, state$1);
-		case "response.function_call_arguments.delta": return handleFunctionCallArgumentsDelta(rawEvent, state$1);
-		case "response.function_call_arguments.done": return handleFunctionCallArgumentsDone(rawEvent, state$1);
-		case "response.completed":
-		case "response.incomplete": return handleResponseCompleted(rawEvent, state$1);
-		case "response.failed": return handleResponseFailed(rawEvent, state$1);
-		case "error": return handleErrorEvent(rawEvent, state$1);
-		default: return [];
-	}
-};
-const handleResponseCreated = (rawEvent, state$1) => {
-	return messageStart(state$1, rawEvent.response);
-};
-const handleOutputItemAdded$1 = (rawEvent, state$1) => {
-	const events$1 = new Array();
-	const functionCallDetails = extractFunctionCallDetails(rawEvent);
-	if (!functionCallDetails) return events$1;
-	const { outputIndex, toolCallId, name, initialArguments } = functionCallDetails;
-	const blockIndex = openFunctionCallBlock(state$1, {
-		outputIndex,
-		toolCallId,
-		name,
-		events: events$1
-	});
-	if (initialArguments !== void 0 && initialArguments.length > 0) {
+	if (delta.content === "" && delta.reasoning_opaque && delta.reasoning_opaque.length > 0 && state$1.thinkingBlockOpen) {
 		events$1.push({
 			type: "content_block_delta",
-			index: blockIndex,
+			index: state$1.contentBlockIndex,
 			delta: {
-				type: "input_json_delta",
-				partial_json: initialArguments
+				type: "signature_delta",
+				signature: delta.reasoning_opaque
 			}
+		}, {
+			type: "content_block_stop",
+			index: state$1.contentBlockIndex
 		});
-		state$1.blockHasDelta.add(blockIndex);
+		state$1.contentBlockIndex++;
+		state$1.thinkingBlockOpen = false;
 	}
-	return events$1;
-};
-const handleOutputItemDone$1 = (rawEvent, state$1) => {
-	const events$1 = new Array();
-	const item = rawEvent.item;
-	const itemType = item.type;
-	const outputIndex = rawEvent.output_index;
-	if (itemType === "compaction") {
-		if (!item.id || !item.encrypted_content) return events$1;
-		const blockIndex$1 = openThinkingBlockIfNeeded(state$1, outputIndex, events$1);
-		if (!state$1.blockHasDelta.has(blockIndex$1)) events$1.push({
+}
+function handleMessageStart(state$1, events$1, chunk) {
+	if (!state$1.messageStartSent) {
+		const { cachedTokens, cacheCreationTokens, inputTokens } = getOpenAIChunkUsageTokens(chunk);
+		events$1.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$1.messageStartSent = true;
+	}
+}
+function handleReasoningOpaque(delta, events$1, state$1) {
+	if (delta.reasoning_opaque && delta.reasoning_opaque.length > 0) {
+		events$1.push({
+			type: "content_block_start",
+			index: state$1.contentBlockIndex,
+			content_block: {
+				type: "thinking",
+				thinking: ""
+			}
+		}, {
 			type: "content_block_delta",
-			index: blockIndex$1,
+			index: state$1.contentBlockIndex,
 			delta: {
 				type: "thinking_delta",
 				thinking: THINKING_TEXT$1
 			}
-		});
-		events$1.push({
+		}, {
 			type: "content_block_delta",
-			index: blockIndex$1,
+			index: state$1.contentBlockIndex,
 			delta: {
 				type: "signature_delta",
-				signature: encodeCompactionCarrierSignature({
-					id: item.id,
-					encrypted_content: item.encrypted_content
-				})
+				signature: delta.reasoning_opaque
 			}
+		}, {
+			type: "content_block_stop",
+			index: state$1.contentBlockIndex
 		});
-		state$1.blockHasDelta.add(blockIndex$1);
-		return events$1;
+		state$1.contentBlockIndex++;
 	}
-	if (itemType !== "reasoning") return events$1;
-	const blockIndex = openThinkingBlockIfNeeded(state$1, outputIndex, events$1);
-	const signature = (item.encrypted_content ?? "") + "@" + item.id;
-	if (signature) {
-		if (!item.summary || item.summary.length === 0) events$1.push({
+}
+function handleThinkingText(delta, state$1, events$1) {
+	const reasoningText = delta.reasoning_text ?? delta.reasoning_content;
+	if (reasoningText && reasoningText.length > 0) {
+		if (state$1.contentBlockOpen) {
+			delta.content = reasoningText;
+			delta.reasoning_text = void 0;
+			delta.reasoning_content = void 0;
+			return;
+		}
+		if (!state$1.thinkingBlockOpen) {
+			events$1.push({
+				type: "content_block_start",
+				index: state$1.contentBlockIndex,
+				content_block: {
+					type: "thinking",
+					thinking: ""
+				}
+			});
+			state$1.thinkingBlockOpen = true;
+		}
+		events$1.push({
 			type: "content_block_delta",
-			index: blockIndex,
+			index: state$1.contentBlockIndex,
 			delta: {
 				type: "thinking_delta",
-				thinking: THINKING_TEXT$1
+				thinking: reasoningText
 			}
 		});
+	}
+}
+function closeThinkingBlockIfOpen(state$1, events$1) {
+	if (state$1.thinkingBlockOpen) {
 		events$1.push({
 			type: "content_block_delta",
-			index: blockIndex,
+			index: state$1.contentBlockIndex,
 			delta: {
 				type: "signature_delta",
-				signature
+				signature: ""
 			}
+		}, {
+			type: "content_block_stop",
+			index: state$1.contentBlockIndex
 		});
-		state$1.blockHasDelta.add(blockIndex);
+		state$1.contentBlockIndex++;
+		state$1.thinkingBlockOpen = false;
 	}
-	return events$1;
+}
+
+//#endregion
+//#region src/services/providers/anthropic-proxy.ts
+const SHARED_FORWARDABLE_HEADERS = ["accept", "user-agent"];
+const ANTHROPIC_FORWARDABLE_HEADERS = ["anthropic-version", "anthropic-beta"];
+const STRIPPED_RESPONSE_HEADERS = [
+	"connection",
+	"content-encoding",
+	"content-length",
+	"keep-alive",
+	"proxy-authenticate",
+	"proxy-authorization",
+	"te",
+	"trailer",
+	"transfer-encoding",
+	"upgrade"
+];
+function buildProviderUpstreamHeaders(providerConfig, requestHeaders) {
+	const authHeaders = {};
+	if (providerConfig.authType === "authorization") authHeaders.authorization = `Bearer ${providerConfig.apiKey}`;
+	else authHeaders["x-api-key"] = providerConfig.apiKey;
+	const headers = {
+		"content-type": "application/json",
+		accept: "application/json",
+		...authHeaders
+	};
+	for (const headerName of SHARED_FORWARDABLE_HEADERS) {
+		const headerValue = requestHeaders.get(headerName);
+		if (headerValue) headers[headerName] = headerValue;
+	}
+	if (providerConfig.type !== "anthropic") return headers;
+	for (const headerName of ANTHROPIC_FORWARDABLE_HEADERS) {
+		const headerValue = requestHeaders.get(headerName);
+		if (headerValue) headers[headerName] = headerValue;
+	}
+	return headers;
+}
+function createProviderProxyResponse(upstreamResponse) {
+	const headers = new Headers(upstreamResponse.headers);
+	for (const headerName of STRIPPED_RESPONSE_HEADERS) headers.delete(headerName);
+	return new Response(upstreamResponse.body, {
+		headers,
+		status: upstreamResponse.status,
+		statusText: upstreamResponse.statusText
+	});
+}
+async function forwardProviderMessages(providerConfig, payload, requestHeaders) {
+	return await fetch(`${providerConfig.baseUrl}/v1/messages`, {
+		method: "POST",
+		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders),
+		body: JSON.stringify(payload)
+	});
+}
+async function forwardProviderChatCompletions(providerConfig, payload, requestHeaders) {
+	return await fetch(`${providerConfig.baseUrl}/v1/chat/completions`, {
+		method: "POST",
+		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders),
+		body: JSON.stringify(payload)
+	});
+}
+async function forwardProviderModels(providerConfig, requestHeaders) {
+	return await fetch(`${providerConfig.baseUrl}/v1/models`, {
+		method: "GET",
+		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders)
+	});
+}
+
+//#endregion
+//#region src/routes/provider/messages/handler.ts
+const logger$4 = createHandlerLogger("provider-messages-handler");
+const OPENAI_COMPATIBLE_CONTEXT_CACHE_MARKER_LIMIT = 4;
+const OPENAI_COMPATIBLE_CONTEXT_CACHE_CONTROL = { type: "ephemeral" };
+const OPENAI_COMPATIBLE_CONTEXT_CACHE_ROLES = new Set([
+	"system",
+	"user",
+	"assistant",
+	"tool"
+]);
+async function handleProviderMessages(c) {
+	const provider = c.req.param("provider");
+	const payload = await c.req.json();
+	return await handleProviderMessagesForProvider(c, {
+		payload,
+		provider
+	});
+}
+async function handleProviderMessagesForProvider(c, options) {
+	const { payload, provider } = options;
+	const providerConfig = getProviderConfig(provider);
+	if (!providerConfig) return c.json({ error: {
+		message: `Provider '${provider}' not found or disabled`,
+		type: "invalid_request_error"
+	} }, 404);
+	try {
+		const modelConfig = providerConfig.models?.[payload.model];
+		applyModelDefaults(payload, modelConfig);
+		debugJson(logger$4, "provider.messages.request", {
+			payload,
+			provider
+		});
+		if (providerConfig.type === "openai-compatible") return await handleOpenAICompatibleProviderMessages(c, {
+			modelConfig,
+			payload,
+			provider,
+			providerConfig
+		});
+		applyMissingExtraBody(payload, { extraBody: modelConfig?.extraBody });
+		const upstreamResponse = await forwardProviderMessages(providerConfig, payload, c.req.raw.headers);
+		if (!upstreamResponse.ok) {
+			logger$4.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
+		});
+		const jsonBody = await upstreamResponse.json();
+		return respondProviderMessagesJson(c, {
+			body: jsonBody,
+			payload,
+			provider,
+			providerConfig
+		});
+	} catch (error) {
+		logger$4.error("provider.messages.error", {
+			provider,
+			error
+		});
+		throw error;
+	}
+}
+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 handleFunctionCallArgumentsDelta = (rawEvent, state$1) => {
-	const events$1 = new Array();
-	const outputIndex = rawEvent.output_index;
-	const deltaText = rawEvent.delta;
-	if (!deltaText) return events$1;
-	const blockIndex = openFunctionCallBlock(state$1, {
-		outputIndex,
-		events: events$1
+const handleOpenAICompatibleProviderMessages = async (c, options) => {
+	const { modelConfig, payload, provider, providerConfig } = options;
+	const openAIPayload = createOpenAICompatiblePayload(payload, modelConfig);
+	debugJson(logger$4, "provider.messages.openai_compatible.request", {
+		payload: openAIPayload,
+		provider
 	});
-	const functionCallState = state$1.functionCallStateByOutputIndex.get(outputIndex);
-	if (!functionCallState) return handleFunctionCallArgumentsValidationError(new FunctionCallArgumentsValidationError("Received function call arguments delta without an open tool call block."), state$1, events$1);
-	const { nextCount, exceeded } = updateWhitespaceRunState(functionCallState.consecutiveWhitespaceCount, deltaText);
-	if (exceeded) return handleFunctionCallArgumentsValidationError(new FunctionCallArgumentsValidationError("Received function call arguments delta containing more than 20 consecutive whitespace characters."), state$1, events$1);
-	functionCallState.consecutiveWhitespaceCount = nextCount;
-	events$1.push({
-		type: "content_block_delta",
-		index: blockIndex,
-		delta: {
-			type: "input_json_delta",
-			partial_json: deltaText
-		}
+	const upstreamResponse = await forwardProviderChatCompletions(providerConfig, openAIPayload, c.req.raw.headers);
+	if (!upstreamResponse.ok) {
+		logger$4.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
 	});
-	state$1.blockHasDelta.add(blockIndex);
-	return events$1;
-};
-const handleFunctionCallArgumentsDone = (rawEvent, state$1) => {
-	const events$1 = new Array();
-	const outputIndex = rawEvent.output_index;
-	const blockIndex = openFunctionCallBlock(state$1, {
-		outputIndex,
-		events: events$1
+	const jsonBody = await upstreamResponse.json();
+	return respondOpenAICompatibleProviderMessagesJson(c, {
+		body: jsonBody,
+		payload,
+		provider
 	});
-	const finalArguments = typeof rawEvent.arguments === "string" ? rawEvent.arguments : void 0;
-	if (!state$1.blockHasDelta.has(blockIndex) && finalArguments) {
-		events$1.push({
-			type: "content_block_delta",
-			index: blockIndex,
-			delta: {
-				type: "input_json_delta",
-				partial_json: finalArguments
-			}
-		});
-		state$1.blockHasDelta.add(blockIndex);
-	}
-	state$1.functionCallStateByOutputIndex.delete(outputIndex);
-	return events$1;
 };
-const handleOutputTextDelta = (rawEvent, state$1) => {
-	const events$1 = new Array();
-	const outputIndex = rawEvent.output_index;
-	const contentIndex = rawEvent.content_index;
-	const deltaText = rawEvent.delta;
-	if (!deltaText) return events$1;
-	const blockIndex = openTextBlockIfNeeded(state$1, {
-		outputIndex,
-		contentIndex,
-		events: events$1
+const createOpenAICompatiblePayload = (payload, modelConfig) => {
+	const openAIPayload = translateToOpenAI(payload, {
+		supportPdf: modelConfig?.supportPdf,
+		toolContentSupportType: modelConfig?.toolContentSupportType ?? []
 	});
-	events$1.push({
-		type: "content_block_delta",
-		index: blockIndex,
-		delta: {
-			type: "text_delta",
-			text: deltaText
-		}
+	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
 	});
-	state$1.blockHasDelta.add(blockIndex);
-	return events$1;
+	applyMissingExtraBody(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 handleReasoningSummaryTextDelta = (rawEvent, state$1) => {
-	const outputIndex = rawEvent.output_index;
-	const deltaText = rawEvent.delta;
-	const events$1 = new Array();
-	const blockIndex = openThinkingBlockIfNeeded(state$1, outputIndex, events$1);
-	events$1.push({
-		type: "content_block_delta",
-		index: blockIndex,
-		delta: {
-			type: "thinking_delta",
-			thinking: deltaText
-		}
-	});
-	state$1.blockHasDelta.add(blockIndex);
-	return events$1;
+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 handleReasoningSummaryTextDone = (rawEvent, state$1) => {
-	const outputIndex = rawEvent.output_index;
-	const text = rawEvent.text;
-	const events$1 = new Array();
-	const blockIndex = openThinkingBlockIfNeeded(state$1, outputIndex, events$1);
-	if (text && !state$1.blockHasDelta.has(blockIndex)) events$1.push({
-		type: "content_block_delta",
-		index: blockIndex,
-		delta: {
-			type: "thinking_delta",
-			thinking: text
-		}
-	});
-	return events$1;
+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 handleOutputTextDone = (rawEvent, state$1) => {
-	const events$1 = new Array();
-	const outputIndex = rawEvent.output_index;
-	const contentIndex = rawEvent.content_index;
-	const text = rawEvent.text;
-	const blockIndex = openTextBlockIfNeeded(state$1, {
-		outputIndex,
-		contentIndex,
-		events: events$1
-	});
-	if (text && !state$1.blockHasDelta.has(blockIndex)) events$1.push({
-		type: "content_block_delta",
-		index: blockIndex,
-		delta: {
-			type: "text_delta",
-			text
-		}
-	});
-	return events$1;
+const applyOpenAICompatibleContextCache = (payload) => {
+	const messageIndexes = selectContextCacheMessageIndexes(payload.messages);
+	for (const messageIndex of messageIndexes) applyContextCacheControl(payload.messages[messageIndex]);
 };
-const handleResponseCompleted = (rawEvent, state$1) => {
-	const response = rawEvent.response;
-	const events$1 = new Array();
-	closeAllOpenBlocks(state$1, events$1);
-	const anthropic = translateResponsesResultToAnthropic(response);
-	events$1.push({
-		type: "message_delta",
-		delta: {
-			stop_reason: anthropic.stop_reason,
-			stop_sequence: anthropic.stop_sequence
-		},
-		usage: anthropic.usage
-	}, { type: "message_stop" });
-	state$1.messageCompleted = true;
-	return events$1;
+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 handleResponseFailed = (rawEvent, state$1) => {
-	const response = rawEvent.response;
-	const events$1 = new Array();
-	closeAllOpenBlocks(state$1, events$1);
-	const message = response.error?.message ?? "The response failed due to an unknown error.";
-	events$1.push(buildErrorEvent(message));
-	state$1.messageCompleted = true;
-	return events$1;
+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 handleErrorEvent = (rawEvent, state$1) => {
-	const message = typeof rawEvent.message === "string" ? rawEvent.message : "An unexpected error occurred during streaming.";
-	state$1.messageCompleted = true;
-	return [buildErrorEvent(message)];
+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 handleFunctionCallArgumentsValidationError = (error, state$1, events$1 = []) => {
-	const reason = error.message;
-	closeAllOpenBlocks(state$1, events$1);
-	state$1.messageCompleted = true;
-	events$1.push(buildErrorEvent(reason));
-	return events$1;
+const setContextCacheControl = (part) => {
+	part.cache_control = { ...OPENAI_COMPATIBLE_CONTEXT_CACHE_CONTROL };
 };
-const messageStart = (state$1, response) => {
-	state$1.messageStartSent = true;
-	const inputCachedTokens = response.usage?.input_tokens_details?.cached_tokens;
-	const inputTokens = (response.usage?.input_tokens ?? 0) - (inputCachedTokens ?? 0);
-	return [{
-		type: "message_start",
-		message: {
-			id: response.id,
-			type: "message",
-			role: "assistant",
-			content: [],
-			model: response.model,
-			stop_reason: null,
-			stop_sequence: null,
-			usage: {
-				input_tokens: inputTokens,
-				output_tokens: 0,
-				cache_read_input_tokens: inputCachedTokens ?? 0
+const streamProviderMessages = ({ c, payload, provider, providerConfig, upstreamResponse }) => {
+	logger$4.debug("provider.messages.streaming");
+	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
+	return streamSSE(c, async (stream) => {
+		let usage = {};
+		for await (const chunk of events(upstreamResponse)) {
+			logger$4.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 openTextBlockIfNeeded = (state$1, params) => {
-	const { outputIndex, contentIndex, events: events$1 } = params;
-	const key = getBlockKey(outputIndex, contentIndex);
-	let blockIndex = state$1.blockIndexByKey.get(key);
-	if (blockIndex === void 0) {
-		blockIndex = state$1.nextContentBlockIndex;
-		state$1.nextContentBlockIndex += 1;
-		state$1.blockIndexByKey.set(key, blockIndex);
-	}
-	if (!state$1.openBlocks.has(blockIndex)) {
-		closeOpenBlocks(state$1, events$1);
-		events$1.push({
-			type: "content_block_start",
-			index: blockIndex,
-			content_block: {
-				type: "text",
-				text: ""
+const streamOpenAICompatibleProviderMessages = ({ c, payload, provider, upstreamResponse }) => {
+	logger$4.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$4.debug("provider.messages.openai_compatible.raw_stream_event:", chunk.data);
+			if (chunk.event === "ping") {
+				await stream.writeSSE({
+					event: "ping",
+					data: "{\"type\":\"ping\"}"
+				});
+				continue;
 			}
-		});
-		state$1.openBlocks.add(blockIndex);
-	}
-	return blockIndex;
-};
-const openThinkingBlockIfNeeded = (state$1, outputIndex, events$1) => {
-	const key = getBlockKey(outputIndex, 0);
-	let blockIndex = state$1.blockIndexByKey.get(key);
-	if (blockIndex === void 0) {
-		blockIndex = state$1.nextContentBlockIndex;
-		state$1.nextContentBlockIndex += 1;
-		state$1.blockIndexByKey.set(key, blockIndex);
-	}
-	if (!state$1.openBlocks.has(blockIndex)) {
-		closeOpenBlocks(state$1, events$1);
-		events$1.push({
-			type: "content_block_start",
-			index: blockIndex,
-			content_block: {
-				type: "thinking",
-				thinking: ""
+			if (!chunk.data || chunk.data === "[DONE]") {
+				if (chunk.data === "[DONE]") break;
+				continue;
 			}
-		});
-		state$1.openBlocks.add(blockIndex);
-	}
-	return blockIndex;
-};
-const closeBlockIfOpen = (state$1, blockIndex, events$1) => {
-	if (!state$1.openBlocks.has(blockIndex)) return;
-	events$1.push({
-		type: "content_block_stop",
-		index: blockIndex
+			const parsed = parseOpenAICompatibleStreamChunk(chunk.data);
+			if (!parsed) continue;
+			if (parsed.usage) usage = normalizeOpenAIUsage(parsed.usage);
+			const events$1 = translateChunkToAnthropicEvents(parsed, streamState);
+			for (const event of events$1) {
+				const eventData = JSON.stringify(event);
+				debugLazy(logger$4, () => ["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$4, () => ["provider.messages.openai_compatible.translated_event:", eventData]);
+			await stream.writeSSE({
+				event: event.type,
+				data: eventData
+			});
+		}
+		recordUsage(usage);
 	});
-	state$1.openBlocks.delete(blockIndex);
-	state$1.blockHasDelta.delete(blockIndex);
-};
-const closeOpenBlocks = (state$1, events$1) => {
-	for (const blockIndex of state$1.openBlocks) closeBlockIfOpen(state$1, blockIndex, events$1);
-};
-const closeAllOpenBlocks = (state$1, events$1) => {
-	closeOpenBlocks(state$1, events$1);
-	state$1.functionCallStateByOutputIndex.clear();
 };
-const buildErrorEvent = (message) => ({
-	type: "error",
-	error: {
-		type: "api_error",
-		message
+const parseOpenAICompatibleStreamChunk = (data) => {
+	try {
+		return JSON.parse(data);
+	} catch (error) {
+		logger$4.error("provider.messages.openai_compatible.parse_chunk_error", {
+			data,
+			error
+		});
+		return null;
 	}
-});
-const getBlockKey = (outputIndex, contentIndex) => `${outputIndex}:${contentIndex}`;
-const openFunctionCallBlock = (state$1, params) => {
-	const { outputIndex, toolCallId, name, events: events$1 } = params;
-	let functionCallState = state$1.functionCallStateByOutputIndex.get(outputIndex);
-	if (!functionCallState) {
-		const blockIndex$1 = state$1.nextContentBlockIndex;
-		state$1.nextContentBlockIndex += 1;
-		const resolvedToolCallId = toolCallId ?? `tool_call_${blockIndex$1}`;
-		functionCallState = {
-			blockIndex: blockIndex$1,
-			toolCallId: resolvedToolCallId,
-			name: name ?? "function",
-			consecutiveWhitespaceCount: 0
+};
+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: {}
 		};
-		state$1.functionCallStateByOutputIndex.set(outputIndex, functionCallState);
-	}
-	const { blockIndex } = functionCallState;
-	if (!state$1.openBlocks.has(blockIndex)) {
-		closeOpenBlocks(state$1, events$1);
-		events$1.push({
-			type: "content_block_start",
-			index: blockIndex,
-			content_block: {
-				type: "tool_use",
-				id: functionCallState.toolCallId,
-				name: functionCallState.name,
-				input: {}
-			}
+	} catch (error) {
+		logger$4.error("provider.messages.streaming.adjust_tokens_error", {
+			error,
+			originalData: data
 		});
-		state$1.openBlocks.add(blockIndex);
+		return null;
 	}
-	return blockIndex;
-};
-const extractFunctionCallDetails = (rawEvent) => {
-	const item = rawEvent.item;
-	if (item.type !== "function_call") return;
-	const outputIndex = rawEvent.output_index;
-	const toolCallId = item.call_id;
-	const name = item.name;
-	const initialArguments = item.arguments;
-	return {
-		outputIndex,
-		toolCallId,
-		name,
-		initialArguments
-	};
-};
-
-//#endregion
-//#region src/routes/responses/utils.ts
-const getResponsesRequestOptions = (payload) => {
-	const vision = hasVisionInput(payload);
-	const initiator = hasAgentInitiator(payload) ? "agent" : "user";
-	return {
-		vision,
-		initiator
-	};
-};
-const hasAgentInitiator = (payload) => {
-	const lastItem = getPayloadItems(payload).at(-1);
-	if (!lastItem) return false;
-	if (!("role" in lastItem) || !lastItem.role) return true;
-	return (typeof lastItem.role === "string" ? lastItem.role.toLowerCase() : "") === "assistant";
-};
-const hasVisionInput = (payload) => {
-	return getPayloadItems(payload).some((item) => containsVisionContent(item));
-};
-const resolveResponsesCompactThreshold = (maxPromptTokens) => {
-	if (typeof maxPromptTokens === "number" && maxPromptTokens > 0) return Math.floor(maxPromptTokens * .9);
-	return 5e4;
-};
-const createCompactionContextManagement = (compactThreshold) => [{
-	type: "compaction",
-	compact_threshold: compactThreshold
-}];
-const applyResponsesApiContextManagement = (payload, maxPromptTokens) => {
-	if (payload.context_management !== void 0) return;
-	if (!isResponsesApiContextManagementModel(payload.model)) return;
-	payload.context_management = createCompactionContextManagement(resolveResponsesCompactThreshold(maxPromptTokens));
-};
-const compactInputByLatestCompaction = (payload) => {
-	if (!Array.isArray(payload.input) || payload.input.length === 0) return;
-	const latestCompactionMessageIndex = getLatestCompactionMessageIndex(payload.input);
-	if (latestCompactionMessageIndex === void 0) return;
-	payload.input = payload.input.slice(latestCompactionMessageIndex);
-};
-const getLatestCompactionMessageIndex = (input) => {
-	for (let index = input.length - 1; index >= 0; index -= 1) if (isCompactionInputItem(input[index])) return index;
 };
-const isCompactionInputItem = (value) => {
-	return "type" in value && typeof value.type === "string" && value.type === "compaction";
+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$4, "provider.messages.no_stream result:", body);
+	return c.json(body);
 };
-const getPayloadItems = (payload) => {
-	const result = [];
-	const { input } = payload;
-	if (Array.isArray(input)) result.push(...input);
-	return result;
+const respondOpenAICompatibleProviderMessagesJson = (c, options) => {
+	const { body, payload, provider } = options;
+	createProviderMessagesUsageRecorder(payload, provider)(normalizeOpenAIUsage(body.usage));
+	const anthropicResponse = translateToAnthropic(body);
+	debugJson(logger$4, "provider.messages.openai_compatible.no_stream result:", anthropicResponse);
+	return c.json(anthropicResponse);
 };
-const containsVisionContent = (value) => {
-	if (!value) return false;
-	if (Array.isArray(value)) return value.some((entry) => containsVisionContent(entry));
-	if (typeof value !== "object") return false;
-	const record = value;
-	if ((typeof record.type === "string" ? record.type.toLowerCase() : void 0) === "input_image") return true;
-	if (Array.isArray(record.content)) return record.content.some((entry) => containsVisionContent(entry));
-	return false;
+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$4, "provider.messages.adjusted_usage:", usage);
 };
 
 //#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 createMessages = async (payload, anthropicBetaHeader, options) => {
+//#region src/services/copilot/create-responses.ts
+const createResponses = async (payload, { vision, initiator, subagentMarker, requestId, sessionId, compactType }) => {
 	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"
+		...copilotHeaders(state, requestId, vision),
+		"x-initiator": initiator
 	};
-	prepareInteractionHeaders(options.sessionId, Boolean(options.subagentMarker), headers);
-	prepareForCompact(headers, options.compactType);
-	const { safetyIdentifier, sessionId } = parseUserIdMetadata(payload.metadata?.user_id);
-	if (safetyIdentifier && sessionId) prepareMessageProxyHeaders(headers);
-	const anthropicBeta = buildAnthropicBetaHeader(anthropicBetaHeader, payload.thinking, payload.model);
-	if (anthropicBeta) headers["anthropic-beta"] = anthropicBeta;
+	prepareInteractionHeaders(sessionId, Boolean(subagentMarker), headers);
+	prepareForCompact(headers, compactType);
+	payload.service_tier = void 0;
 	consola.log(`<-- model: ${payload.model}`);
-	const response = await fetch(`${copilotBaseUrl(state)}/v1/messages`, {
+	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 messages", response);
-		throw new HTTPError("Failed to create messages", response);
+		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();
 };
 
 //#endregion
-//#region src/routes/messages/preprocess.ts
-const TOOL_REFERENCE_TURN_BOUNDARY = "Tool loaded.";
-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 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");
+//#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 translateAnthropicMessagesToResponsesPayload = (payload) => {
+	const input = [];
+	const applyPhase = shouldApplyPhase(payload.model);
+	for (const message of payload.messages) input.push(...translateMessage(message, payload.model, applyPhase));
+	const translatedTools = convertAnthropicTools(payload.tools);
+	const toolChoice = convertAnthropicToolChoice(payload.tool_choice);
+	const { sessionId: promptCacheKey } = parseUserIdMetadata(payload.metadata?.user_id);
+	return {
+		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,
+		prompt_cache_key: promptCacheKey,
+		stream: payload.stream ?? null,
+		store: false,
+		parallel_tool_calls: true,
+		reasoning: {
+			effort: getReasoningEffortForModel(payload.model),
+			summary: "detailed"
+		},
+		include: ["reasoning.encrypted_content"]
+	};
 };
-const isCompactMessage = (lastMessage) => {
-	const text = getCompactCandidateText(lastMessage);
-	if (!text) return false;
-	return text.includes(compactTextOnlyGuard) && text.includes(compactSummaryPromptStart) && compactMessageSections.some((section) => text.includes(section));
+const encodeCompactionCarrierSignature = (compaction) => {
+	return `${COMPACTION_SIGNATURE_PREFIX}${compaction.encrypted_content}${COMPACTION_SIGNATURE_SEPARATOR}${compaction.id}`;
 };
-const isCompactAutoContinueMessage = (lastMessage) => {
-	const text = getCompactCandidateText(lastMessage);
-	return Boolean(text) && compactAutoContinuePromptStarts.some((promptStart) => text.startsWith(promptStart));
+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 getCompactType = (anthropicPayload) => {
-	const lastMessage = anthropicPayload.messages.at(-1);
-	if (lastMessage && isCompactMessage(lastMessage)) return COMPACT_REQUEST;
-	if (lastMessage && isCompactAutoContinueMessage(lastMessage)) return COMPACT_AUTO_CONTINUE;
-	const system = anthropicPayload.system;
-	if (typeof system === "string") return compactSystemPromptStarts.some((promptStart) => system.startsWith(promptStart)) ? COMPACT_REQUEST : 0;
-	if (!Array.isArray(system)) return 0;
-	if (system.some((msg) => typeof msg.text === "string" && compactSystemPromptStarts.some((promptStart) => msg.text.startsWith(promptStart)))) return COMPACT_REQUEST;
-	return 0;
+const translateMessage = (message, model, applyPhase) => {
+	if (message.role === "user") return translateUserMessage(message);
+	return translateAssistantMessage(message, model, applyPhase);
 };
-const mergeContentWithText = (tr, textBlock) => {
-	if (typeof tr.content === "string") return {
-		...tr,
-		content: `${tr.content}\n\n${textBlock.text}`
-	};
-	if (hasToolRef(tr)) return tr;
+const translateUserMessage = (message) => {
+	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(createFunctionCallOutput(block));
+			continue;
+		}
+		const converted = translateUserContentBlock(block);
+		if (converted.length > 0) pendingContent.push(...converted);
+	}
+	flushPendingContent(pendingContent, items, { role: "user" });
+	return items;
+};
+const translateAssistantMessage = (message, model, applyPhase) => {
+	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") {
+			flushPendingContent(pendingContent, items, {
+				role: "assistant",
+				phase: assistantPhase
+			});
+			items.push(createFunctionToolCall(block));
+			continue;
+		}
+		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);
+	}
+	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 [];
+	}
+};
+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 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 getExtraPromptForModel(model).includes("## Intermediary updates");
+};
+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_TEXT ? "" : block.thinking;
 	return {
-		...tr,
-		content: [...tr.content, textBlock]
+		id,
+		type: "reasoning",
+		summary: thinking ? [{
+			type: "summary_text",
+			text: thinking
+		}] : [],
+		encrypted_content: encryptedContent
 	};
 };
-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;
+const createCompactionContent = (block) => {
+	const compaction = decodeCompactionCarrierSignature(block.signature);
+	if (!compaction) return;
 	return {
-		...tr,
-		content: [...tr.content, ...textBlocks]
+		id: compaction.id,
+		type: "compaction",
+		encrypted_content: compaction.encrypted_content
 	};
 };
-const mergeContentWithAttachments = (tr, attachments) => {
-	if (typeof tr.content === "string") return {
-		...tr,
-		content: [{
-			type: "text",
-			text: tr.content
-		}, ...attachments]
+const parseReasoningSignature = (signature) => {
+	const splitIndex = signature.lastIndexOf("@");
+	if (splitIndex <= 0 || splitIndex === signature.length - 1) return {
+		encryptedContent: signature,
+		id: ""
 	};
 	return {
-		...tr,
-		content: [...tr.content, ...attachments]
+		encryptedContent: signature.slice(0, splitIndex),
+		id: signature.slice(splitIndex + 1)
 	};
 };
-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 createFunctionToolCall = (block) => ({
+	type: "function_call",
+	call_id: block.id,
+	name: block.name,
+	arguments: JSON.stringify(block.input),
+	status: "completed"
+});
+const createFunctionCallOutput = (block) => ({
+	type: "function_call_output",
+	call_id: block.tool_use_id,
+	output: convertToolResultContent(block.content),
+	status: block.is_error ? "incomplete" : "completed"
+});
+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 mergeAttachmentsIntoToolResults = (toolResults, attachmentsByToolResultIndex) => {
-	if (attachmentsByToolResultIndex.size === 0) return toolResults;
-	return toolResults.map((block, index) => {
-		const matchedAttachments = attachmentsByToolResultIndex.get(index);
-		if (!matchedAttachments) return block;
-		const orderedAttachments = [...matchedAttachments].sort((left, right) => left.order - right.order).map(({ attachment }) => attachment);
-		return mergeContentWithAttachments(block, orderedAttachments);
-	});
+const convertAnthropicTools = (tools) => {
+	if (!tools || tools.length === 0) return null;
+	return tools.map((tool) => ({
+		type: "function",
+		name: tool.name,
+		parameters: normalizeToolSchema(tool.input_schema),
+		strict: false,
+		...tool.description ? { description: tool.description } : {}
+	}));
 };
-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$1 = target.get(toolResultIndex);
-			if (currentAttachments$1) {
-				currentAttachments$1.push(attachments[index]);
-				continue;
-			}
-			target.set(toolResultIndex, [attachments[index]]);
-		}
-		return;
-	}
-	const lastToolResultIndex = fallbackToolResultIndices.at(-1);
-	if (lastToolResultIndex === void 0) return;
-	const currentAttachments = target.get(lastToolResultIndex);
-	if (currentAttachments) {
-		currentAttachments.push(...attachments);
-		return;
+const convertAnthropicToolChoice = (choice) => {
+	if (!choice) return "auto";
+	switch (choice.type) {
+		case "auto": return "auto";
+		case "any": return "required";
+		case "tool": return choice.name ? {
+			type: "function",
+			name: choice.name
+		} : "auto";
+		case "none": return "none";
+		default: return "auto";
 	}
-	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 translateResponsesResultToAnthropic = (response) => {
+	const contentBlocks = mapOutputToAnthropicContent(response.output);
+	const usage = mapResponsesUsage(response);
+	let anthropicContent = fallbackContentBlocks(response.output_text);
+	if (contentBlocks.length > 0) anthropicContent = contentBlocks;
+	const stopReason = mapResponsesStopReason(response);
+	return {
+		id: response.id,
+		type: "message",
+		role: "assistant",
+		content: anthropicContent,
+		model: response.model,
+		stop_reason: stopReason,
+		stop_sequence: null,
+		usage
+	};
 };
-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;
+const mapOutputToAnthropicContent = (output) => {
+	const contentBlocks = [];
+	for (const item of output) switch (item.type) {
+		case "reasoning": {
+			const thinkingText = extractReasoningText(item);
+			if (thinkingText.length > 0) contentBlocks.push({
+				type: "thinking",
+				thinking: thinkingText,
+				signature: (item.encrypted_content ?? "") + "@" + item.id
+			});
+			break;
 		}
-		if (block.type === "text") {
-			textBlocks.push(block);
-			continue;
+		case "function_call": {
+			const toolUseBlock = createToolUseContentBlock(item);
+			if (toolUseBlock) contentBlocks.push(toolUseBlock);
+			break;
 		}
-		if (isAttachmentBlock(block)) {
-			attachments.push({
-				attachment: block,
-				order
+		case "message": {
+			const combinedText = combineMessageTextContent(item.content);
+			if (combinedText.length > 0) contentBlocks.push({
+				type: "text",
+				text: combinedText
+			});
+			break;
+		}
+		case "compaction": {
+			const compactionBlock = createCompactionThinkingBlock(item);
+			if (compactionBlock) contentBlocks.push(compactionBlock);
+			break;
+		}
+		default: {
+			const combinedText = combineMessageTextContent(item.content);
+			if (combinedText.length > 0) contentBlocks.push({
+				type: "text",
+				text: combinedText
 			});
-			continue;
 		}
-		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 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;
-	const mergedToolResults = textBlocks.length === 0 ? toolResults : mergeToolResult(toolResults, textBlocks);
-	return mergeAttachmentsForToolResults(mergedToolResults, 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_REFERENCE_TURN_BOUNDARY);
 	}
+	return contentBlocks;
 };
-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;
+const combineMessageTextContent = (content) => {
+	if (!Array.isArray(content)) return "";
+	let aggregated = "";
+	for (const block of content) {
+		if (isResponseOutputText(block)) {
+			aggregated += block.text;
+			continue;
+		}
+		if (isResponseOutputRefusal(block)) {
+			aggregated += block.refusal;
+			continue;
+		}
+		if (typeof block.text === "string") {
+			aggregated += block.text;
+			continue;
+		}
+		if (typeof block.reasoning === "string") {
+			aggregated += block.reasoning;
+			continue;
+		}
 	}
+	return aggregated;
 };
-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 systemBlock = block;
-		const cacheControl = systemBlock.cache_control;
-		if (cacheControl && typeof cacheControl === "object") {
-			const { scope,...rest } = cacheControl;
-			systemBlock.cache_control = rest;
+const extractReasoningText = (item) => {
+	const segments = [];
+	const collectFromBlocks = (blocks) => {
+		if (!Array.isArray(blocks)) return;
+		for (const block of blocks) if (typeof block.text === "string") {
+			segments.push(block.text);
+			continue;
 		}
-	}
+	};
+	if (!item.summary || item.summary.length === 0) return THINKING_TEXT;
+	collectFromBlocks(item.summary);
+	return segments.join("").trim();
 };
-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 createToolUseContentBlock = (call) => {
+	const toolId = call.call_id;
+	if (!call.name || !toolId) return null;
+	const input = parseFunctionCallArguments(call.arguments);
+	return {
+		type: "tool_use",
+		id: toolId,
+		name: call.name,
+		input
+	};
 };
-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 (payload.model === "claude-opus-4.7") 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 };
+const createCompactionThinkingBlock = (item) => {
+	if (!item.id || !item.encrypted_content) return null;
+	return {
+		type: "thinking",
+		thinking: THINKING_TEXT,
+		signature: encodeCompactionCarrierSignature({
+			id: item.id,
+			encrypted_content: item.encrypted_content
+		})
+	};
+};
+const parseFunctionCallArguments = (rawArguments) => {
+	if (typeof rawArguments !== "string" || rawArguments.trim().length === 0) return {};
+	try {
+		const parsed = JSON.parse(rawArguments);
+		if (Array.isArray(parsed)) return { arguments: parsed };
+		if (parsed && typeof parsed === "object") return parsed;
+	} catch (error) {
+		consola.warn("Failed to parse function call arguments", {
+			error,
+			rawArguments
+		});
 	}
+	return { raw_arguments: rawArguments };
 };
-
-//#endregion
-//#region src/routes/messages/stream-translation.ts
-function isToolBlockOpen(state$1) {
-	if (!state$1.contentBlockOpen) return false;
-	return Object.values(state$1.toolCalls).some((tc) => tc.anthropicBlockIndex === state$1.contentBlockIndex);
-}
-function translateChunkToAnthropicEvents(chunk, state$1) {
-	const events$1 = [];
-	if (chunk.choices.length === 0) {
-		completePendingMessage(state$1, events$1, chunk);
-		return events$1;
+const fallbackContentBlocks = (outputText) => {
+	if (!outputText) return [];
+	return [{
+		type: "text",
+		text: outputText
+	}];
+};
+const mapResponsesStopReason = (response) => {
+	const { status, incomplete_details: incompleteDetails } = response;
+	if (status === "completed") {
+		if (response.output.some((item) => item.type === "function_call")) return "tool_use";
+		return "end_turn";
 	}
-	const choice = chunk.choices[0];
-	const { delta } = choice;
-	handleMessageStart(state$1, events$1, chunk);
-	handleThinkingText(delta, state$1, events$1);
-	handleContent(delta, state$1, events$1);
-	handleToolCalls(delta, state$1, events$1);
-	handleFinish(choice, state$1, {
-		events: events$1,
-		chunk
-	});
-	return events$1;
-}
-function flushPendingAnthropicStreamEvents(state$1) {
-	const events$1 = [];
-	completePendingMessage(state$1, events$1);
-	return events$1;
-}
-function completePendingMessage(state$1, events$1, chunk) {
-	if (!state$1.pendingMessageDelta) return;
-	if (chunk?.usage) state$1.pendingMessageDelta.usage = getAnthropicUsageFromOpenAIChunk(chunk);
-	events$1.push(state$1.pendingMessageDelta, { type: "message_stop" });
-	state$1.pendingMessageDelta = void 0;
-}
-function handleFinish(choice, state$1, context) {
-	const { events: events$1, chunk } = context;
-	if (choice.finish_reason && choice.finish_reason.length > 0) {
-		if (state$1.contentBlockOpen) {
-			const toolBlockOpen = isToolBlockOpen(state$1);
-			context.events.push({
-				type: "content_block_stop",
-				index: state$1.contentBlockIndex
-			});
-			state$1.contentBlockOpen = false;
-			state$1.contentBlockIndex++;
-			if (!toolBlockOpen) handleReasoningOpaque(choice.delta, events$1, state$1);
-		}
-		state$1.pendingMessageDelta = {
-			type: "message_delta",
-			delta: {
-				stop_reason: mapOpenAIStopReasonToAnthropic(choice.finish_reason),
-				stop_sequence: null
-			},
-			usage: getAnthropicUsageFromOpenAIChunk(chunk)
-		};
-		if (chunk.usage) completePendingMessage(state$1, events$1, chunk);
+	if (status === "incomplete") {
+		if (incompleteDetails?.reason === "max_output_tokens") return "max_tokens";
+		if (incompleteDetails?.reason === "content_filter") return "end_turn";
 	}
-}
-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 null;
+};
+const mapResponsesUsage = (response) => {
+	const inputTokens = response.usage?.input_tokens ?? 0;
+	const outputTokens = response.usage?.output_tokens ?? 0;
+	const inputCachedTokens = response.usage?.input_tokens_details?.cached_tokens;
 	return {
-		cacheCreationTokens,
-		cachedTokens,
-		inputTokens: Math.max(0, promptTokens - cachedTokens - cacheCreationTokens)
+		input_tokens: inputTokens - (inputCachedTokens ?? 0),
+		output_tokens: outputTokens,
+		...response.usage?.input_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: response.usage.input_tokens_details.cached_tokens }
 	};
-}
-function handleToolCalls(delta, state$1, events$1) {
-	if (delta.tool_calls && delta.tool_calls.length > 0) {
-		closeThinkingBlockIfOpen(state$1, events$1);
-		handleReasoningOpaqueInToolCalls(state$1, events$1, delta);
-		for (const toolCall of delta.tool_calls) {
-			if (toolCall.id && toolCall.function?.name) {
-				if (state$1.contentBlockOpen) {
-					events$1.push({
-						type: "content_block_stop",
-						index: state$1.contentBlockIndex
-					});
-					state$1.contentBlockIndex++;
-					state$1.contentBlockOpen = false;
-				}
-				const anthropicBlockIndex = state$1.contentBlockIndex;
-				state$1.toolCalls[toolCall.index] = {
-					id: toolCall.id,
-					name: toolCall.function.name,
-					anthropicBlockIndex
-				};
-				events$1.push({
-					type: "content_block_start",
-					index: anthropicBlockIndex,
-					content_block: {
-						type: "tool_use",
-						id: toolCall.id,
-						name: toolCall.function.name,
-						input: {}
-					}
-				});
-				state$1.contentBlockOpen = true;
-			}
-			if (toolCall.function?.arguments) {
-				const toolCallInfo = state$1.toolCalls[toolCall.index];
-				if (toolCallInfo) events$1.push({
-					type: "content_block_delta",
-					index: toolCallInfo.anthropicBlockIndex,
-					delta: {
-						type: "input_json_delta",
-						partial_json: toolCall.function.arguments
-					}
-				});
-			}
+};
+const isRecord = (value) => typeof value === "object" && value !== null;
+const isResponseOutputText = (block) => isRecord(block) && "type" in block && block.type === "output_text";
+const isResponseOutputRefusal = (block) => isRecord(block) && "type" in block && block.type === "refusal";
+const convertToolResultContent = (content) => {
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) {
+		const result = [];
+		for (const block of content) switch (block.type) {
+			case "text":
+				result.push(createTextContent(block.text));
+				break;
+			case "image":
+				result.push(createImageContent(block));
+				break;
+			case "document":
+				result.push(createFileContent(block));
+				break;
+			case "tool_reference":
+				result.push(createTextContent(`Tool ${block.tool_name} loaded`));
+				break;
+			default: break;
 		}
+		return result;
 	}
-}
-function handleReasoningOpaqueInToolCalls(state$1, events$1, delta) {
-	if (state$1.contentBlockOpen && !isToolBlockOpen(state$1)) {
-		events$1.push({
-			type: "content_block_stop",
-			index: state$1.contentBlockIndex
-		});
-		state$1.contentBlockIndex++;
-		state$1.contentBlockOpen = false;
+	return "";
+};
+
+//#endregion
+//#region src/routes/messages/responses-stream-translation.ts
+const MAX_CONSECUTIVE_FUNCTION_CALL_WHITESPACE = 20;
+var FunctionCallArgumentsValidationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "FunctionCallArgumentsValidationError";
 	}
-	handleReasoningOpaque(delta, events$1, state$1);
-}
-function handleContent(delta, state$1, events$1) {
-	if (delta.content && delta.content.length > 0) {
-		closeThinkingBlockIfOpen(state$1, events$1);
-		if (isToolBlockOpen(state$1)) {
-			events$1.push({
-				type: "content_block_stop",
-				index: state$1.contentBlockIndex
-			});
-			state$1.contentBlockIndex++;
-			state$1.contentBlockOpen = false;
-		}
-		if (!state$1.contentBlockOpen) {
-			events$1.push({
-				type: "content_block_start",
-				index: state$1.contentBlockIndex,
-				content_block: {
-					type: "text",
-					text: ""
-				}
-			});
-			state$1.contentBlockOpen = true;
+};
+const updateWhitespaceRunState = (previousCount, chunk) => {
+	let count = previousCount;
+	for (const char of chunk) {
+		if (char === "\r" || char === "\n" || char === "	") {
+			count += 1;
+			if (count > MAX_CONSECUTIVE_FUNCTION_CALL_WHITESPACE) return {
+				nextCount: count,
+				exceeded: true
+			};
+			continue;
 		}
+		if (char !== " ") count = 0;
+	}
+	return {
+		nextCount: count,
+		exceeded: false
+	};
+};
+const createResponsesStreamState = () => ({
+	messageStartSent: false,
+	messageCompleted: false,
+	nextContentBlockIndex: 0,
+	blockIndexByKey: /* @__PURE__ */ new Map(),
+	openBlocks: /* @__PURE__ */ new Set(),
+	blockHasDelta: /* @__PURE__ */ new Set(),
+	functionCallStateByOutputIndex: /* @__PURE__ */ new Map()
+});
+const translateResponsesStreamEvent = (rawEvent, state$1) => {
+	switch (rawEvent.type) {
+		case "response.created": return handleResponseCreated(rawEvent, state$1);
+		case "response.output_item.added": return handleOutputItemAdded$1(rawEvent, state$1);
+		case "response.reasoning_summary_text.delta": return handleReasoningSummaryTextDelta(rawEvent, state$1);
+		case "response.output_text.delta": return handleOutputTextDelta(rawEvent, state$1);
+		case "response.reasoning_summary_text.done": return handleReasoningSummaryTextDone(rawEvent, state$1);
+		case "response.output_text.done": return handleOutputTextDone(rawEvent, state$1);
+		case "response.output_item.done": return handleOutputItemDone$1(rawEvent, state$1);
+		case "response.function_call_arguments.delta": return handleFunctionCallArgumentsDelta(rawEvent, state$1);
+		case "response.function_call_arguments.done": return handleFunctionCallArgumentsDone(rawEvent, state$1);
+		case "response.completed":
+		case "response.incomplete": return handleResponseCompleted(rawEvent, state$1);
+		case "response.failed": return handleResponseFailed(rawEvent, state$1);
+		case "error": return handleErrorEvent(rawEvent, state$1);
+		default: return [];
+	}
+};
+const handleResponseCreated = (rawEvent, state$1) => {
+	return messageStart(state$1, rawEvent.response);
+};
+const handleOutputItemAdded$1 = (rawEvent, state$1) => {
+	const events$1 = new Array();
+	const functionCallDetails = extractFunctionCallDetails(rawEvent);
+	if (!functionCallDetails) return events$1;
+	const { outputIndex, toolCallId, name, initialArguments } = functionCallDetails;
+	const blockIndex = openFunctionCallBlock(state$1, {
+		outputIndex,
+		toolCallId,
+		name,
+		events: events$1
+	});
+	if (initialArguments !== void 0 && initialArguments.length > 0) {
 		events$1.push({
 			type: "content_block_delta",
-			index: state$1.contentBlockIndex,
+			index: blockIndex,
 			delta: {
-				type: "text_delta",
-				text: delta.content
+				type: "input_json_delta",
+				partial_json: initialArguments
 			}
 		});
+		state$1.blockHasDelta.add(blockIndex);
 	}
-	if (delta.content === "" && delta.reasoning_opaque && delta.reasoning_opaque.length > 0 && state$1.thinkingBlockOpen) {
-		events$1.push({
+	return events$1;
+};
+const handleOutputItemDone$1 = (rawEvent, state$1) => {
+	const events$1 = new Array();
+	const item = rawEvent.item;
+	const itemType = item.type;
+	const outputIndex = rawEvent.output_index;
+	if (itemType === "compaction") {
+		if (!item.id || !item.encrypted_content) return events$1;
+		const blockIndex$1 = openThinkingBlockIfNeeded(state$1, outputIndex, events$1);
+		if (!state$1.blockHasDelta.has(blockIndex$1)) events$1.push({
 			type: "content_block_delta",
-			index: state$1.contentBlockIndex,
+			index: blockIndex$1,
 			delta: {
-				type: "signature_delta",
-				signature: delta.reasoning_opaque
+				type: "thinking_delta",
+				thinking: THINKING_TEXT
 			}
-		}, {
-			type: "content_block_stop",
-			index: state$1.contentBlockIndex
 		});
-		state$1.contentBlockIndex++;
-		state$1.thinkingBlockOpen = false;
-	}
-}
-function handleMessageStart(state$1, events$1, chunk) {
-	if (!state$1.messageStartSent) {
-		const { cachedTokens, cacheCreationTokens, inputTokens } = getOpenAIChunkUsageTokens(chunk);
 		events$1.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 }
-				}
+			type: "content_block_delta",
+			index: blockIndex$1,
+			delta: {
+				type: "signature_delta",
+				signature: encodeCompactionCarrierSignature({
+					id: item.id,
+					encrypted_content: item.encrypted_content
+				})
 			}
 		});
-		state$1.messageStartSent = true;
+		state$1.blockHasDelta.add(blockIndex$1);
+		return events$1;
 	}
-}
-function handleReasoningOpaque(delta, events$1, state$1) {
-	if (delta.reasoning_opaque && delta.reasoning_opaque.length > 0) {
-		events$1.push({
-			type: "content_block_start",
-			index: state$1.contentBlockIndex,
-			content_block: {
-				type: "thinking",
-				thinking: ""
-			}
-		}, {
+	if (itemType !== "reasoning") return events$1;
+	const blockIndex = openThinkingBlockIfNeeded(state$1, outputIndex, events$1);
+	const signature = (item.encrypted_content ?? "") + "@" + item.id;
+	if (signature) {
+		if (!item.summary || item.summary.length === 0) events$1.push({
 			type: "content_block_delta",
-			index: state$1.contentBlockIndex,
+			index: blockIndex,
 			delta: {
 				type: "thinking_delta",
 				thinking: THINKING_TEXT
 			}
-		}, {
-			type: "content_block_delta",
-			index: state$1.contentBlockIndex,
-			delta: {
-				type: "signature_delta",
-				signature: delta.reasoning_opaque
-			}
-		}, {
-			type: "content_block_stop",
-			index: state$1.contentBlockIndex
 		});
-		state$1.contentBlockIndex++;
-	}
-}
-function handleThinkingText(delta, state$1, events$1) {
-	const reasoningText = delta.reasoning_text ?? delta.reasoning_content;
-	if (reasoningText && reasoningText.length > 0) {
-		if (state$1.contentBlockOpen) {
-			delta.content = reasoningText;
-			delta.reasoning_text = void 0;
-			delta.reasoning_content = void 0;
-			return;
-		}
-		if (!state$1.thinkingBlockOpen) {
-			events$1.push({
-				type: "content_block_start",
-				index: state$1.contentBlockIndex,
-				content_block: {
-					type: "thinking",
-					thinking: ""
-				}
-			});
-			state$1.thinkingBlockOpen = true;
-		}
 		events$1.push({
 			type: "content_block_delta",
-			index: state$1.contentBlockIndex,
+			index: blockIndex,
 			delta: {
-				type: "thinking_delta",
-				thinking: reasoningText
+				type: "signature_delta",
+				signature
 			}
 		});
+		state$1.blockHasDelta.add(blockIndex);
 	}
-}
-function closeThinkingBlockIfOpen(state$1, events$1) {
-	if (state$1.thinkingBlockOpen) {
+	return events$1;
+};
+const handleFunctionCallArgumentsDelta = (rawEvent, state$1) => {
+	const events$1 = new Array();
+	const outputIndex = rawEvent.output_index;
+	const deltaText = rawEvent.delta;
+	if (!deltaText) return events$1;
+	const blockIndex = openFunctionCallBlock(state$1, {
+		outputIndex,
+		events: events$1
+	});
+	const functionCallState = state$1.functionCallStateByOutputIndex.get(outputIndex);
+	if (!functionCallState) return handleFunctionCallArgumentsValidationError(new FunctionCallArgumentsValidationError("Received function call arguments delta without an open tool call block."), state$1, events$1);
+	const { nextCount, exceeded } = updateWhitespaceRunState(functionCallState.consecutiveWhitespaceCount, deltaText);
+	if (exceeded) return handleFunctionCallArgumentsValidationError(new FunctionCallArgumentsValidationError("Received function call arguments delta containing more than 20 consecutive whitespace characters."), state$1, events$1);
+	functionCallState.consecutiveWhitespaceCount = nextCount;
+	events$1.push({
+		type: "content_block_delta",
+		index: blockIndex,
+		delta: {
+			type: "input_json_delta",
+			partial_json: deltaText
+		}
+	});
+	state$1.blockHasDelta.add(blockIndex);
+	return events$1;
+};
+const handleFunctionCallArgumentsDone = (rawEvent, state$1) => {
+	const events$1 = new Array();
+	const outputIndex = rawEvent.output_index;
+	const blockIndex = openFunctionCallBlock(state$1, {
+		outputIndex,
+		events: events$1
+	});
+	const finalArguments = typeof rawEvent.arguments === "string" ? rawEvent.arguments : void 0;
+	if (!state$1.blockHasDelta.has(blockIndex) && finalArguments) {
 		events$1.push({
 			type: "content_block_delta",
-			index: state$1.contentBlockIndex,
+			index: blockIndex,
 			delta: {
-				type: "signature_delta",
-				signature: ""
+				type: "input_json_delta",
+				partial_json: finalArguments
 			}
-		}, {
-			type: "content_block_stop",
-			index: state$1.contentBlockIndex
 		});
-		state$1.contentBlockIndex++;
-		state$1.thinkingBlockOpen = false;
+		state$1.blockHasDelta.add(blockIndex);
 	}
-}
-
-//#endregion
-//#region src/routes/messages/api-flows.ts
-const handleWithChatCompletions = async (c, anthropicPayload, options) => {
-	const { logger: logger$7, subagentMarker, requestId, sessionId, compactType } = options;
-	const openAIPayload = translateToOpenAI(anthropicPayload);
-	const recordUsage = createCopilotUsageRecorder({
-		endpoint: "chat_completions",
-		fallbackSessionId: sessionId,
-		model: openAIPayload.model,
-		payload: anthropicPayload
+	state$1.functionCallStateByOutputIndex.delete(outputIndex);
+	return events$1;
+};
+const handleOutputTextDelta = (rawEvent, state$1) => {
+	const events$1 = new Array();
+	const outputIndex = rawEvent.output_index;
+	const contentIndex = rawEvent.content_index;
+	const deltaText = rawEvent.delta;
+	if (!deltaText) return events$1;
+	const blockIndex = openTextBlockIfNeeded(state$1, {
+		outputIndex,
+		contentIndex,
+		events: events$1
 	});
-	debugJson(logger$7, "Translated OpenAI request payload:", openAIPayload);
-	const response = await createChatCompletions(openAIPayload, {
-		subagentMarker,
-		requestId,
-		sessionId,
-		compactType
+	events$1.push({
+		type: "content_block_delta",
+		index: blockIndex,
+		delta: {
+			type: "text_delta",
+			text: deltaText
+		}
 	});
-	if (isNonStreaming(response)) {
-		debugJson(logger$7, "Non-streaming response from Copilot:", response);
-		recordUsage(normalizeOpenAIUsage(response.usage));
-		const anthropicResponse = translateToAnthropic(response);
-		debugJson(logger$7, "Translated Anthropic response:", anthropicResponse);
-		return c.json(anthropicResponse);
-	}
-	logger$7.debug("Streaming response from Copilot");
-	return streamSSE(c, async (stream) => {
-		let usage = {};
-		const streamState = {
-			messageStartSent: false,
-			contentBlockIndex: 0,
-			contentBlockOpen: false,
-			toolCalls: {},
-			thinkingBlockOpen: false
-		};
-		for await (const rawEvent of response) {
-			debugJson(logger$7, "Copilot raw stream event:", rawEvent);
-			if (rawEvent.data === "[DONE]") break;
-			if (!rawEvent.data) continue;
-			const chunk = JSON.parse(rawEvent.data);
-			if (chunk.usage) usage = normalizeOpenAIUsage(chunk.usage);
-			const events$1 = translateChunkToAnthropicEvents(chunk, streamState);
-			for (const event of events$1) {
-				const eventData = JSON.stringify(event);
-				debugLazy(logger$7, () => ["Translated Anthropic event:", eventData]);
-				await stream.writeSSE({
-					event: event.type,
-					data: eventData
-				});
-			}
+	state$1.blockHasDelta.add(blockIndex);
+	return events$1;
+};
+const handleReasoningSummaryTextDelta = (rawEvent, state$1) => {
+	const outputIndex = rawEvent.output_index;
+	const deltaText = rawEvent.delta;
+	const events$1 = new Array();
+	const blockIndex = openThinkingBlockIfNeeded(state$1, outputIndex, events$1);
+	events$1.push({
+		type: "content_block_delta",
+		index: blockIndex,
+		delta: {
+			type: "thinking_delta",
+			thinking: deltaText
 		}
-		for (const event of flushPendingAnthropicStreamEvents(streamState)) {
-			const eventData = JSON.stringify(event);
-			debugLazy(logger$7, () => ["Translated Anthropic event:", eventData]);
-			await stream.writeSSE({
-				event: event.type,
-				data: eventData
-			});
+	});
+	state$1.blockHasDelta.add(blockIndex);
+	return events$1;
+};
+const handleReasoningSummaryTextDone = (rawEvent, state$1) => {
+	const outputIndex = rawEvent.output_index;
+	const text = rawEvent.text;
+	const events$1 = new Array();
+	const blockIndex = openThinkingBlockIfNeeded(state$1, outputIndex, events$1);
+	if (text && !state$1.blockHasDelta.has(blockIndex)) events$1.push({
+		type: "content_block_delta",
+		index: blockIndex,
+		delta: {
+			type: "thinking_delta",
+			thinking: text
 		}
-		recordUsage(usage);
 	});
+	return events$1;
 };
-const handleWithResponsesApi = async (c, anthropicPayload, options) => {
-	const { logger: logger$7, selectedModel,...requestOptions } = options;
-	const responsesPayload = translateAnthropicMessagesToResponsesPayload(anthropicPayload);
-	const recordUsage = createCopilotUsageRecorder({
-		endpoint: "responses",
-		fallbackSessionId: requestOptions.sessionId,
-		model: responsesPayload.model,
-		payload: anthropicPayload
+const handleOutputTextDone = (rawEvent, state$1) => {
+	const events$1 = new Array();
+	const outputIndex = rawEvent.output_index;
+	const contentIndex = rawEvent.content_index;
+	const text = rawEvent.text;
+	const blockIndex = openTextBlockIfNeeded(state$1, {
+		outputIndex,
+		contentIndex,
+		events: events$1
 	});
-	applyResponsesApiContextManagement(responsesPayload, selectedModel?.capabilities.limits.max_prompt_tokens);
-	compactInputByLatestCompaction(responsesPayload);
-	debugJson(logger$7, "Translated Responses payload:", responsesPayload);
-	const { vision, initiator } = getResponsesRequestOptions(responsesPayload);
-	const response = await createResponses(responsesPayload, {
-		vision,
-		initiator,
-		...requestOptions
+	if (text && !state$1.blockHasDelta.has(blockIndex)) events$1.push({
+		type: "content_block_delta",
+		index: blockIndex,
+		delta: {
+			type: "text_delta",
+			text
+		}
 	});
-	if (responsesPayload.stream && isAsyncIterable$1(response)) {
-		logger$7.debug("Streaming response from Copilot (Responses API)");
-		return streamSSE(c, async (stream) => {
-			const streamState = createResponsesStreamState();
-			let usage = {};
-			for await (const chunk of response) {
-				if (chunk.event === "ping") {
-					await stream.writeSSE({
-						event: "ping",
-						data: "{\"type\":\"ping\"}"
-					});
-					continue;
-				}
-				const data = chunk.data;
-				if (!data) continue;
-				debugLazy(logger$7, () => ["Responses raw stream event:", data]);
-				const responseEvent = JSON.parse(data);
-				if (responseEvent.type === "response.completed" || responseEvent.type === "response.failed" || responseEvent.type === "response.incomplete") usage = normalizeResponsesUsage(responseEvent.response.usage);
-				const events$1 = translateResponsesStreamEvent(responseEvent, streamState);
-				for (const event of events$1) {
-					const eventData = JSON.stringify(event);
-					debugLazy(logger$7, () => ["Translated Anthropic event:", eventData]);
-					await stream.writeSSE({
-						event: event.type,
-						data: eventData
-					});
-				}
-				if (streamState.messageCompleted) {
-					logger$7.debug("Message completed, ending stream");
-					break;
-				}
+	return events$1;
+};
+const handleResponseCompleted = (rawEvent, state$1) => {
+	const response = rawEvent.response;
+	const events$1 = new Array();
+	closeAllOpenBlocks(state$1, events$1);
+	const anthropic = translateResponsesResultToAnthropic(response);
+	events$1.push({
+		type: "message_delta",
+		delta: {
+			stop_reason: anthropic.stop_reason,
+			stop_sequence: anthropic.stop_sequence
+		},
+		usage: anthropic.usage
+	}, { type: "message_stop" });
+	state$1.messageCompleted = true;
+	return events$1;
+};
+const handleResponseFailed = (rawEvent, state$1) => {
+	const response = rawEvent.response;
+	const events$1 = new Array();
+	closeAllOpenBlocks(state$1, events$1);
+	const message = response.error?.message ?? "The response failed due to an unknown error.";
+	events$1.push(buildErrorEvent(message));
+	state$1.messageCompleted = true;
+	return events$1;
+};
+const handleErrorEvent = (rawEvent, state$1) => {
+	const message = typeof rawEvent.message === "string" ? rawEvent.message : "An unexpected error occurred during streaming.";
+	state$1.messageCompleted = true;
+	return [buildErrorEvent(message)];
+};
+const handleFunctionCallArgumentsValidationError = (error, state$1, events$1 = []) => {
+	const reason = error.message;
+	closeAllOpenBlocks(state$1, events$1);
+	state$1.messageCompleted = true;
+	events$1.push(buildErrorEvent(reason));
+	return events$1;
+};
+const messageStart = (state$1, response) => {
+	state$1.messageStartSent = true;
+	const inputCachedTokens = response.usage?.input_tokens_details?.cached_tokens;
+	const inputTokens = (response.usage?.input_tokens ?? 0) - (inputCachedTokens ?? 0);
+	return [{
+		type: "message_start",
+		message: {
+			id: response.id,
+			type: "message",
+			role: "assistant",
+			content: [],
+			model: response.model,
+			stop_reason: null,
+			stop_sequence: null,
+			usage: {
+				input_tokens: inputTokens,
+				output_tokens: 0,
+				cache_read_input_tokens: inputCachedTokens ?? 0
 			}
-			if (!streamState.messageCompleted) {
-				logger$7.warn("Responses stream ended without completion; sending error event");
-				const errorEvent = buildErrorEvent("Responses stream ended without completion");
-				await stream.writeSSE({
-					event: errorEvent.type,
-					data: JSON.stringify(errorEvent)
-				});
+		}
+	}];
+};
+const openTextBlockIfNeeded = (state$1, params) => {
+	const { outputIndex, contentIndex, events: events$1 } = params;
+	const key = getBlockKey(outputIndex, contentIndex);
+	let blockIndex = state$1.blockIndexByKey.get(key);
+	if (blockIndex === void 0) {
+		blockIndex = state$1.nextContentBlockIndex;
+		state$1.nextContentBlockIndex += 1;
+		state$1.blockIndexByKey.set(key, blockIndex);
+	}
+	if (!state$1.openBlocks.has(blockIndex)) {
+		closeOpenBlocks(state$1, events$1);
+		events$1.push({
+			type: "content_block_start",
+			index: blockIndex,
+			content_block: {
+				type: "text",
+				text: ""
 			}
-			recordUsage(usage);
 		});
+		state$1.openBlocks.add(blockIndex);
 	}
-	debugJsonTail(logger$7, "Non-streaming Responses result:", {
-		value: response,
-		tailLength: 400
-	});
-	const anthropicResponse = translateResponsesResultToAnthropic(response);
-	recordUsage(normalizeResponsesUsage(response.usage));
-	debugJson(logger$7, "Translated Anthropic response:", anthropicResponse);
-	return c.json(anthropicResponse);
+	return blockIndex;
 };
-const handleWithMessagesApi = async (c, anthropicPayload, options) => {
-	const { logger: logger$7, anthropicBetaHeader, subagentMarker, selectedModel, requestId, sessionId, compactType } = options;
-	prepareMessagesApiPayload(anthropicPayload, selectedModel);
-	const recordUsage = createCopilotUsageRecorder({
-		endpoint: "messages",
-		fallbackSessionId: sessionId,
-		model: anthropicPayload.model,
-		payload: anthropicPayload
-	});
-	debugJson(logger$7, "Translated Messages payload:", anthropicPayload);
-	const response = await createMessages(anthropicPayload, anthropicBetaHeader, {
-		subagentMarker,
-		requestId,
-		sessionId,
-		compactType
-	});
-	if (isAsyncIterable$1(response)) {
-		logger$7.debug("Streaming response from Copilot (Messages API)");
-		return streamSSE(c, async (stream) => {
-			let usage = {};
-			for await (const event of response) {
-				const eventName = event.event;
-				const data = event.data ?? "";
-				if (data === "[DONE]") break;
-				if (!data) continue;
-				debugLazy(logger$7, () => ["Messages raw stream event:", data]);
-				const parsedEvent = parseAnthropicStreamEvent(data);
-				if (parsedEvent?.type === "message_start") usage = mergeAnthropicUsage(usage, normalizeAnthropicUsage(parsedEvent.message.usage));
-				else if (parsedEvent?.type === "message_delta") usage = mergeAnthropicUsage(usage, normalizeAnthropicUsage(parsedEvent.usage));
-				await stream.writeSSE({
-					event: eventName,
-					data
-				});
+const openThinkingBlockIfNeeded = (state$1, outputIndex, events$1) => {
+	const key = getBlockKey(outputIndex, 0);
+	let blockIndex = state$1.blockIndexByKey.get(key);
+	if (blockIndex === void 0) {
+		blockIndex = state$1.nextContentBlockIndex;
+		state$1.nextContentBlockIndex += 1;
+		state$1.blockIndexByKey.set(key, blockIndex);
+	}
+	if (!state$1.openBlocks.has(blockIndex)) {
+		closeOpenBlocks(state$1, events$1);
+		events$1.push({
+			type: "content_block_start",
+			index: blockIndex,
+			content_block: {
+				type: "thinking",
+				thinking: ""
 			}
-			recordUsage(usage);
 		});
+		state$1.openBlocks.add(blockIndex);
 	}
-	debugJsonTail(logger$7, "Non-streaming Messages result:", {
-		value: response,
-		tailLength: 400
+	return blockIndex;
+};
+const closeBlockIfOpen = (state$1, blockIndex, events$1) => {
+	if (!state$1.openBlocks.has(blockIndex)) return;
+	events$1.push({
+		type: "content_block_stop",
+		index: blockIndex
 	});
-	recordUsage(normalizeAnthropicUsage(response.usage));
-	return c.json(response);
+	state$1.openBlocks.delete(blockIndex);
+	state$1.blockHasDelta.delete(blockIndex);
 };
-const isNonStreaming = (response) => Object.hasOwn(response, "choices");
-const isAsyncIterable$1 = (value) => Boolean(value) && typeof value[Symbol.asyncIterator] === "function";
-const createCopilotUsageRecorder = (options) => createCopilotTokenUsageRecorder({
-	endpoint: options.endpoint,
-	fallbackSessionId: options.fallbackSessionId,
-	model: options.model,
-	sessionId: getMetadataSessionId(options.payload)
-});
-const getMetadataSessionId = (payload) => parseUserIdMetadata(payload.metadata?.user_id).sessionId;
-const parseAnthropicStreamEvent = (data) => {
-	try {
-		return JSON.parse(data);
-	} catch {
-		return null;
-	}
+const closeOpenBlocks = (state$1, events$1) => {
+	for (const blockIndex of state$1.openBlocks) closeBlockIfOpen(state$1, blockIndex, events$1);
 };
-
-//#endregion
-//#region src/lib/subagent.ts
-const subagentMarkerPrefix = "__SUBAGENT_MARKER__";
-
-//#endregion
-//#region src/routes/messages/subagent-marker.ts
-const parseSubagentMarkerFromFirstUser = (payload) => {
-	const firstUserMessage = payload.messages.find((msg) => msg.role === "user" && Array.isArray(msg.content));
-	if (!firstUserMessage || !Array.isArray(firstUserMessage.content)) return null;
-	for (const block of firstUserMessage.content) {
-		if (block.type !== "text") continue;
-		const marker = parseSubagentMarkerFromSystemReminder(block.text);
-		if (marker) return marker;
-	}
-	return null;
+const closeAllOpenBlocks = (state$1, events$1) => {
+	closeOpenBlocks(state$1, events$1);
+	state$1.functionCallStateByOutputIndex.clear();
 };
-const parseSubagentMarkerFromSystemReminder = (text) => {
-	const startTag = "<system-reminder>";
-	const endTag = "</system-reminder>";
-	let searchFrom = 0;
-	while (true) {
-		const reminderStart = text.indexOf(startTag, searchFrom);
-		if (reminderStart === -1) break;
-		const contentStart = reminderStart + 17;
-		const reminderEnd = text.indexOf(endTag, contentStart);
-		if (reminderEnd === -1) break;
-		const reminderContent = text.slice(contentStart, reminderEnd);
-		const markerIndex = reminderContent.indexOf(subagentMarkerPrefix);
-		if (markerIndex === -1) {
-			searchFrom = reminderEnd + 18;
-			continue;
-		}
-		const markerJson = reminderContent.slice(markerIndex + subagentMarkerPrefix.length).trim();
-		try {
-			const parsed = JSON.parse(markerJson);
-			if (!parsed.session_id || !parsed.agent_id || !parsed.agent_type) {
-				searchFrom = reminderEnd + 18;
-				continue;
+const buildErrorEvent = (message) => ({
+	type: "error",
+	error: {
+		type: "api_error",
+		message
+	}
+});
+const getBlockKey = (outputIndex, contentIndex) => `${outputIndex}:${contentIndex}`;
+const openFunctionCallBlock = (state$1, params) => {
+	const { outputIndex, toolCallId, name, events: events$1 } = params;
+	let functionCallState = state$1.functionCallStateByOutputIndex.get(outputIndex);
+	if (!functionCallState) {
+		const blockIndex$1 = state$1.nextContentBlockIndex;
+		state$1.nextContentBlockIndex += 1;
+		const resolvedToolCallId = toolCallId ?? `tool_call_${blockIndex$1}`;
+		functionCallState = {
+			blockIndex: blockIndex$1,
+			toolCallId: resolvedToolCallId,
+			name: name ?? "function",
+			consecutiveWhitespaceCount: 0
+		};
+		state$1.functionCallStateByOutputIndex.set(outputIndex, functionCallState);
+	}
+	const { blockIndex } = functionCallState;
+	if (!state$1.openBlocks.has(blockIndex)) {
+		closeOpenBlocks(state$1, events$1);
+		events$1.push({
+			type: "content_block_start",
+			index: blockIndex,
+			content_block: {
+				type: "tool_use",
+				id: functionCallState.toolCallId,
+				name: functionCallState.name,
+				input: {}
 			}
-			return parsed;
-		} catch {
-			searchFrom = reminderEnd + 18;
-			continue;
-		}
+		});
+		state$1.openBlocks.add(blockIndex);
 	}
-	return null;
+	return blockIndex;
+};
+const extractFunctionCallDetails = (rawEvent) => {
+	const item = rawEvent.item;
+	if (item.type !== "function_call") return;
+	const outputIndex = rawEvent.output_index;
+	const toolCallId = item.call_id;
+	const name = item.name;
+	const initialArguments = item.arguments;
+	return {
+		outputIndex,
+		toolCallId,
+		name,
+		initialArguments
+	};
 };
 
 //#endregion
-//#region src/routes/messages/handler.ts
-const logger$5 = createHandlerLogger("messages-handler");
-async function handleCompletion(c) {
-	await checkRateLimit(state);
-	const anthropicPayload = await c.req.json();
-	debugJson(logger$5, "Anthropic request payload:", anthropicPayload);
-	sanitizeIdeTools(anthropicPayload);
-	const subagentMarker = parseSubagentMarkerFromFirstUser(anthropicPayload);
-	if (subagentMarker) debugJson(logger$5, "Detected Subagent marker:", subagentMarker);
-	const sessionId = getRootSessionId(anthropicPayload, c);
-	logger$5.debug("Extracted session ID:", sessionId);
-	const compactType = getCompactType(anthropicPayload);
-	const anthropicBeta = c.req.header("anthropic-beta");
-	logger$5.debug("Anthropic Beta header:", anthropicBeta);
-	const noTools = !anthropicPayload.tools || anthropicPayload.tools.length === 0;
-	if (anthropicBeta && noTools && compactType === 0) anthropicPayload.model = getSmallModel();
-	if (compactType) logger$5.debug("Compact request type:", compactType);
-	stripToolReferenceTurnBoundary(anthropicPayload);
-	mergeToolResultForClaude(anthropicPayload, { skipLastMessage: compactType === COMPACT_REQUEST });
-	const requestId = generateRequestIdFromPayload(anthropicPayload, sessionId);
-	logger$5.debug("Generated request ID:", requestId);
-	if (state.manualApprove) await awaitApproval();
-	const selectedModel = findEndpointModel(anthropicPayload.model);
-	anthropicPayload.model = selectedModel?.id ?? anthropicPayload.model;
-	if (shouldUseMessagesApi(selectedModel)) return await handleWithMessagesApi(c, anthropicPayload, {
-		anthropicBetaHeader: anthropicBeta,
-		subagentMarker,
-		selectedModel,
-		requestId,
-		sessionId,
-		compactType,
-		logger: logger$5
-	});
-	if (shouldUseResponsesApi(selectedModel)) return await handleWithResponsesApi(c, anthropicPayload, {
-		subagentMarker,
-		selectedModel,
-		requestId,
-		sessionId,
-		compactType,
-		logger: logger$5
-	});
-	return await handleWithChatCompletions(c, anthropicPayload, {
-		subagentMarker,
-		requestId,
-		sessionId,
-		compactType,
-		logger: logger$5
-	});
-}
-const RESPONSES_ENDPOINT$1 = "/responses";
-const MESSAGES_ENDPOINT = "/v1/messages";
-const shouldUseResponsesApi = (selectedModel) => {
-	return selectedModel?.supported_endpoints?.includes(RESPONSES_ENDPOINT$1) ?? false;
+//#region src/routes/responses/utils.ts
+const getResponsesRequestOptions = (payload) => {
+	const vision = hasVisionInput(payload);
+	const initiator = hasAgentInitiator(payload) ? "agent" : "user";
+	return {
+		vision,
+		initiator
+	};
+};
+const hasAgentInitiator = (payload) => {
+	const lastItem = getPayloadItems(payload).at(-1);
+	if (!lastItem) return false;
+	if (!("role" in lastItem) || !lastItem.role) return true;
+	return (typeof lastItem.role === "string" ? lastItem.role.toLowerCase() : "") === "assistant";
 };
-const shouldUseMessagesApi = (selectedModel) => {
-	if (!isMessagesApiEnabled()) return false;
-	return selectedModel?.supported_endpoints?.includes(MESSAGES_ENDPOINT) ?? false;
+const hasVisionInput = (payload) => {
+	return getPayloadItems(payload).some((item) => containsVisionContent(item));
+};
+const resolveResponsesCompactThreshold = (maxPromptTokens) => {
+	if (typeof maxPromptTokens === "number" && maxPromptTokens > 0) return Math.floor(maxPromptTokens * .9);
+	return 5e4;
+};
+const createCompactionContextManagement = (compactThreshold) => [{
+	type: "compaction",
+	compact_threshold: compactThreshold
+}];
+const applyResponsesApiContextManagement = (payload, maxPromptTokens) => {
+	if (payload.context_management !== void 0) return;
+	if (!isResponsesApiContextManagementModel(payload.model)) return;
+	payload.context_management = createCompactionContextManagement(resolveResponsesCompactThreshold(maxPromptTokens));
+};
+const compactInputByLatestCompaction = (payload) => {
+	if (!Array.isArray(payload.input) || payload.input.length === 0) return;
+	const latestCompactionMessageIndex = getLatestCompactionMessageIndex(payload.input);
+	if (latestCompactionMessageIndex === void 0) return;
+	payload.input = payload.input.slice(latestCompactionMessageIndex);
+};
+const getLatestCompactionMessageIndex = (input) => {
+	for (let index = input.length - 1; index >= 0; index -= 1) if (isCompactionInputItem(input[index])) return index;
+};
+const isCompactionInputItem = (value) => {
+	return "type" in value && typeof value.type === "string" && value.type === "compaction";
+};
+const getPayloadItems = (payload) => {
+	const result = [];
+	const { input } = payload;
+	if (Array.isArray(input)) result.push(...input);
+	return result;
+};
+const containsVisionContent = (value) => {
+	if (!value) return false;
+	if (Array.isArray(value)) return value.some((entry) => containsVisionContent(entry));
+	if (typeof value !== "object") return false;
+	const record = value;
+	if ((typeof record.type === "string" ? record.type.toLowerCase() : void 0) === "input_image") return true;
+	if (Array.isArray(record.content)) return record.content.some((entry) => containsVisionContent(entry));
+	return false;
 };
 
 //#endregion
-//#region src/routes/messages/route.ts
-const messageRoutes = new Hono();
-messageRoutes.post("/", async (c) => {
-	try {
-		return await handleCompletion(c);
-	} catch (error) {
-		return await forwardError(c, error);
+//#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;
 	}
-});
-messageRoutes.post("/count_tokens", async (c) => {
-	try {
-		return await handleCountTokens(c);
-	} catch (error) {
-		return await forwardError(c, error);
+	if (thinking?.budget_tokens && !isAdaptiveThinking) return INTERLEAVED_THINKING_BETA;
+};
+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) 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)
+	});
+	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/models/route.ts
-const modelRoutes = new Hono();
-modelRoutes.get("/", async (c) => {
-	try {
-		if (!state.models) await cacheModels();
-		const models = state.models?.data.map((model) => {
-			const is1m = model.capabilities.limits?.max_context_window_tokens === 1e6;
-			return {
-				...model,
-				id: is1m ? `${model.id}[1m]` : model.id,
-				object: "model",
-				type: "model",
-				created: 0,
-				created_at: (/* @__PURE__ */ new Date(0)).toISOString(),
-				owned_by: model.vendor,
-				display_name: model.name
-			};
-		});
-		return c.json({
-			object: "list",
-			data: models,
-			has_more: false
-		});
-	} catch (error) {
-		return await forwardError(c, error);
+//#region src/routes/messages/preprocess.ts
+const TOOL_REFERENCE_TURN_BOUNDARY = "Tool loaded.";
+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 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(compactTextOnlyGuard) && text.includes(compactSummaryPromptStart) && 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 COMPACT_REQUEST;
+	if (lastMessage && isCompactAutoContinueMessage(lastMessage)) return COMPACT_AUTO_CONTINUE;
+	const system = anthropicPayload.system;
+	if (typeof system === "string") return compactSystemPromptStarts.some((promptStart) => system.startsWith(promptStart)) ? COMPACT_REQUEST : 0;
+	if (!Array.isArray(system)) return 0;
+	if (system.some((msg) => typeof msg.text === "string" && compactSystemPromptStarts.some((promptStart) => msg.text.startsWith(promptStart)))) return COMPACT_REQUEST;
+	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, 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}`
+		};
 	}
-});
-
-//#endregion
-//#region src/routes/provider/messages/count-tokens-handler.ts
-const logger$4 = createHandlerLogger("provider-count-tokens-handler");
-const createFallbackModel = (modelId) => ({
-	capabilities: {
-		family: "provider",
-		limits: {},
-		object: "model_capabilities",
-		supports: {},
-		tokenizer: "o200k_base",
-		type: "chat"
-	},
-	id: modelId,
-	model_picker_enabled: false,
-	name: modelId,
-	object: "model",
-	preview: false,
-	vendor: "provider",
-	version: "unknown"
-});
-async function handleProviderCountTokens(c) {
-	const provider = c.req.param("provider");
-	try {
-		const anthropicPayload = await c.req.json();
-		const modelId = anthropicPayload.model.trim();
-		const providerConfig = getProviderConfig(provider);
-		const modelConfig = providerConfig?.models?.[modelId];
-		const translationOptions = providerConfig?.type === "openai-compatible" ? {
-			supportPdf: modelConfig?.supportPdf,
-			toolContentSupportType: modelConfig?.toolContentSupportType ?? []
-		} : void 0;
-		const openAIPayload = translateToOpenAI(anthropicPayload, translationOptions);
-		let selectedModel = state.models?.data.find((model) => model.id === modelId);
-		if (!selectedModel && modelId) selectedModel = createFallbackModel(modelId);
-		if (!selectedModel) {
-			logger$4.warn("provider.count_tokens.model_not_found", {
-				provider,
-				model: anthropicPayload.model
+	if (hasToolRef(tr)) return tr;
+	return {
+		...tr,
+		content: [...tr.content, ...textBlocks]
+	};
+};
+const mergeContentWithAttachments = (tr, attachments) => {
+	if (typeof tr.content === "string") return {
+		...tr,
+		content: [{
+			type: "text",
+			text: tr.content
+		}, ...attachments]
+	};
+	return {
+		...tr,
+		content: [...tr.content, ...attachments]
+	};
+};
+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;
+		const orderedAttachments = [...matchedAttachments].sort((left, right) => left.order - right.order).map(({ attachment }) => attachment);
+		return mergeContentWithAttachments(block, orderedAttachments);
+	});
+};
+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$1 = target.get(toolResultIndex);
+			if (currentAttachments$1) {
+				currentAttachments$1.push(attachments[index]);
+				continue;
+			}
+			target.set(toolResultIndex, [attachments[index]]);
+		}
+		return;
+	}
+	const lastToolResultIndex = fallbackToolResultIndices.at(-1);
+	if (lastToolResultIndex === void 0) return;
+	const currentAttachments = target.get(lastToolResultIndex);
+	if (currentAttachments) {
+		currentAttachments.push(...attachments);
+		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 (block.type === "text") {
+			textBlocks.push(block);
+			continue;
+		}
+		if (isAttachmentBlock(block)) {
+			attachments.push({
+				attachment: block,
+				order
 			});
-			return c.json({ input_tokens: 1 });
+			continue;
 		}
-		const tokenCount = await getTokenCount(openAIPayload, selectedModel);
-		const finalTokenCount = tokenCount.input + tokenCount.output;
-		logger$4.debug("provider.count_tokens.success", {
-			provider,
-			model: anthropicPayload.model,
-			input_tokens: finalTokenCount
-		});
-		return c.json({ input_tokens: finalTokenCount });
-	} catch (error) {
-		logger$4.error("provider.count_tokens.error", {
-			provider,
-			error
-		});
-		return c.json({ input_tokens: 1 });
+		return null;
 	}
-}
-
-//#endregion
-//#region src/services/providers/anthropic-proxy.ts
-const SHARED_FORWARDABLE_HEADERS = ["accept", "user-agent"];
-const ANTHROPIC_FORWARDABLE_HEADERS = ["anthropic-version", "anthropic-beta"];
-const STRIPPED_RESPONSE_HEADERS = [
-	"connection",
-	"content-encoding",
-	"content-length",
-	"keep-alive",
-	"proxy-authenticate",
-	"proxy-authorization",
-	"te",
-	"trailer",
-	"transfer-encoding",
-	"upgrade"
-];
-function buildProviderUpstreamHeaders(providerConfig, requestHeaders) {
-	const authHeaders = {};
-	if (providerConfig.authType === "authorization") authHeaders.authorization = `Bearer ${providerConfig.apiKey}`;
-	else authHeaders["x-api-key"] = providerConfig.apiKey;
-	const headers = {
-		"content-type": "application/json",
-		accept: "application/json",
-		...authHeaders
+	return {
+		toolResults,
+		textBlocks,
+		attachments
 	};
-	for (const headerName of SHARED_FORWARDABLE_HEADERS) {
-		const headerValue = requestHeaders.get(headerName);
-		if (headerValue) headers[headerName] = headerValue;
-	}
-	if (providerConfig.type !== "anthropic") return headers;
-	for (const headerName of ANTHROPIC_FORWARDABLE_HEADERS) {
-		const headerValue = requestHeaders.get(headerName);
-		if (headerValue) headers[headerName] = headerValue;
+};
+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));
 	}
-	return headers;
-}
-function createProviderProxyResponse(upstreamResponse) {
-	const headers = new Headers(upstreamResponse.headers);
-	for (const headerName of STRIPPED_RESPONSE_HEADERS) headers.delete(headerName);
-	return new Response(upstreamResponse.body, {
-		headers,
-		status: upstreamResponse.status,
-		statusText: upstreamResponse.statusText
-	});
-}
-async function forwardProviderMessages(providerConfig, payload, requestHeaders) {
-	return await fetch(`${providerConfig.baseUrl}/v1/messages`, {
-		method: "POST",
-		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders),
-		body: JSON.stringify(payload)
-	});
-}
-async function forwardProviderChatCompletions(providerConfig, payload, requestHeaders) {
-	return await fetch(`${providerConfig.baseUrl}/v1/chat/completions`, {
-		method: "POST",
-		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders),
-		body: JSON.stringify(payload)
+	assignAttachmentsToToolResults(attachmentsByToolResultIndex, remainingAttachments, {
+		toolResultIndices: countMatchToolResultIndices,
+		fallbackToolResultIndices: mergeableToolResultIndices
 	});
-}
-async function forwardProviderModels(providerConfig, requestHeaders) {
-	return await fetch(`${providerConfig.baseUrl}/v1/models`, {
-		method: "GET",
-		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders)
+	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;
+	const mergedToolResults = textBlocks.length === 0 ? toolResults : mergeToolResult(toolResults, textBlocks);
+	return mergeAttachmentsForToolResults(mergedToolResults, 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_REFERENCE_TURN_BOUNDARY);
+	}
+};
+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;
+	}
+};
+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];
 	});
-}
-
-//#endregion
-//#region src/routes/provider/messages/handler.ts
-const logger$3 = createHandlerLogger("provider-messages-handler");
-const OPENAI_COMPATIBLE_CONTEXT_CACHE_MARKER_LIMIT = 4;
-const OPENAI_COMPATIBLE_CONTEXT_CACHE_CONTROL = { type: "ephemeral" };
-const OPENAI_COMPATIBLE_CONTEXT_CACHE_ROLES = new Set([
-	"system",
-	"user",
-	"assistant",
-	"tool"
-]);
-async function handleProviderMessages(c) {
-	const provider = c.req.param("provider");
-	const providerConfig = getProviderConfig(provider);
-	if (!providerConfig) return c.json({ error: {
-		message: `Provider '${provider}' not found or disabled`,
-		type: "invalid_request_error"
-	} }, 404);
-	try {
-		const payload = await c.req.json();
-		const modelConfig = providerConfig.models?.[payload.model];
-		applyModelDefaults(payload, modelConfig);
-		debugJson(logger$3, "provider.messages.request", {
-			payload,
-			provider
-		});
-		if (providerConfig.type === "openai-compatible") return await handleOpenAICompatibleProviderMessages(c, {
-			modelConfig,
-			payload,
-			provider,
-			providerConfig
-		});
-		applyMissingExtraBody(payload, { extraBody: modelConfig?.extraBody });
-		const upstreamResponse = await forwardProviderMessages(providerConfig, payload, c.req.raw.headers);
-		if (!upstreamResponse.ok) {
-			logger$3.error("Failed to create responses", upstreamResponse);
-			throw new HTTPError("Failed to create responses", upstreamResponse);
+};
+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 systemBlock = block;
+		const cacheControl = systemBlock.cache_control;
+		if (cacheControl && typeof cacheControl === "object") {
+			const { scope,...rest } = cacheControl;
+			systemBlock.cache_control = rest;
 		}
-		const contentType = upstreamResponse.headers.get("content-type") ?? "";
-		if (Boolean(payload.stream) && contentType.includes("text/event-stream")) return streamProviderMessages({
-			c,
-			payload,
-			provider,
-			providerConfig,
-			upstreamResponse
-		});
-		const jsonBody = await upstreamResponse.json();
-		return respondProviderMessagesJson(c, {
-			body: jsonBody,
-			payload,
-			provider,
-			providerConfig
-		});
-	} catch (error) {
-		logger$3.error("provider.messages.error", {
-			provider,
-			error
-		});
-		throw error;
 	}
-}
-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 handleOpenAICompatibleProviderMessages = async (c, options) => {
-	const { modelConfig, payload, provider, providerConfig } = options;
-	const openAIPayload = createOpenAICompatiblePayload(payload, modelConfig);
-	debugJson(logger$3, "provider.messages.openai_compatible.request", {
-		payload: openAIPayload,
-		provider
+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 (payload.model === "claude-opus-4.7") 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/messages/api-flows.ts
+const COPILOT_CONTEXT_CACHE_SYSTEM_MARKER_LIMIT = 2;
+const COPILOT_CONTEXT_CACHE_NON_SYSTEM_MARKER_LIMIT = 2;
+const COPILOT_CONTEXT_CACHE_CONTROL = { type: "ephemeral" };
+const handleWithChatCompletions = async (c, anthropicPayload, options) => {
+	const { logger: logger$7, subagentMarker, requestId, sessionId, compactType } = options;
+	const openAIPayload = translateToOpenAI(anthropicPayload);
+	prepareCopilotChatCompletionsPayload(openAIPayload);
+	const recordUsage = createCopilotUsageRecorder({
+		endpoint: "chat_completions",
+		fallbackSessionId: sessionId,
+		model: openAIPayload.model,
+		payload: anthropicPayload
 	});
-	const upstreamResponse = await forwardProviderChatCompletions(providerConfig, openAIPayload, c.req.raw.headers);
-	if (!upstreamResponse.ok) {
-		logger$3.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
+	debugJson(logger$7, "Translated OpenAI request payload:", openAIPayload);
+	const response = await createChatCompletions(openAIPayload, {
+		subagentMarker,
+		requestId,
+		sessionId,
+		compactType
 	});
-	const jsonBody = await upstreamResponse.json();
-	return respondOpenAICompatibleProviderMessagesJson(c, {
-		body: jsonBody,
-		payload,
-		provider
+	if (isNonStreaming(response)) {
+		debugJson(logger$7, "Non-streaming response from Copilot:", response);
+		recordUsage(normalizeOpenAIUsage(response.usage));
+		const anthropicResponse = translateToAnthropic(response);
+		debugJson(logger$7, "Translated Anthropic response:", anthropicResponse);
+		return c.json(anthropicResponse);
+	}
+	logger$7.debug("Streaming response from Copilot");
+	return streamSSE(c, async (stream) => {
+		let usage = {};
+		const streamState = {
+			messageStartSent: false,
+			contentBlockIndex: 0,
+			contentBlockOpen: false,
+			toolCalls: {},
+			thinkingBlockOpen: false
+		};
+		for await (const rawEvent of response) {
+			debugJson(logger$7, "Copilot raw stream event:", rawEvent);
+			if (rawEvent.data === "[DONE]") break;
+			if (!rawEvent.data) continue;
+			const chunk = JSON.parse(rawEvent.data);
+			if (chunk.usage) usage = normalizeOpenAIUsage(chunk.usage);
+			const events$1 = translateChunkToAnthropicEvents(chunk, streamState);
+			for (const event of events$1) {
+				const eventData = JSON.stringify(event);
+				debugLazy(logger$7, () => ["Translated Anthropic event:", eventData]);
+				await stream.writeSSE({
+					event: event.type,
+					data: eventData
+				});
+			}
+		}
+		for (const event of flushPendingAnthropicStreamEvents(streamState)) {
+			const eventData = JSON.stringify(event);
+			debugLazy(logger$7, () => ["Translated Anthropic event:", eventData]);
+			await stream.writeSSE({
+				event: event.type,
+				data: eventData
+			});
+		}
+		recordUsage(usage);
 	});
 };
-const createOpenAICompatiblePayload = (payload, modelConfig) => {
-	const openAIPayload = translateToOpenAI(payload, {
-		supportPdf: modelConfig?.supportPdf,
-		toolContentSupportType: modelConfig?.toolContentSupportType ?? []
+const handleWithResponsesApi = async (c, anthropicPayload, options) => {
+	const { logger: logger$7, selectedModel,...requestOptions } = options;
+	const responsesPayload = translateAnthropicMessagesToResponsesPayload(anthropicPayload);
+	const recordUsage = createCopilotUsageRecorder({
+		endpoint: "responses",
+		fallbackSessionId: requestOptions.sessionId,
+		model: responsesPayload.model,
+		payload: anthropicPayload
 	});
-	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
+	applyResponsesApiContextManagement(responsesPayload, selectedModel?.capabilities.limits.max_prompt_tokens);
+	compactInputByLatestCompaction(responsesPayload);
+	debugJson(logger$7, "Translated Responses payload:", responsesPayload);
+	const { vision, initiator } = getResponsesRequestOptions(responsesPayload);
+	const response = await createResponses(responsesPayload, {
+		vision,
+		initiator,
+		...requestOptions
 	});
-	applyMissingExtraBody(openAIPayload, { extraBody: modelConfig?.extraBody });
-	if (!Object.hasOwn(openAIPayload, "parallel_tool_calls")) openAIPayload.parallel_tool_calls = true;
-	if (modelConfig?.contextCache !== false) applyOpenAICompatibleContextCache(openAIPayload);
-	return openAIPayload;
+	if (responsesPayload.stream && isAsyncIterable$1(response)) {
+		logger$7.debug("Streaming response from Copilot (Responses API)");
+		return streamSSE(c, async (stream) => {
+			const streamState = createResponsesStreamState();
+			let usage = {};
+			for await (const chunk of response) {
+				if (chunk.event === "ping") {
+					await stream.writeSSE({
+						event: "ping",
+						data: "{\"type\":\"ping\"}"
+					});
+					continue;
+				}
+				const data = chunk.data;
+				if (!data) continue;
+				debugLazy(logger$7, () => ["Responses raw stream event:", data]);
+				const responseEvent = JSON.parse(data);
+				if (responseEvent.type === "response.completed" || responseEvent.type === "response.failed" || responseEvent.type === "response.incomplete") usage = normalizeResponsesUsage(responseEvent.response.usage);
+				const events$1 = translateResponsesStreamEvent(responseEvent, streamState);
+				for (const event of events$1) {
+					const eventData = JSON.stringify(event);
+					debugLazy(logger$7, () => ["Translated Anthropic event:", eventData]);
+					await stream.writeSSE({
+						event: event.type,
+						data: eventData
+					});
+				}
+				if (streamState.messageCompleted) {
+					logger$7.debug("Message completed, ending stream");
+					break;
+				}
+			}
+			if (!streamState.messageCompleted) {
+				logger$7.warn("Responses stream ended without completion; sending error event");
+				const errorEvent = buildErrorEvent("Responses stream ended without completion");
+				await stream.writeSSE({
+					event: errorEvent.type,
+					data: JSON.stringify(errorEvent)
+				});
+			}
+			recordUsage(usage);
+		});
+	}
+	debugJsonTail(logger$7, "Non-streaming Responses result:", {
+		value: response,
+		tailLength: 400
+	});
+	const anthropicResponse = translateResponsesResultToAnthropic(response);
+	recordUsage(normalizeResponsesUsage(response.usage));
+	debugJson(logger$7, "Translated Anthropic response:", anthropicResponse);
+	return c.json(anthropicResponse);
 };
-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 handleWithMessagesApi = async (c, anthropicPayload, options) => {
+	const { logger: logger$7, anthropicBetaHeader, subagentMarker, selectedModel, requestId, sessionId, compactType } = options;
+	prepareMessagesApiPayload(anthropicPayload, selectedModel);
+	const recordUsage = createCopilotUsageRecorder({
+		endpoint: "messages",
+		fallbackSessionId: sessionId,
+		model: anthropicPayload.model,
+		payload: anthropicPayload
+	});
+	debugJson(logger$7, "Translated Messages payload:", anthropicPayload);
+	const response = await createMessages(anthropicPayload, anthropicBetaHeader, {
+		subagentMarker,
+		requestId,
+		sessionId,
+		compactType
+	});
+	if (isAsyncIterable$1(response)) {
+		logger$7.debug("Streaming response from Copilot (Messages API)");
+		return streamSSE(c, async (stream) => {
+			let usage = {};
+			for await (const event of response) {
+				const eventName = event.event;
+				const data = event.data ?? "";
+				if (data === "[DONE]") break;
+				if (!data) continue;
+				debugLazy(logger$7, () => ["Messages raw stream event:", data]);
+				const parsedEvent = parseAnthropicStreamEvent(data);
+				if (parsedEvent?.type === "message_start") usage = mergeAnthropicUsage(usage, normalizeAnthropicUsage(parsedEvent.message.usage));
+				else if (parsedEvent?.type === "message_delta") usage = mergeAnthropicUsage(usage, normalizeAnthropicUsage(parsedEvent.usage));
+				await stream.writeSSE({
+					event: eventName,
+					data
+				});
+			}
+			recordUsage(usage);
+		});
 	}
+	debugJsonTail(logger$7, "Non-streaming Messages result:", {
+		value: response,
+		tailLength: 400
+	});
+	recordUsage(normalizeAnthropicUsage(response.usage));
+	return c.json(response);
 };
-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 prepareCopilotChatCompletionsPayload = (payload) => {
+	applyCopilotContextCache(payload);
 };
-const applyOpenAICompatibleContextCache = (payload) => {
-	const messageIndexes = selectContextCacheMessageIndexes(payload.messages);
-	for (const messageIndex of messageIndexes) applyContextCacheControl(payload.messages[messageIndex]);
+const applyCopilotContextCache = (payload) => {
+	const messageIndexes = selectCopilotContextCacheMessageIndexes(payload.messages);
+	for (const messageIndex of messageIndexes) {
+		const message = payload.messages[messageIndex];
+		message.copilot_cache_control = { ...COPILOT_CONTEXT_CACHE_CONTROL };
+	}
 };
-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([...systemIndexes, ...finalIndexes]).sort((a, b) => a - b);
+const selectCopilotContextCacheMessageIndexes = (messages) => {
+	const systemIndexes = messages.flatMap((message, index) => message.role === "system" && isCopilotContextCacheEligible(message) ? [index] : []).slice(0, COPILOT_CONTEXT_CACHE_SYSTEM_MARKER_LIMIT);
+	const reverseNonSystemIndexes = messages.flatMap((message, index) => message.role !== "system" && isCopilotContextCacheEligible(message) ? [index] : []).reverse().slice(0, COPILOT_CONTEXT_CACHE_NON_SYSTEM_MARKER_LIMIT);
+	return uniqueIndexes([...systemIndexes, ...reverseNonSystemIndexes]).sort((a, b) => a - b);
 };
-const uniqueIndexes = (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;
+const isCopilotContextCacheEligible = (message) => {
 	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;
+const uniqueIndexes = (indexes) => [...new Set(indexes)];
+const isNonStreaming = (response) => Object.hasOwn(response, "choices");
+const isAsyncIterable$1 = (value) => Boolean(value) && typeof value[Symbol.asyncIterator] === "function";
+const createCopilotUsageRecorder = (options) => createCopilotTokenUsageRecorder({
+	endpoint: options.endpoint,
+	fallbackSessionId: options.fallbackSessionId,
+	model: options.model,
+	sessionId: getMetadataSessionId(options.payload)
+});
+const getMetadataSessionId = (payload) => parseUserIdMetadata(payload.metadata?.user_id).sessionId;
+const parseAnthropicStreamEvent = (data) => {
+	try {
+		return JSON.parse(data);
+	} catch {
+		return null;
 	}
-	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 };
+
+//#endregion
+//#region src/lib/subagent.ts
+const subagentMarkerPrefix = "__SUBAGENT_MARKER__";
+
+//#endregion
+//#region src/routes/messages/subagent-marker.ts
+const parseSubagentMarkerFromFirstUser = (payload) => {
+	const firstUserMessage = payload.messages.find((msg) => msg.role === "user" && Array.isArray(msg.content));
+	if (!firstUserMessage || !Array.isArray(firstUserMessage.content)) return null;
+	for (const block of firstUserMessage.content) {
+		if (block.type !== "text") continue;
+		const marker = parseSubagentMarkerFromSystemReminder(block.text);
+		if (marker) return marker;
+	}
+	return null;
 };
-const streamProviderMessages = ({ c, payload, provider, providerConfig, upstreamResponse }) => {
-	logger$3.debug("provider.messages.streaming");
-	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
-	return streamSSE(c, async (stream) => {
-		let usage = {};
-		for await (const chunk of events(upstreamResponse)) {
-			logger$3.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
-			});
+const parseSubagentMarkerFromSystemReminder = (text) => {
+	const startTag = "<system-reminder>";
+	const endTag = "</system-reminder>";
+	let searchFrom = 0;
+	while (true) {
+		const reminderStart = text.indexOf(startTag, searchFrom);
+		if (reminderStart === -1) break;
+		const contentStart = reminderStart + 17;
+		const reminderEnd = text.indexOf(endTag, contentStart);
+		if (reminderEnd === -1) break;
+		const reminderContent = text.slice(contentStart, reminderEnd);
+		const markerIndex = reminderContent.indexOf(subagentMarkerPrefix);
+		if (markerIndex === -1) {
+			searchFrom = reminderEnd + 18;
+			continue;
 		}
-		recordUsage(usage);
-	});
-};
-const streamOpenAICompatibleProviderMessages = ({ c, payload, provider, upstreamResponse }) => {
-	logger$3.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$3.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;
+		const markerJson = reminderContent.slice(markerIndex + subagentMarkerPrefix.length).trim();
+		try {
+			const parsed = JSON.parse(markerJson);
+			if (!parsed.session_id || !parsed.agent_id || !parsed.agent_type) {
+				searchFrom = reminderEnd + 18;
 				continue;
 			}
-			const parsed = parseOpenAICompatibleStreamChunk(chunk.data);
-			if (!parsed) continue;
-			if (parsed.usage) usage = normalizeOpenAIUsage(parsed.usage);
-			const events$1 = translateChunkToAnthropicEvents(parsed, streamState);
-			for (const event of events$1) {
-				const eventData = JSON.stringify(event);
-				debugLazy(logger$3, () => ["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$3, () => ["provider.messages.openai_compatible.translated_event:", eventData]);
-			await stream.writeSSE({
-				event: event.type,
-				data: eventData
-			});
+			return parsed;
+		} catch {
+			searchFrom = reminderEnd + 18;
+			continue;
 		}
-		recordUsage(usage);
+	}
+	return null;
+};
+
+//#endregion
+//#region src/routes/messages/handler.ts
+const logger$3 = createHandlerLogger("messages-handler");
+const messagesFlowHandlers = {
+	handleWithChatCompletions,
+	handleWithMessagesApi,
+	handleWithResponsesApi
+};
+async function handleCompletion(c) {
+	const anthropicPayload = await c.req.json();
+	const providerModelAlias = parseProviderModelAlias(anthropicPayload.model);
+	if (providerModelAlias) {
+		anthropicPayload.model = providerModelAlias.model;
+		return await handleProviderMessagesForProvider(c, {
+			payload: anthropicPayload,
+			provider: providerModelAlias.provider
+		});
+	}
+	await checkRateLimit(state);
+	debugJson(logger$3, "Anthropic request payload:", anthropicPayload);
+	sanitizeIdeTools(anthropicPayload);
+	const subagentMarker = parseSubagentMarkerFromFirstUser(anthropicPayload);
+	if (subagentMarker) debugJson(logger$3, "Detected Subagent marker:", subagentMarker);
+	const sessionId = getRootSessionId(anthropicPayload, c);
+	logger$3.debug("Extracted session ID:", sessionId);
+	const compactType = getCompactType(anthropicPayload);
+	const anthropicBeta = c.req.header("anthropic-beta");
+	logger$3.debug("Anthropic Beta header:", anthropicBeta);
+	const noTools = !anthropicPayload.tools || anthropicPayload.tools.length === 0;
+	if (anthropicBeta && noTools && compactType === 0) anthropicPayload.model = getSmallModel();
+	if (compactType) logger$3.debug("Compact request type:", compactType);
+	stripToolReferenceTurnBoundary(anthropicPayload);
+	mergeToolResultForClaude(anthropicPayload, { skipLastMessage: compactType === COMPACT_REQUEST });
+	const requestId = generateRequestIdFromPayload(anthropicPayload, sessionId);
+	logger$3.debug("Generated request ID:", requestId);
+	if (state.manualApprove) await awaitApproval();
+	const selectedModel = findEndpointModel(anthropicPayload.model);
+	anthropicPayload.model = selectedModel?.id ?? anthropicPayload.model;
+	if (shouldUseMessagesApi(selectedModel)) return await messagesFlowHandlers.handleWithMessagesApi(c, anthropicPayload, {
+		anthropicBetaHeader: anthropicBeta,
+		subagentMarker,
+		selectedModel,
+		requestId,
+		sessionId,
+		compactType,
+		logger: logger$3
+	});
+	if (shouldUseResponsesApi(selectedModel)) return await messagesFlowHandlers.handleWithResponsesApi(c, anthropicPayload, {
+		subagentMarker,
+		selectedModel,
+		requestId,
+		sessionId,
+		compactType,
+		logger: logger$3
+	});
+	return await messagesFlowHandlers.handleWithChatCompletions(c, anthropicPayload, {
+		subagentMarker,
+		requestId,
+		sessionId,
+		compactType,
+		logger: logger$3
 	});
+}
+const RESPONSES_ENDPOINT$1 = "/responses";
+const MESSAGES_ENDPOINT = "/v1/messages";
+const shouldUseResponsesApi = (selectedModel) => {
+	return selectedModel?.supported_endpoints?.includes(RESPONSES_ENDPOINT$1) ?? false;
 };
-const parseOpenAICompatibleStreamChunk = (data) => {
+const shouldUseMessagesApi = (selectedModel) => {
+	if (!isMessagesApiEnabled()) return false;
+	return selectedModel?.supported_endpoints?.includes(MESSAGES_ENDPOINT) ?? false;
+};
+
+//#endregion
+//#region src/routes/messages/route.ts
+const messageRoutes = new Hono();
+messageRoutes.post("/", async (c) => {
 	try {
-		return JSON.parse(data);
+		return await handleCompletion(c);
 	} catch (error) {
-		logger$3.error("provider.messages.openai_compatible.parse_chunk_error", {
-			data,
-			error
-		});
-		return null;
+		return await forwardError(c, error);
 	}
-};
-const parseProviderStreamEvent = (data, providerConfig) => {
+});
+messageRoutes.post("/count_tokens", async (c) => {
 	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 await handleCountTokens(c);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+
+//#endregion
+//#region src/routes/models/route.ts
+const modelRoutes = new Hono();
+modelRoutes.get("/", async (c) => {
+	try {
+		if (!state.models) await cacheModels();
+		const models = state.models?.data.map((model) => {
+			const is1m = model.capabilities.limits?.max_context_window_tokens === 1e6;
 			return {
-				data: JSON.stringify(parsed),
-				usage: normalizeAnthropicUsage(parsed.usage)
+				...model,
+				id: is1m ? `${model.id}[1m]` : model.id,
+				object: "model",
+				type: "model",
+				created: 0,
+				created_at: (/* @__PURE__ */ new Date(0)).toISOString(),
+				owned_by: model.vendor,
+				display_name: model.name
 			};
-		}
-		return {
-			data: JSON.stringify(parsed),
-			usage: {}
-		};
-	} catch (error) {
-		logger$3.error("provider.messages.streaming.adjust_tokens_error", {
-			error,
-			originalData: data
 		});
-		return null;
+		return c.json({
+			object: "list",
+			data: models,
+			has_more: false
+		});
+	} catch (error) {
+		return await forwardError(c, error);
 	}
-};
-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$3, "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$3, "provider.messages.openai_compatible.no_stream result:", anthropicResponse);
-	return c.json(anthropicResponse);
-};
-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$3, "provider.messages.adjusted_usage:", usage);
-};
 
 //#endregion
 //#region src/routes/provider/messages/route.ts
@@ -4310,4 +4376,4 @@ server.route("/:provider/v1/models", providerModelRoutes);
 
 //#endregion
 export { server };
-//# sourceMappingURL=server-D4FT8suK.js.map
+//# sourceMappingURL=server-D4pg54e1.js.map