@dianshuv/copilot-api 0.19.0 → 0.20.0

package/dist/main.mjs

@@ -143,7 +143,6 @@ const state = {
 	allowTokenEndpoint: false,
 	autoTruncate: true,
 	compressToolResults: false,
-	redirectAnthropic: false,
 	stripServerTools: false,
 	contextEditingMode: "off",
 	normalizeResponsesCallIds: true,
@@ -1012,7 +1011,7 @@ const logout = defineCommand({
 
 //#endregion
 //#region package.json
-var version = "0.19.0";
+var version = "0.20.0";
 
 //#endregion
 //#region src/lib/event-loop-lag.ts
@@ -3567,9 +3566,8 @@ async function autoTruncateOpenAI(payload, model, config = {}) {
 *
 * Pre-flight steps for any request whose final payload is an OpenAI
 * ChatCompletionsPayload — auto-truncate decisions, 413 diagnostic logging,
-* and the non-streaming type guard. Used by both `routes/chat-completions`
-* (native OpenAI) and `routes/messages/translated-handler` (Anthropic that
-* gets translated into OpenAI shape before hitting upstream).
+* and the non-streaming type guard. Used by `routes/chat-completions`
+* (native OpenAI).
 */
 /** Type guard for non-streaming responses */
 function isNonStreaming(response) {
@@ -3777,89 +3775,6 @@ function createStreamRepetitionChecker(label, config) {
 	};
 }
 
-//#endregion
-//#region src/lib/anthropic/beta.ts
-/**
-* Vendor-neutral utilities for manipulating the `anthropic-beta` request header.
-*
-* Lives in `lib/anthropic/` (not in either transport module) so both the
-* Anthropic-native and OpenAI-translated transport layers can share these
-* helpers without introducing cross-transport imports.
-*/
-/** Anthropic beta feature that unlocks the 1M context window. */
-const CONTEXT_1M_BETA_FEATURE = "context-1m-2025-08-07";
-/**
-* Merge two comma-separated anthropic-beta header values. Trims whitespace,
-* drops empty tokens, and dedupes by exact string match. Returns a canonical
-* comma-joined string with no spaces.
-*
-* Either input may be undefined / empty.
-*/
-function mergeBetaFeatures(existing, incoming) {
-	const seen = /* @__PURE__ */ new Set();
-	const out = [];
-	for (const raw of [existing, incoming]) {
-		if (!raw) continue;
-		for (const part of raw.split(",")) {
-			const f = part.trim();
-			if (f.length === 0 || seen.has(f)) continue;
-			seen.add(f);
-			out.push(f);
-		}
-	}
-	return out.join(",");
-}
-/**
-* Append the context-1m feature to an anthropic-beta header value, deduping
-* any prior occurrence. Returns the merged comma-separated string.
-*/
-function appendContext1mBeta(existing) {
-	return mergeBetaFeatures(existing, CONTEXT_1M_BETA_FEATURE);
-}
-/**
-* True iff a model id appears to be the suffixed 1M-context variant of an
-* Anthropic Claude model (e.g. claude-opus-4-8-1m, claude-opus-4.6-1m).
-*
-* Used as a state.models-independent signal for whether to inject the
-* context-1m-2025-08-07 beta header, so the 1M intent survives a stale or
-* empty model cache (where `resolveAnthropicModelForDirectPath` would return
-* undefined). Forwarding the beta is harmless to upstreams that ignore it.
-*/
-function isOneMillionSuffixedClaudeId(modelId) {
-	return modelId.startsWith("claude-") && modelId.endsWith("-1m");
-}
-
-//#endregion
-//#region src/lib/headers.ts
-/**
-* Vendor-neutral header-bag helpers.
-*
-* HTTP header names are case-insensitive, but a plain-object header bag is
-* case-sensitive on its keys. Code that wants to look up "anthropic-beta"
-* without knowing whether some other producer wrote "Anthropic-Beta" needs
-* `findHeaderKey`. Code that wants to set a header without creating a
-* second case variant of the same name needs `setHeader`.
-*/
-/** Case-insensitive lookup of a header key in a plain-object header bag. */
-function findHeaderKey(headers, name) {
-	const lower = name.toLowerCase();
-	return Object.keys(headers).find((k) => k.toLowerCase() === lower);
-}
-/** Case-insensitive read of a header value. */
-function getHeader(headers, name) {
-	const key = findHeaderKey(headers, name);
-	return key === void 0 ? void 0 : headers[key];
-}
-/**
-* Set a header value at the existing case variant if one is present, else at
-* the supplied canonical name. Prevents a second key (different case) from
-* being added for the same logical header.
-*/
-function setHeader(headers, name, value) {
-	const key = findHeaderKey(headers, name) ?? name;
-	headers[key] = value;
-}
-
 //#endregion
 //#region src/services/copilot/create-chat-completions.ts
 const GPT_MODEL_PATTERN = /^gpt-/i;
@@ -3880,21 +3795,15 @@ const createChatCompletions = async (payload, options) => {
 	const enableVision = wire.messages.some((x) => typeof x.content !== "string" && x.content?.some((x) => x.type === "image_url"));
 	const isAgentCall = wire.messages.some((msg) => ["assistant", "tool"].includes(msg.role));
 	const modelSupportsVision = options?.resolvedModel?.capabilities?.supports?.vision !== false;
-	const headers = {
-		...copilotHeaders(state, {
-			vision: enableVision && modelSupportsVision,
-			modelRequestHeaders: options?.resolvedModel?.request_headers
-		}),
-		"X-Initiator": options?.initiator ?? (isAgentCall ? "agent" : "user")
-	};
-	if (options?.anthropicBeta) {
-		const existingKey = findHeaderKey(headers, "anthropic-beta") ?? "anthropic-beta";
-		headers[existingKey] = mergeBetaFeatures(headers[existingKey], options.anthropicBeta);
-		consola.debug(`[ChatCompletions] anthropic-beta after merge: ${headers[existingKey]}`);
-	}
 	const response = await copilotFetch("/chat/completions", {
 		method: "POST",
-		headers,
+		headers: {
+			...copilotHeaders(state, {
+				vision: enableVision && modelSupportsVision,
+				modelRequestHeaders: options?.resolvedModel?.request_headers
+			}),
+			"X-Initiator": options?.initiator ?? (isAgentCall ? "agent" : "user")
+		},
 		body: JSON.stringify(wire),
 		signal: options?.signal
 	});
@@ -4347,12 +4256,12 @@ async function executeRequest(opts) {
 			signal: abort.signal
 		}));
 		ctx.queueWaitMs = queueWaitMs;
-		if (isNonStreaming(response)) return handleNonStreamingResponse$1(c, response, ctx, payload);
+		if (isNonStreaming(response)) return handleNonStreamingResponse(c, response, ctx, payload);
 		consola.debug("Streaming response");
 		updateTrackerStatus(ctx.trackingId, "streaming");
 		return streamSSE(c, async (stream) => {
 			stream.onAbort(() => abort.abort());
-			await handleStreamingResponse$1({
+			await handleStreamingResponse({
 				stream,
 				response,
 				payload,
@@ -4381,7 +4290,7 @@ async function logTokenCount(payload, selectedModel) {
 		consola.debug("Failed to calculate token count:", error);
 	}
 }
-function handleNonStreamingResponse$1(c, originalResponse, ctx, payload) {
+function handleNonStreamingResponse(c, originalResponse, ctx, payload) {
 	consola.debug("Non-streaming response:", JSON.stringify(originalResponse));
 	let response = originalResponse;
 	if (state.verbose && ctx.truncateResult?.wasCompacted && response.choices[0]?.message.content) {
@@ -4474,7 +4383,7 @@ function createStreamAccumulator() {
 		toolCallMap: /* @__PURE__ */ new Map()
 	};
 }
-async function handleStreamingResponse$1(opts) {
+async function handleStreamingResponse(opts) {
 	const { stream, response, payload, ctx } = opts;
 	const acc = createStreamAccumulator();
 	const checkRepetition = createStreamRepetitionChecker(`openai:${payload.model}`);
@@ -6608,6 +6517,46 @@ async function checkNeedsCompactionAnthropic(payload, model, config = {}) {
 	};
 }
 
+//#endregion
+//#region src/lib/anthropic/beta.ts
+/**
+* Vendor-neutral utilities for manipulating the `anthropic-beta` request header.
+*
+* Lives in `lib/anthropic/` (not in either transport module) so both the
+* Anthropic-native and OpenAI-translated transport layers can share these
+* helpers without introducing cross-transport imports.
+*/
+/** Anthropic beta feature that unlocks the 1M context window. */
+const CONTEXT_1M_BETA_FEATURE = "context-1m-2025-08-07";
+/**
+* Merge two comma-separated anthropic-beta header values. Trims whitespace,
+* drops empty tokens, and dedupes by exact string match. Returns a canonical
+* comma-joined string with no spaces.
+*
+* Either input may be undefined / empty.
+*/
+function mergeBetaFeatures(existing, incoming) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const raw of [existing, incoming]) {
+		if (!raw) continue;
+		for (const part of raw.split(",")) {
+			const f = part.trim();
+			if (f.length === 0 || seen.has(f)) continue;
+			seen.add(f);
+			out.push(f);
+		}
+	}
+	return out.join(",");
+}
+/**
+* Append the context-1m feature to an anthropic-beta header value, deduping
+* any prior occurrence. Returns the merged comma-separated string.
+*/
+function appendContext1mBeta(existing) {
+	return mergeBetaFeatures(existing, CONTEXT_1M_BETA_FEATURE);
+}
+
 //#endregion
 //#region src/lib/anthropic/features.ts
 function normalizeForMatching(modelId) {
@@ -6758,6 +6707,37 @@ function filterServerToolBlocksFromResponse(response) {
 	};
 }
 
+//#endregion
+//#region src/lib/headers.ts
+/**
+* Vendor-neutral header-bag helpers.
+*
+* HTTP header names are case-insensitive, but a plain-object header bag is
+* case-sensitive on its keys. Code that wants to look up "anthropic-beta"
+* without knowing whether some other producer wrote "Anthropic-Beta" needs
+* `findHeaderKey`. Code that wants to set a header without creating a
+* second case variant of the same name needs `setHeader`.
+*/
+/** Case-insensitive lookup of a header key in a plain-object header bag. */
+function findHeaderKey(headers, name) {
+	const lower = name.toLowerCase();
+	return Object.keys(headers).find((k) => k.toLowerCase() === lower);
+}
+/** Case-insensitive read of a header value. */
+function getHeader(headers, name) {
+	const key = findHeaderKey(headers, name);
+	return key === void 0 ? void 0 : headers[key];
+}
+/**
+* Set a header value at the existing case variant if one is present, else at
+* the supplied canonical name. Prevents a second key (different case) from
+* being added for the same logical header.
+*/
+function setHeader(headers, name, value) {
+	const key = findHeaderKey(headers, name) ?? name;
+	headers[key] = value;
+}
+
 //#endregion
 //#region src/services/copilot/create-anthropic-messages.ts
 /**
@@ -6960,11 +6940,12 @@ function resolveAnthropicModelForDirectPath(modelId) {
 	}
 }
 /**
-* Check if a model supports direct Anthropic API.
-* Returns true if redirect is disabled (direct API is on) and the model is from Anthropic vendor.
+* Check if a model supports the native direct Anthropic API on Copilot.
+* True iff the model resolves to an Anthropic-vendor model (see
+* resolveAnthropicModelForDirectPath). `/v1/messages` serves these only;
+* the OpenAI-translation fallback was removed (docs/adr/0004-...).
 */
 function supportsDirectAnthropicApi(modelId) {
-	if (state.redirectAnthropic) return false;
 	return resolveAnthropicModelForDirectPath(modelId) !== void 0;
 }
 
@@ -7161,15 +7142,6 @@ function extractToolCallsFromContent(content) {
 	});
 	return tools.length > 0 ? tools : void 0;
 }
-function mapOpenAIStopReasonToAnthropic(finishReason) {
-	if (finishReason === null) return null;
-	return {
-		stop: "end_turn",
-		length: "max_tokens",
-		tool_calls: "tool_use",
-		content_filter: "end_turn"
-	}[finishReason];
-}
 function prependMarkerToResponse(response, marker) {
 	if (!marker) return response;
 	const content = [...response.content];
@@ -7290,555 +7262,79 @@ function recordAnthropicStreamingResponse(acc, fallbackModel, ctx) {
 }
 
 //#endregion
-//#region src/routes/messages/non-stream-translation.ts
-const OPENAI_TOOL_NAME_LIMIT = 64;
+//#region src/routes/messages/stream-translation.ts
 /**
-* Ensure all tool_use blocks have corresponding tool_result responses.
-* This handles edge cases where conversation history may be incomplete:
-* - Session interruptions where tool execution was cut off
-* - Previous request failures
-* - Client sending truncated history
+* Wrap an arbitrary error into an Anthropic-native `error` stream event.
 *
-* Adding placeholder responses prevents API errors and maintains protocol compliance.
+* Shared by the direct Anthropic path (`direct-anthropic-handler.ts`) to emit a
+* client-facing error frame mid-stream. The OpenAI→Anthropic response
+* translation that once also lived here was removed with the translation
+* fallback (see docs/adr/0004-drop-openai-translation-fallback-for-messages.md).
 */
-function fixMessageSequence(messages) {
-	const fixedMessages = [];
-	for (let i = 0; i < messages.length; i++) {
-		const message = messages[i];
-		fixedMessages.push(message);
-		if (message.role === "assistant" && message.tool_calls && message.tool_calls.length > 0) {
-			const foundToolResponses = /* @__PURE__ */ new Set();
-			let j = i + 1;
-			while (j < messages.length && messages[j].role === "tool") {
-				const toolMessage = messages[j];
-				if (toolMessage.tool_call_id) foundToolResponses.add(toolMessage.tool_call_id);
-				j++;
-			}
-			for (const toolCall of message.tool_calls) if (!foundToolResponses.has(toolCall.id)) {
-				consola.debug(`Adding placeholder tool_result for ${toolCall.id}`);
-				fixedMessages.push({
-					role: "tool",
-					tool_call_id: toolCall.id,
-					content: "Tool execution was interrupted or failed."
-				});
-			}
+function translateErrorToAnthropicErrorEvent(error) {
+	return {
+		type: "error",
+		error: {
+			type: "api_error",
+			message: error ? formatError(error) : "An unexpected error occurred during streaming."
 		}
+	};
+}
+
+//#endregion
+//#region src/routes/messages/tool-call-recovery.ts
+const ENVELOPE = String.raw`(?:<(?:antml:)?function_calls>|call|count|court)`;
+const INVOKE_BODY = String.raw`<(?:antml:)?invoke\s+name="[^"]+">(?:(?!<(?:antml:)?invoke\b)[\s\S])*?</(?:antml:)?invoke>`;
+const LEAKED_REGION_RE = new RegExp(String.raw`(?:^|\n)[ \t]*(?:` + ENVELOPE + String.raw`[ \t\n]*(?:` + INVOKE_BODY + String.raw`\s*)+(?:</(?:antml:)?function_calls>)?|` + INVOKE_BODY + String.raw`)`, "g");
+const STARTS_WITH_ENVELOPE_RE = new RegExp(String.raw`^[ \t\n]*` + ENVELOPE);
+const INVOKE_OPENER_RE = new RegExp(String.raw`(?:^|\n)[ \t]*(?:` + ENVELOPE + String.raw`[ \t\n]*)?<(?:antml:)?invoke\b[^\n>]*>?`, "g");
+const LEAK_OPEN_RE = new RegExp(String.raw`(?:^|\n)[ \t]*(?:` + ENVELOPE + String.raw`[ \t\n]*)?<(?:antml:)?invoke\s+name="`, "g");
+const INVOKE_RE = /<(?:antml:)?invoke\s+name="([^"]+)">([\s\S]*?)<\/(?:antml:)?invoke>/g;
+const PARAMETER_RE = /<(?:antml:)?parameter\s+name="([^"]+)">([\s\S]*?)<\/(?:antml:)?parameter>/g;
+function coerceParamValue(raw) {
+	const trimmed = raw.trim();
+	if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) try {
+		return JSON.parse(trimmed);
+	} catch {
+		return raw;
 	}
-	return fixedMessages;
+	return raw;
 }
-function translateToOpenAI(payload) {
-	const toolNameMapping = {
-		truncatedToOriginal: /* @__PURE__ */ new Map(),
-		originalToTruncated: /* @__PURE__ */ new Map()
-	};
-	const messages = translateAnthropicMessagesToOpenAI(payload.messages, payload.system, toolNameMapping);
-	return {
-		payload: {
-			model: translateModelName(payload.model),
-			messages: fixMessageSequence(messages),
-			max_tokens: payload.max_tokens,
-			stop: payload.stop_sequences,
-			stream: payload.stream,
-			temperature: payload.temperature,
-			top_p: payload.top_p,
-			user: payload.metadata?.user_id,
-			tools: translateAnthropicToolsToOpenAI(payload.tools, toolNameMapping),
-			tool_choice: translateAnthropicToolChoiceToOpenAI(payload.tool_choice, toolNameMapping)
-		},
-		toolNameMapping
-	};
+function parseRegionInvokes(region, knownTools) {
+	const calls = [];
+	for (const invokeMatch of region.matchAll(INVOKE_RE)) {
+		const name = invokeMatch[1];
+		if (knownTools && !knownTools.has(name)) continue;
+		const input = {};
+		for (const paramMatch of invokeMatch[2].matchAll(PARAMETER_RE)) input[paramMatch[1]] = coerceParamValue(paramMatch[2]);
+		calls.push({
+			name,
+			input
+		});
+	}
+	return calls;
+}
+const FENCE_DELIM_RE = /(?:^|\n)[ \t]*```/g;
+function insideFence(text, pos) {
+	let openAt = -1;
+	for (const m of text.matchAll(FENCE_DELIM_RE)) if (openAt === -1) {
+		if (m.index >= pos) break;
+		openAt = m.index;
+	} else if (m.index > pos) return true;
+	else openAt = -1;
+	return false;
+}
+function regionIsLeak(region, offset, fullText, knownTools) {
+	if (insideFence(fullText, offset)) return false;
+	if (STARTS_WITH_ENVELOPE_RE.test(region)) return true;
+	if (!knownTools) return false;
+	return parseRegionInvokes(region, knownTools).length > 0;
 }
 /**
-* Find the latest available model matching a family prefix.
-* Searches state.models for models starting with the given prefix
-* and returns the one with the highest version number.
-*
-* @param familyPrefix - e.g., "claude-opus", "claude-sonnet", "claude-haiku"
-* @param fallback - fallback model ID if no match found
-*/
-function findLatestModel(familyPrefix, fallback) {
-	const models = state.models?.data;
-	if (!models || models.length === 0) return fallback;
-	const candidates = models.filter((m) => m.id.startsWith(familyPrefix));
-	if (candidates.length === 0) return fallback;
-	candidates.sort((a, b) => {
-		const [aMajor, aMinor] = extractVersion(a.id, familyPrefix);
-		const [bMajor, bMinor] = extractVersion(b.id, familyPrefix);
-		if (aMajor !== bMajor) return bMajor - aMajor;
-		return bMinor - aMinor;
-	});
-	return candidates[0].id;
-}
-/**
-* Extract numeric [major, minor] version from a model id.
-*
-* Supports both naming conventions Anthropic/Copilot have used:
-*  - dot:  "claude-opus-4.5"  → [4, 5]
-*  - dash: "claude-opus-4-8"  → [4, 8]
-*  - dash double-digit: "claude-opus-4-10" → [4, 10]
-*
-* The dash form previously parsed as just the major via the regex
-* /^(\d+(?:\.\d+)?)/ (the dash stopped the match), which silently
-* downgraded dash-named candidates against any dot-named candidate in
-* findLatestModel. Parsing into a tuple also avoids the parseFloat
-* lossiness on double-digit minors ("4.10" → 4.1).
-*
-* Anything after the major/minor segment (date stamps, "-1m") is ignored.
-* The minor capture is bounded to 1-3 digits so that an 8-digit date suffix
-* directly after the major (e.g. "claude-opus-4-20250514") is NOT mistaken
-* for a minor version of 20_250_514 — without that bound, dated ids would
-* outrank legitimate dotted candidates like "claude-opus-4.8" in
-* findLatestModel's sort.
-*
-* Returns [0, 0] when no version can be extracted.
-*/
-function extractVersion(modelId, prefix) {
-	const match = modelId.slice(prefix.length + 1).match(/^(\d+)(?:[.-](\d{1,3}))?/);
-	if (!match) return [0, 0];
-	const major = Number.parseInt(match[1], 10);
-	const rawMinor = match[2];
-	return [major, rawMinor === void 0 ? 0 : Number.parseInt(rawMinor, 10) || 0];
-}
-function translateModelName(model) {
-	const aliasMap = {
-		opus: "claude-opus",
-		sonnet: "claude-sonnet",
-		haiku: "claude-haiku"
-	};
-	if (aliasMap[model]) {
-		const familyPrefix = aliasMap[model];
-		return findLatestModel(familyPrefix, `${familyPrefix}-4.5`);
-	}
-	if (/^claude-sonnet-4-5-\d+$/.test(model)) return "claude-sonnet-4.5";
-	if (/^claude-sonnet-4-\d+$/.test(model)) return "claude-sonnet-4";
-	if (model === "claude-opus-4-8-1m") return "claude-opus-4.8";
-	if (model === "claude-opus-4-8") return "claude-opus-4.8";
-	if (model === "claude-opus-4-7-1m") return "claude-opus-4.7";
-	if (/^claude-opus-4-7$/.test(model)) return "claude-opus-4.7";
-	if (model === "claude-opus-4-6-1m") return "claude-opus-4.6-1m";
-	if (/^claude-opus-4-6$/.test(model)) return "claude-opus-4.6";
-	if (/^claude-opus-4-5-\d+$/.test(model)) return "claude-opus-4.5";
-	if (/^claude-opus-4-\d+$/.test(model)) return findLatestModel("claude-opus", "claude-opus-4.5");
-	if (/^claude-haiku-4-5-\d+$/.test(model)) return "claude-haiku-4.5";
-	if (/^claude-haiku-3-5-\d+$/.test(model)) return findLatestModel("claude-haiku", "claude-haiku-4.5");
-	return model;
-}
-function translateAnthropicMessagesToOpenAI(anthropicMessages, system, toolNameMapping) {
-	const systemMessages = handleSystemPrompt(system);
-	const otherMessages = anthropicMessages.flatMap((message) => message.role === "user" ? handleUserMessage(message) : handleAssistantMessage(message, toolNameMapping));
-	return [...systemMessages, ...otherMessages];
-}
-const RESERVED_KEYWORDS = ["x-anthropic-billing-header", "x-anthropic-billing"];
-/**
-* Filter out reserved keywords from system prompt text.
-* Copilot API rejects requests containing these keywords.
-* Removes the entire line containing the keyword to keep the prompt clean.
-*/
-function filterReservedKeywords(text) {
-	let filtered = text;
-	for (const keyword of RESERVED_KEYWORDS) if (text.includes(keyword)) {
-		consola.debug(`[Reserved Keyword] Removing line containing "${keyword}"`);
-		filtered = filtered.split("\n").filter((line) => !line.includes(keyword)).join("\n");
-	}
-	return filtered;
-}
-function handleSystemPrompt(system) {
-	if (!system) return [];
-	if (typeof system === "string") return [{
-		role: "system",
-		content: filterReservedKeywords(system)
-	}];
-	else return [{
-		role: "system",
-		content: filterReservedKeywords(system.map((block) => block.text).join("\n\n"))
-	}];
-}
-function handleUserMessage(message) {
-	const newMessages = [];
-	if (Array.isArray(message.content)) {
-		const toolResultBlocks = message.content.filter((block) => block.type === "tool_result");
-		const otherBlocks = message.content.filter((block) => block.type !== "tool_result");
-		for (const block of toolResultBlocks) newMessages.push({
-			role: "tool",
-			tool_call_id: block.tool_use_id,
-			content: mapContent(block.content)
-		});
-		if (otherBlocks.length > 0) newMessages.push({
-			role: "user",
-			content: mapContent(otherBlocks)
-		});
-	} else newMessages.push({
-		role: "user",
-		content: mapContent(message.content)
-	});
-	return newMessages;
-}
-function handleAssistantMessage(message, toolNameMapping) {
-	if (!Array.isArray(message.content)) return [{
-		role: "assistant",
-		content: mapContent(message.content)
-	}];
-	const toolUseBlocks = message.content.filter((block) => block.type === "tool_use");
-	const textBlocks = message.content.filter((block) => block.type === "text");
-	const thinkingBlocks = message.content.filter((block) => block.type === "thinking");
-	const allTextContent = [...textBlocks.map((b) => b.text), ...thinkingBlocks.map((b) => b.thinking)].join("\n\n");
-	return toolUseBlocks.length > 0 ? [{
-		role: "assistant",
-		content: allTextContent || null,
-		tool_calls: toolUseBlocks.map((toolUse) => ({
-			id: toolUse.id,
-			type: "function",
-			function: {
-				name: getTruncatedToolName(toolUse.name, toolNameMapping),
-				arguments: JSON.stringify(toolUse.input)
-			}
-		}))
-	}] : [{
-		role: "assistant",
-		content: mapContent(message.content)
-	}];
-}
-function mapContent(content) {
-	if (typeof content === "string") return content;
-	if (!Array.isArray(content)) return null;
-	if (!content.some((block) => block.type === "image")) return content.filter((block) => block.type === "text" || block.type === "thinking").map((block) => block.type === "text" ? block.text : block.thinking).join("\n\n");
-	const contentParts = [];
-	for (const block of content) switch (block.type) {
-		case "text":
-			contentParts.push({
-				type: "text",
-				text: block.text
-			});
-			break;
-		case "thinking":
-			contentParts.push({
-				type: "text",
-				text: block.thinking
-			});
-			break;
-		case "image":
-			contentParts.push({
-				type: "image_url",
-				image_url: { url: `data:${block.source.media_type};base64,${block.source.data}` }
-			});
-			break;
-	}
-	return contentParts;
-}
-function getTruncatedToolName(originalName, toolNameMapping) {
-	if (originalName.length <= OPENAI_TOOL_NAME_LIMIT) return originalName;
-	const existingTruncated = toolNameMapping.originalToTruncated.get(originalName);
-	if (existingTruncated) return existingTruncated;
-	let hash = 0;
-	for (let i = 0; i < originalName.length; i++) {
-		const char = originalName.codePointAt(i) ?? 0;
-		hash = (hash << 5) - hash + char;
-		hash = Math.trunc(hash);
-	}
-	const hashSuffix = Math.abs(hash).toString(36).slice(0, 8);
-	const truncatedName = originalName.slice(0, OPENAI_TOOL_NAME_LIMIT - 9) + "_" + hashSuffix;
-	toolNameMapping.truncatedToOriginal.set(truncatedName, originalName);
-	toolNameMapping.originalToTruncated.set(originalName, truncatedName);
-	consola.debug(`Truncated tool name: "${originalName}" -> "${truncatedName}"`);
-	return truncatedName;
-}
-function translateAnthropicToolsToOpenAI(anthropicTools, toolNameMapping) {
-	if (!anthropicTools) return;
-	return anthropicTools.map((tool) => ({
-		type: "function",
-		function: {
-			name: getTruncatedToolName(tool.name, toolNameMapping),
-			description: tool.description,
-			parameters: tool.input_schema ?? {}
-		}
-	}));
-}
-function translateAnthropicToolChoiceToOpenAI(anthropicToolChoice, toolNameMapping) {
-	if (!anthropicToolChoice) return;
-	switch (anthropicToolChoice.type) {
-		case "auto": return "auto";
-		case "any": return "required";
-		case "tool":
-			if (anthropicToolChoice.name) return {
-				type: "function",
-				function: { name: getTruncatedToolName(anthropicToolChoice.name, toolNameMapping) }
-			};
-			return;
-		case "none": return "none";
-		default: return;
-	}
-}
-/** Create empty response for edge case of no choices */
-function createEmptyResponse(response) {
-	return {
-		id: response.id,
-		type: "message",
-		role: "assistant",
-		model: response.model,
-		content: [],
-		stop_reason: "end_turn",
-		stop_sequence: null,
-		usage: {
-			input_tokens: response.usage?.prompt_tokens ?? 0,
-			output_tokens: response.usage?.completion_tokens ?? 0
-		}
-	};
-}
-/** Build usage object from response */
-function buildUsageObject(response) {
-	const cachedTokens = response.usage?.prompt_tokens_details?.cached_tokens;
-	return {
-		input_tokens: (response.usage?.prompt_tokens ?? 0) - (cachedTokens ?? 0),
-		output_tokens: response.usage?.completion_tokens ?? 0,
-		...cachedTokens !== void 0 && { cache_read_input_tokens: cachedTokens }
-	};
-}
-function translateToAnthropic(response, toolNameMapping) {
-	if (response.choices.length === 0) return createEmptyResponse(response);
-	const allTextBlocks = [];
-	const allToolUseBlocks = [];
-	let stopReason = null;
-	stopReason = response.choices[0]?.finish_reason ?? stopReason;
-	for (const choice of response.choices) {
-		const textBlocks = getAnthropicTextBlocks(choice.message.content);
-		const toolUseBlocks = getAnthropicToolUseBlocks(choice.message.tool_calls, toolNameMapping);
-		allTextBlocks.push(...textBlocks);
-		allToolUseBlocks.push(...toolUseBlocks);
-		if (choice.finish_reason === "tool_calls" || stopReason === "stop") stopReason = choice.finish_reason;
-	}
-	return {
-		id: response.id,
-		type: "message",
-		role: "assistant",
-		model: response.model,
-		content: [...allTextBlocks, ...allToolUseBlocks],
-		stop_reason: mapOpenAIStopReasonToAnthropic(stopReason),
-		stop_sequence: null,
-		usage: buildUsageObject(response)
-	};
-}
-function getAnthropicTextBlocks(messageContent) {
-	if (typeof messageContent === "string") return [{
-		type: "text",
-		text: messageContent
-	}];
-	if (Array.isArray(messageContent)) return messageContent.filter((part) => part.type === "text").map((part) => ({
-		type: "text",
-		text: part.text
-	}));
-	return [];
-}
-function getAnthropicToolUseBlocks(toolCalls, toolNameMapping) {
-	if (!toolCalls) return [];
-	return toolCalls.map((toolCall) => {
-		let input = {};
-		try {
-			input = JSON.parse(toolCall.function.arguments);
-		} catch (error) {
-			consola.warn(`Failed to parse tool call arguments for ${toolCall.function.name}:`, error);
-		}
-		const originalName = toolNameMapping?.truncatedToOriginal.get(toolCall.function.name) ?? toolCall.function.name;
-		return {
-			type: "tool_use",
-			id: toolCall.id,
-			name: originalName,
-			input
-		};
-	});
-}
-
-//#endregion
-//#region src/routes/messages/stream-translation.ts
-function isToolBlockOpen(state) {
-	if (!state.contentBlockOpen) return false;
-	return Object.values(state.toolCalls).some((tc) => tc.anthropicBlockIndex === state.contentBlockIndex);
-}
-function translateChunkToAnthropicEvents(chunk, state, toolNameMapping) {
-	const events = [];
-	if (chunk.choices.length === 0) {
-		if (chunk.model && !state.model) state.model = chunk.model;
-		return events;
-	}
-	const choice = chunk.choices[0];
-	const { delta } = choice;
-	if (!state.messageStartSent) {
-		const model = chunk.model || state.model || "unknown";
-		events.push({
-			type: "message_start",
-			message: {
-				id: chunk.id || `msg_${Date.now()}`,
-				type: "message",
-				role: "assistant",
-				content: [],
-				model,
-				stop_reason: null,
-				stop_sequence: null,
-				usage: {
-					input_tokens: (chunk.usage?.prompt_tokens ?? 0) - (chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0),
-					output_tokens: 0,
-					...chunk.usage?.prompt_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: chunk.usage.prompt_tokens_details.cached_tokens }
-				}
-			}
-		});
-		state.messageStartSent = true;
-	}
-	if (delta.content) {
-		if (isToolBlockOpen(state)) {
-			events.push({
-				type: "content_block_stop",
-				index: state.contentBlockIndex
-			});
-			state.contentBlockIndex++;
-			state.contentBlockOpen = false;
-		}
-		if (!state.contentBlockOpen) {
-			events.push({
-				type: "content_block_start",
-				index: state.contentBlockIndex,
-				content_block: {
-					type: "text",
-					text: ""
-				}
-			});
-			state.contentBlockOpen = true;
-		}
-		events.push({
-			type: "content_block_delta",
-			index: state.contentBlockIndex,
-			delta: {
-				type: "text_delta",
-				text: delta.content
-			}
-		});
-	}
-	if (delta.tool_calls) for (const toolCall of delta.tool_calls) {
-		if (toolCall.id && toolCall.function?.name) {
-			if (state.contentBlockOpen) {
-				events.push({
-					type: "content_block_stop",
-					index: state.contentBlockIndex
-				});
-				state.contentBlockIndex++;
-				state.contentBlockOpen = false;
-			}
-			const originalName = toolNameMapping?.truncatedToOriginal.get(toolCall.function.name) ?? toolCall.function.name;
-			const anthropicBlockIndex = state.contentBlockIndex;
-			state.toolCalls[toolCall.index] = {
-				id: toolCall.id,
-				name: originalName,
-				anthropicBlockIndex
-			};
-			events.push({
-				type: "content_block_start",
-				index: anthropicBlockIndex,
-				content_block: {
-					type: "tool_use",
-					id: toolCall.id,
-					name: originalName,
-					input: {}
-				}
-			});
-			state.contentBlockOpen = true;
-		}
-		if (toolCall.function?.arguments) {
-			const toolCallInfo = state.toolCalls[toolCall.index];
-			if (toolCallInfo) events.push({
-				type: "content_block_delta",
-				index: toolCallInfo.anthropicBlockIndex,
-				delta: {
-					type: "input_json_delta",
-					partial_json: toolCall.function.arguments
-				}
-			});
-		}
-	}
-	if (choice.finish_reason) {
-		if (state.contentBlockOpen) {
-			events.push({
-				type: "content_block_stop",
-				index: state.contentBlockIndex
-			});
-			state.contentBlockOpen = false;
-		}
-		events.push({
-			type: "message_delta",
-			delta: {
-				stop_reason: mapOpenAIStopReasonToAnthropic(choice.finish_reason),
-				stop_sequence: null
-			},
-			usage: {
-				input_tokens: (chunk.usage?.prompt_tokens ?? 0) - (chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0),
-				output_tokens: chunk.usage?.completion_tokens ?? 0,
-				...chunk.usage?.prompt_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: chunk.usage.prompt_tokens_details.cached_tokens }
-			}
-		}, { type: "message_stop" });
-	}
-	return events;
-}
-function translateErrorToAnthropicErrorEvent(error) {
-	return {
-		type: "error",
-		error: {
-			type: "api_error",
-			message: error ? formatError(error) : "An unexpected error occurred during streaming."
-		}
-	};
-}
-
-//#endregion
-//#region src/routes/messages/tool-call-recovery.ts
-const ENVELOPE = String.raw`(?:<(?:antml:)?function_calls>|call|count|court)`;
-const INVOKE_BODY = String.raw`<(?:antml:)?invoke\s+name="[^"]+">(?:(?!<(?:antml:)?invoke\b)[\s\S])*?</(?:antml:)?invoke>`;
-const LEAKED_REGION_RE = new RegExp(String.raw`(?:^|\n)[ \t]*(?:` + ENVELOPE + String.raw`[ \t\n]*(?:` + INVOKE_BODY + String.raw`\s*)+(?:</(?:antml:)?function_calls>)?|` + INVOKE_BODY + String.raw`)`, "g");
-const STARTS_WITH_ENVELOPE_RE = new RegExp(String.raw`^[ \t\n]*` + ENVELOPE);
-const INVOKE_OPENER_RE = new RegExp(String.raw`(?:^|\n)[ \t]*(?:` + ENVELOPE + String.raw`[ \t\n]*)?<(?:antml:)?invoke\b[^\n>]*>?`, "g");
-const LEAK_OPEN_RE = new RegExp(String.raw`(?:^|\n)[ \t]*(?:` + ENVELOPE + String.raw`[ \t\n]*)?<(?:antml:)?invoke\s+name="`, "g");
-const INVOKE_RE = /<(?:antml:)?invoke\s+name="([^"]+)">([\s\S]*?)<\/(?:antml:)?invoke>/g;
-const PARAMETER_RE = /<(?:antml:)?parameter\s+name="([^"]+)">([\s\S]*?)<\/(?:antml:)?parameter>/g;
-function coerceParamValue(raw) {
-	const trimmed = raw.trim();
-	if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) try {
-		return JSON.parse(trimmed);
-	} catch {
-		return raw;
-	}
-	return raw;
-}
-function parseRegionInvokes(region, knownTools) {
-	const calls = [];
-	for (const invokeMatch of region.matchAll(INVOKE_RE)) {
-		const name = invokeMatch[1];
-		if (knownTools && !knownTools.has(name)) continue;
-		const input = {};
-		for (const paramMatch of invokeMatch[2].matchAll(PARAMETER_RE)) input[paramMatch[1]] = coerceParamValue(paramMatch[2]);
-		calls.push({
-			name,
-			input
-		});
-	}
-	return calls;
-}
-const FENCE_DELIM_RE = /(?:^|\n)[ \t]*```/g;
-function insideFence(text, pos) {
-	let openAt = -1;
-	for (const m of text.matchAll(FENCE_DELIM_RE)) if (openAt === -1) {
-		if (m.index >= pos) break;
-		openAt = m.index;
-	} else if (m.index > pos) return true;
-	else openAt = -1;
-	return false;
-}
-function regionIsLeak(region, offset, fullText, knownTools) {
-	if (insideFence(fullText, offset)) return false;
-	if (STARTS_WITH_ENVELOPE_RE.test(region)) return true;
-	if (!knownTools) return false;
-	return parseRegionInvokes(region, knownTools).length > 0;
-}
-/**
-* Split assistant text into ordered segments — dropping leaked envelope markup
-* (and undeclared-tool invokes) while preserving the natural-language on either
-* side and the pre/tool/post ordering. Returns a single text segment when there
-* is no leak. Shared by both response recovery paths so they cannot diverge.
+* Split assistant text into ordered segments — dropping leaked envelope markup
+* (and undeclared-tool invokes) while preserving the natural-language on either
+* side and the pre/tool/post ordering. Returns a single text segment when there
+* is no leak. Shared by both response recovery paths so they cannot diverge.
 *
 * `from` restricts the EMITTED window to `text.slice(from)` while still
 * classifying against the FULL `text` — so a streaming capture that started just
@@ -8643,359 +8139,350 @@ const parseSubagentMarkerFromSystemReminder = (text) => {
 };
 
 //#endregion
-//#region src/routes/messages/translated-handler.ts
+//#region src/routes/messages/handler.ts
+function resolveModelFromBetaHeader(model, betaHeader) {
+	if (!betaHeader || !/\bcontext-1m\b/.test(betaHeader)) return model;
+	if (!model.startsWith("claude-")) return model;
+	if (model.endsWith("-1m")) return model;
+	const resolved = `${model}-1m`;
+	consola.debug(`Detected context-1m in anthropic-beta header, resolving model: ${model} → ${resolved}`);
+	return resolved;
+}
+async function handleCompletion(c) {
+	const rawPayload = await c.req.json();
+	consola.debug("Anthropic request payload:", JSON.stringify(rawPayload));
+	if (rawPayload === null || typeof rawPayload.model !== "string" || rawPayload.model.length === 0) return c.json({
+		type: "error",
+		error: {
+			type: "invalid_request_error",
+			message: "model is required and must be a non-empty string"
+		}
+	}, 400);
+	const normalizedModel = resolveModelFromBetaHeader(rawPayload.model, c.req.header("anthropic-beta"));
+	if (!supportsDirectAnthropicApi(normalizedModel)) return c.json({
+		type: "error",
+		error: {
+			type: "invalid_request_error",
+			message: `model \`${normalizedModel}\` is not an Anthropic model available on /v1/messages`
+		}
+	}, 400);
+	const { ctx, payload: anthropicPayload } = createEntryContext({
+		c,
+		rawPayload,
+		endpoint: "anthropic",
+		normalizePayload: (p) => ({
+			...p,
+			model: resolveModelFromBetaHeader(p.model, c.req.header("anthropic-beta"))
+		}),
+		buildHistoryRequest: (p) => ({
+			model: p.model,
+			messages: convertAnthropicMessages(p.messages),
+			stream: p.stream ?? false,
+			tools: p.tools?.map((t) => ({
+				name: t.name,
+				description: t.description
+			})),
+			max_tokens: p.max_tokens,
+			temperature: p.temperature,
+			system: extractSystemPrompt(p.system)
+		})
+	});
+	const sanitizedPayload = dePoisonAssistantMessages(anthropicPayload);
+	logToolInfo(sanitizedPayload);
+	const subagentMarker = parseSubagentMarkerFromFirstUser(sanitizedPayload);
+	const initiatorOverride = subagentMarker ? "agent" : void 0;
+	if (subagentMarker) consola.debug("Detected Subagent marker:", JSON.stringify(subagentMarker));
+	normalizeSystemPromptDate(sanitizedPayload);
+	injectSystemCacheControl(sanitizedPayload);
+	return handleDirectAnthropicCompletion(c, sanitizedPayload, ctx, initiatorOverride);
+}
 /**
-* Handle completion using OpenAI translation path (legacy)
+* Log tool-related information for debugging
 */
-async function handleTranslatedCompletion(c, anthropicPayload, ctx, initiatorOverride) {
-	const originalModelId = anthropicPayload.model;
-	const hasOneMillionSuffix = isOneMillionSuffixedClaudeId(originalModelId);
-	const oneMResolution = resolveAnthropicModelForDirectPath(originalModelId);
-	const needsContext1mBeta = hasOneMillionSuffix || (oneMResolution?.oneMillionFallback ?? false);
-	const { payload: translatedPayload, toolNameMapping } = translateToOpenAI(anthropicPayload);
-	consola.debug("Translated OpenAI request payload:", JSON.stringify(translatedPayload));
-	updateTrackerResolvedModel(ctx.trackingId, translatedPayload.model);
-	const selectedModel = findModelById(translatedPayload.model);
-	const autoTruncateConfig = oneMResolution?.oneMillionFallback ? {
-		contextWindowOverride: oneMResolution.effectiveContextWindowTokens,
-		tokenLimitCacheKeyOverride: originalModelId
-	} : {};
-	const { finalPayload: openAIPayload, truncateResult } = await buildFinalPayload(translatedPayload, selectedModel, autoTruncateConfig);
-	if (truncateResult) ctx.truncateResult = truncateResult;
-	let anthropicBeta = c.req.header("anthropic-beta");
-	if (needsContext1mBeta) anthropicBeta = appendContext1mBeta(anthropicBeta);
-	if (state.manualApprove) await awaitApproval();
-	let errorModelIdOverride;
-	if (autoTruncateConfig.tokenLimitCacheKeyOverride !== void 0) errorModelIdOverride = autoTruncateConfig.tokenLimitCacheKeyOverride;
-	else if (needsContext1mBeta && selectedModel) errorModelIdOverride = selectedModel.id;
-	else if (hasOneMillionSuffix) errorModelIdOverride = originalModelId;
-	const abort = clientAbortController(c);
-	const isStreaming = anthropicPayload.stream === true;
-	try {
-		const settled = settle(executeWithAdaptiveRateLimit(() => createChatCompletions(openAIPayload, {
-			initiator: initiatorOverride,
-			resolvedModel: selectedModel,
-			anthropicBeta,
-			errorModelIdOverride,
-			signal: abort.signal
-		})));
-		const raced = isStreaming ? await raceWithGrace(settled, RATE_LIMIT_GRACE_MS) : await settled;
-		if (raced.kind === "error") throw raced.error;
-		if (raced.kind === "done") {
-			const { result: response, queueWaitMs } = raced.value;
-			ctx.queueWaitMs = queueWaitMs;
-			if (isNonStreaming(response)) return handleNonStreamingResponse({
-				c,
-				response,
-				toolNameMapping,
-				ctx,
-				anthropicPayload
-			});
-			consola.debug("Streaming response from Copilot");
-			updateTrackerStatus(ctx.trackingId, "streaming");
-			return streamSSE(c, async (stream) => {
-				stream.onAbort(() => abort.abort());
-				await handleStreamingResponse({
-					stream,
-					response,
-					toolNameMapping,
-					anthropicPayload,
-					ctx
+function logToolInfo(anthropicPayload) {
+	if (anthropicPayload.tools?.length) {
+		const toolInfo = anthropicPayload.tools.map((t) => ({
+			name: t.name,
+			type: t.type ?? "(custom)"
+		}));
+		consola.debug(`[Tools] Defined tools:`, JSON.stringify(toolInfo));
+	}
+	for (const msg of anthropicPayload.messages) if (typeof msg.content !== "string") for (const block of msg.content) {
+		if (block.type === "tool_use") consola.debug(`[Tools] tool_use in message: ${block.name} (id: ${block.id})`);
+		if (block.type === "tool_result") consola.debug(`[Tools] tool_result in message: id=${block.tool_use_id}, is_error=${block.is_error ?? false}`);
+	}
+}
+
+//#endregion
+//#region src/routes/messages/non-stream-translation.ts
+const OPENAI_TOOL_NAME_LIMIT = 64;
+/**
+* Ensure all tool_use blocks have corresponding tool_result responses.
+* This handles edge cases where conversation history may be incomplete:
+* - Session interruptions where tool execution was cut off
+* - Previous request failures
+* - Client sending truncated history
+*
+* Adding placeholder responses prevents API errors and maintains protocol compliance.
+*/
+function fixMessageSequence(messages) {
+	const fixedMessages = [];
+	for (let i = 0; i < messages.length; i++) {
+		const message = messages[i];
+		fixedMessages.push(message);
+		if (message.role === "assistant" && message.tool_calls && message.tool_calls.length > 0) {
+			const foundToolResponses = /* @__PURE__ */ new Set();
+			let j = i + 1;
+			while (j < messages.length && messages[j].role === "tool") {
+				const toolMessage = messages[j];
+				if (toolMessage.tool_call_id) foundToolResponses.add(toolMessage.tool_call_id);
+				j++;
+			}
+			for (const toolCall of message.tool_calls) if (!foundToolResponses.has(toolCall.id)) {
+				consola.debug(`Adding placeholder tool_result for ${toolCall.id}`);
+				fixedMessages.push({
+					role: "tool",
+					tool_call_id: toolCall.id,
+					content: "Tool execution was interrupted or failed."
 				});
-			});
-		}
-		consola.debug("[RateLimiter] Request queued past grace; opening keepalive stream (translated)");
-		updateTrackerStatus(ctx.trackingId, "streaming");
-		return streamSSE(c, async (stream) => {
-			stream.onAbort(() => abort.abort());
-			await runStreamWithKeepalive({
-				stream,
-				settled,
-				pingIntervalMs: KEEPALIVE_PING_INTERVAL_MS,
-				onResponse: async ({ result: response, queueWaitMs }) => {
-					ctx.queueWaitMs = queueWaitMs;
-					if (isNonStreaming(response)) return;
-					await handleStreamingResponse({
-						stream,
-						response,
-						toolNameMapping,
-						anthropicPayload,
-						ctx
-					});
-				},
-				onError: async (error) => {
-					if (isAbortError(error)) {
-						consola.debug("[Translated] client disconnected during keepalive; upstream aborted");
-						failTracking(ctx.trackingId, "client disconnected");
-						return;
-					}
-					recordStreamError({
-						acc: createAnthropicStreamAccumulator(),
-						fallbackModel: anthropicPayload.model,
-						ctx,
-						error,
-						endpoint: "messages"
-					});
-					failTracking(ctx.trackingId, error);
-					const errorEvent = translateErrorToAnthropicErrorEvent(error);
-					await stream.writeSSE({
-						event: errorEvent.type,
-						data: JSON.stringify(errorEvent)
-					});
-				}
-			});
-		});
-	} catch (error) {
-		if (isAbortError(error)) {
-			consola.debug("[Translated] client disconnected before response; upstream aborted");
-			failTracking(ctx.trackingId, "client disconnected");
-			return new Response(null, { status: 499 });
+			}
 		}
-		if (error instanceof HTTPError && error.status === 413) await logPayloadSizeInfo(openAIPayload, selectedModel);
-		recordErrorResponse(ctx, anthropicPayload.model, error, "messages", anthropicPayload.stream ?? false);
-		throw error;
 	}
+	return fixedMessages;
 }
-function handleNonStreamingResponse(opts) {
-	const { c, response, toolNameMapping, ctx, anthropicPayload } = opts;
-	consola.debug("Non-streaming response from Copilot:", JSON.stringify(response).slice(-400));
-	let anthropicResponse = translateToAnthropic(response, toolNameMapping);
-	consola.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
-	if (state.verbose && ctx.truncateResult?.wasCompacted) {
-		const marker = formatClientTruncationMarker(ctx.truncateResult);
-		anthropicResponse = prependMarkerToResponse(anthropicResponse, marker);
-	}
-	recordResponse(ctx.historyId, {
-		success: true,
-		model: anthropicResponse.model,
-		usage: anthropicResponse.usage,
-		stop_reason: anthropicResponse.stop_reason ?? void 0,
-		content: {
-			role: "assistant",
-			content: anthropicResponse.content.map((block) => {
-				if (block.type === "text") return {
-					type: "text",
-					text: block.text
-				};
-				if (block.type === "tool_use") return {
-					type: "tool_use",
-					id: block.id,
-					name: block.name,
-					input: JSON.stringify(block.input)
-				};
-				return { type: block.type };
-			})
-		},
-		toolCalls: extractToolCallsFromContent(anthropicResponse.content)
-	}, Date.now() - ctx.startTime);
-	const cacheRead = anthropicResponse.usage.cache_read_input_tokens ?? 0;
-	const cacheCreation = anthropicResponse.usage.cache_creation_input_tokens ?? 0;
-	const totalInputTokens = anthropicResponse.usage.input_tokens + cacheRead + cacheCreation;
-	if (ctx.trackingId) requestTracker.updateRequest(ctx.trackingId, {
-		inputTokens: anthropicResponse.usage.input_tokens,
-		outputTokens: anthropicResponse.usage.output_tokens,
-		queueWaitMs: ctx.queueWaitMs,
-		cachedInputTokens: cacheRead,
-		cacheCreationInputTokens: cacheCreation,
-		totalInputTokens
-	});
-	captureRequest({
-		model: anthropicResponse.model,
-		inputTokens: anthropicResponse.usage.input_tokens,
-		outputTokens: anthropicResponse.usage.output_tokens,
-		durationMs: Date.now() - ctx.startTime,
-		success: true,
-		stream: false,
-		toolCount: anthropicPayload.tools?.length ?? 0,
-		cachedInputTokens: cacheRead,
-		cacheCreationInputTokens: cacheCreation,
-		totalInputTokens,
-		stopReason: anthropicResponse.stop_reason ?? void 0
+function translateToOpenAI(payload) {
+	const toolNameMapping = { originalToTruncated: /* @__PURE__ */ new Map() };
+	const messages = translateAnthropicMessagesToOpenAI(payload.messages, payload.system, toolNameMapping);
+	return { payload: {
+		model: translateModelName(payload.model),
+		messages: fixMessageSequence(messages),
+		max_tokens: payload.max_tokens,
+		stop: payload.stop_sequences,
+		stream: payload.stream,
+		temperature: payload.temperature,
+		top_p: payload.top_p,
+		user: payload.metadata?.user_id,
+		tools: translateAnthropicToolsToOpenAI(payload.tools, toolNameMapping),
+		tool_choice: translateAnthropicToolChoiceToOpenAI(payload.tool_choice, toolNameMapping)
+	} };
+}
+/**
+* Find the latest available model matching a family prefix.
+* Searches state.models for models starting with the given prefix
+* and returns the one with the highest version number.
+*
+* @param familyPrefix - e.g., "claude-opus", "claude-sonnet", "claude-haiku"
+* @param fallback - fallback model ID if no match found
+*/
+function findLatestModel(familyPrefix, fallback) {
+	const models = state.models?.data;
+	if (!models || models.length === 0) return fallback;
+	const candidates = models.filter((m) => m.id.startsWith(familyPrefix));
+	if (candidates.length === 0) return fallback;
+	candidates.sort((a, b) => {
+		const [aMajor, aMinor] = extractVersion(a.id, familyPrefix);
+		const [bMajor, bMinor] = extractVersion(b.id, familyPrefix);
+		if (aMajor !== bMajor) return bMajor - aMajor;
+		return bMinor - aMinor;
 	});
-	return c.json(echoResponseBody(anthropicResponse, ctx));
+	return candidates[0].id;
 }
-async function handleStreamingResponse(opts) {
-	const { stream, response, toolNameMapping, anthropicPayload, ctx } = opts;
-	const streamState = {
-		messageStartSent: false,
-		contentBlockIndex: 0,
-		contentBlockOpen: false,
-		toolCalls: {}
-	};
-	const acc = createAnthropicStreamAccumulator();
-	const checkRepetition = createStreamRepetitionChecker(`translated:${anthropicPayload.model}`);
-	try {
-		if (ctx.truncateResult?.wasCompacted) {
-			const marker = formatClientTruncationMarker(ctx.truncateResult);
-			await sendTruncationMarkerEvent(stream, streamState, marker);
-			acc.content += marker;
-		}
-		await processStreamChunks({
-			stream,
-			response,
-			toolNameMapping,
-			streamState,
-			acc,
-			checkRepetition,
-			ctx
-		});
-		recordAnthropicStreamingResponse(acc, anthropicPayload.model, ctx);
-		completeTracking(ctx.trackingId, acc.inputTokens, acc.outputTokens, ctx.queueWaitMs, void 0, {
-			model: acc.model || anthropicPayload.model,
-			stream: true,
-			durationMs: Date.now() - ctx.startTime,
-			stopReason: acc.stopReason || void 0,
-			toolCount: anthropicPayload.tools?.length ?? 0
-		}, ctx.timings, {
-			cachedInputTokens: acc.cacheReadInputTokens,
-			cacheCreationInputTokens: acc.cacheCreationInputTokens,
-			totalInputTokens: acc.inputTokens + acc.cacheReadInputTokens + acc.cacheCreationInputTokens
-		});
-	} catch (error) {
-		if (isAbortError(error)) {
-			consola.debug("[Translated] client disconnected mid-stream; upstream aborted");
-			failTracking(ctx.trackingId, "client disconnected");
-			return;
-		}
-		consola.error("Stream error:", formatError(error));
-		recordStreamError({
-			acc,
-			fallbackModel: anthropicPayload.model,
-			ctx,
-			error,
-			endpoint: "messages"
-		});
-		failTracking(ctx.trackingId, error);
-		const errorEvent = translateErrorToAnthropicErrorEvent(error);
-		await stream.writeSSE({
-			event: errorEvent.type,
-			data: JSON.stringify(errorEvent)
-		});
-	}
+/**
+* Extract numeric [major, minor] version from a model id.
+*
+* Supports both naming conventions Anthropic/Copilot have used:
+*  - dot:  "claude-opus-4.5"  → [4, 5]
+*  - dash: "claude-opus-4-8"  → [4, 8]
+*  - dash double-digit: "claude-opus-4-10" → [4, 10]
+*
+* The dash form previously parsed as just the major via the regex
+* /^(\d+(?:\.\d+)?)/ (the dash stopped the match), which silently
+* downgraded dash-named candidates against any dot-named candidate in
+* findLatestModel. Parsing into a tuple also avoids the parseFloat
+* lossiness on double-digit minors ("4.10" → 4.1).
+*
+* Anything after the major/minor segment (date stamps, "-1m") is ignored.
+* The minor capture is bounded to 1-3 digits so that an 8-digit date suffix
+* directly after the major (e.g. "claude-opus-4-20250514") is NOT mistaken
+* for a minor version of 20_250_514 — without that bound, dated ids would
+* outrank legitimate dotted candidates like "claude-opus-4.8" in
+* findLatestModel's sort.
+*
+* Returns [0, 0] when no version can be extracted.
+*/
+function extractVersion(modelId, prefix) {
+	const match = modelId.slice(prefix.length + 1).match(/^(\d+)(?:[.-](\d{1,3}))?/);
+	if (!match) return [0, 0];
+	const major = Number.parseInt(match[1], 10);
+	const rawMinor = match[2];
+	return [major, rawMinor === void 0 ? 0 : Number.parseInt(rawMinor, 10) || 0];
 }
-async function sendTruncationMarkerEvent(stream, streamState, marker) {
-	const blockStartEvent = {
-		type: "content_block_start",
-		index: streamState.contentBlockIndex,
-		content_block: {
-			type: "text",
-			text: ""
-		}
-	};
-	await stream.writeSSE({
-		event: "content_block_start",
-		data: JSON.stringify(blockStartEvent)
-	});
-	const deltaEvent = {
-		type: "content_block_delta",
-		index: streamState.contentBlockIndex,
-		delta: {
-			type: "text_delta",
-			text: marker
-		}
-	};
-	await stream.writeSSE({
-		event: "content_block_delta",
-		data: JSON.stringify(deltaEvent)
-	});
-	const blockStopEvent = {
-		type: "content_block_stop",
-		index: streamState.contentBlockIndex
+function translateModelName(model) {
+	const aliasMap = {
+		opus: "claude-opus",
+		sonnet: "claude-sonnet",
+		haiku: "claude-haiku"
 	};
-	await stream.writeSSE({
-		event: "content_block_stop",
-		data: JSON.stringify(blockStopEvent)
-	});
-	streamState.contentBlockIndex++;
-}
-async function processStreamChunks(opts) {
-	const { stream, response, toolNameMapping, streamState, acc, checkRepetition, ctx } = opts;
-	for await (const rawEvent of response) {
-		consola.debug("Copilot raw stream event:", JSON.stringify(rawEvent));
-		if (rawEvent.data === "[DONE]") break;
-		if (!rawEvent.data) continue;
-		let chunk;
-		try {
-			chunk = JSON.parse(rawEvent.data);
-		} catch (parseError) {
-			consola.error("Failed to parse stream chunk:", parseError, rawEvent.data);
-			continue;
-		}
-		if (chunk.model && !acc.model) acc.model = chunk.model;
-		const events = translateChunkToAnthropicEvents(chunk, streamState, toolNameMapping);
-		for (const event of events) {
-			consola.debug("Translated Anthropic event:", JSON.stringify(event));
-			processAnthropicEvent(event, acc);
-			if (event.type === "content_block_delta" && event.delta.type === "text_delta") checkRepetition(event.delta.text);
-			const echoed = echoParsedEvent(event, ctx);
-			await stream.writeSSE({
-				event: echoed.type,
-				data: JSON.stringify(echoed)
-			});
-		}
+	if (aliasMap[model]) {
+		const familyPrefix = aliasMap[model];
+		return findLatestModel(familyPrefix, `${familyPrefix}-4.5`);
 	}
+	if (/^claude-sonnet-4-5-\d+$/.test(model)) return "claude-sonnet-4.5";
+	if (/^claude-sonnet-4-\d+$/.test(model)) return "claude-sonnet-4";
+	if (model === "claude-opus-4-8-1m") return "claude-opus-4.8";
+	if (model === "claude-opus-4-8") return "claude-opus-4.8";
+	if (model === "claude-opus-4-7-1m") return "claude-opus-4.7";
+	if (/^claude-opus-4-7$/.test(model)) return "claude-opus-4.7";
+	if (model === "claude-opus-4-6-1m") return "claude-opus-4.6-1m";
+	if (/^claude-opus-4-6$/.test(model)) return "claude-opus-4.6";
+	if (/^claude-opus-4-5-\d+$/.test(model)) return "claude-opus-4.5";
+	if (/^claude-opus-4-\d+$/.test(model)) return findLatestModel("claude-opus", "claude-opus-4.5");
+	if (/^claude-haiku-4-5-\d+$/.test(model)) return "claude-haiku-4.5";
+	if (/^claude-haiku-3-5-\d+$/.test(model)) return findLatestModel("claude-haiku", "claude-haiku-4.5");
+	return model;
 }
-
-//#endregion
-//#region src/routes/messages/handler.ts
-function resolveModelFromBetaHeader(model, betaHeader) {
-	if (!betaHeader || !/\bcontext-1m\b/.test(betaHeader)) return model;
-	if (!model.startsWith("claude-")) return model;
-	if (model.endsWith("-1m")) return model;
-	const resolved = `${model}-1m`;
-	consola.debug(`Detected context-1m in anthropic-beta header, resolving model: ${model} → ${resolved}`);
-	return resolved;
+function translateAnthropicMessagesToOpenAI(anthropicMessages, system, toolNameMapping) {
+	const systemMessages = handleSystemPrompt(system);
+	const otherMessages = anthropicMessages.flatMap((message) => message.role === "user" ? handleUserMessage(message) : handleAssistantMessage(message, toolNameMapping));
+	return [...systemMessages, ...otherMessages];
 }
-async function handleCompletion(c) {
-	const rawPayload = await c.req.json();
-	consola.debug("Anthropic request payload:", JSON.stringify(rawPayload));
-	const { ctx, payload: anthropicPayload } = createEntryContext({
-		c,
-		rawPayload,
-		endpoint: "anthropic",
-		normalizePayload: (p) => ({
-			...p,
-			model: resolveModelFromBetaHeader(p.model, c.req.header("anthropic-beta"))
-		}),
-		buildHistoryRequest: (p) => ({
-			model: p.model,
-			messages: convertAnthropicMessages(p.messages),
-			stream: p.stream ?? false,
-			tools: p.tools?.map((t) => ({
-				name: t.name,
-				description: t.description
-			})),
-			max_tokens: p.max_tokens,
-			temperature: p.temperature,
-			system: extractSystemPrompt(p.system)
-		})
+const RESERVED_KEYWORDS = ["x-anthropic-billing-header", "x-anthropic-billing"];
+/**
+* Filter out reserved keywords from system prompt text.
+* Copilot API rejects requests containing these keywords.
+* Removes the entire line containing the keyword to keep the prompt clean.
+*/
+function filterReservedKeywords(text) {
+	let filtered = text;
+	for (const keyword of RESERVED_KEYWORDS) if (text.includes(keyword)) {
+		consola.debug(`[Reserved Keyword] Removing line containing "${keyword}"`);
+		filtered = filtered.split("\n").filter((line) => !line.includes(keyword)).join("\n");
+	}
+	return filtered;
+}
+function handleSystemPrompt(system) {
+	if (!system) return [];
+	if (typeof system === "string") return [{
+		role: "system",
+		content: filterReservedKeywords(system)
+	}];
+	else return [{
+		role: "system",
+		content: filterReservedKeywords(system.map((block) => block.text).join("\n\n"))
+	}];
+}
+function handleUserMessage(message) {
+	const newMessages = [];
+	if (Array.isArray(message.content)) {
+		const toolResultBlocks = message.content.filter((block) => block.type === "tool_result");
+		const otherBlocks = message.content.filter((block) => block.type !== "tool_result");
+		for (const block of toolResultBlocks) newMessages.push({
+			role: "tool",
+			tool_call_id: block.tool_use_id,
+			content: mapContent(block.content)
+		});
+		if (otherBlocks.length > 0) newMessages.push({
+			role: "user",
+			content: mapContent(otherBlocks)
+		});
+	} else newMessages.push({
+		role: "user",
+		content: mapContent(message.content)
 	});
-	const sanitizedPayload = dePoisonAssistantMessages(anthropicPayload);
-	logToolInfo(sanitizedPayload);
-	const subagentMarker = parseSubagentMarkerFromFirstUser(sanitizedPayload);
-	const initiatorOverride = subagentMarker ? "agent" : void 0;
-	if (subagentMarker) consola.debug("Detected Subagent marker:", JSON.stringify(subagentMarker));
-	if (supportsDirectAnthropicApi(sanitizedPayload.model)) {
-		normalizeSystemPromptDate(sanitizedPayload);
-		injectSystemCacheControl(sanitizedPayload);
-		return handleDirectAnthropicCompletion(c, sanitizedPayload, ctx, initiatorOverride);
+	return newMessages;
+}
+function handleAssistantMessage(message, toolNameMapping) {
+	if (!Array.isArray(message.content)) return [{
+		role: "assistant",
+		content: mapContent(message.content)
+	}];
+	const toolUseBlocks = message.content.filter((block) => block.type === "tool_use");
+	const textBlocks = message.content.filter((block) => block.type === "text");
+	const thinkingBlocks = message.content.filter((block) => block.type === "thinking");
+	const allTextContent = [...textBlocks.map((b) => b.text), ...thinkingBlocks.map((b) => b.thinking)].join("\n\n");
+	return toolUseBlocks.length > 0 ? [{
+		role: "assistant",
+		content: allTextContent || null,
+		tool_calls: toolUseBlocks.map((toolUse) => ({
+			id: toolUse.id,
+			type: "function",
+			function: {
+				name: getTruncatedToolName(toolUse.name, toolNameMapping),
+				arguments: JSON.stringify(toolUse.input)
+			}
+		}))
+	}] : [{
+		role: "assistant",
+		content: mapContent(message.content)
+	}];
+}
+function mapContent(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return null;
+	if (!content.some((block) => block.type === "image")) return content.filter((block) => block.type === "text" || block.type === "thinking").map((block) => block.type === "text" ? block.text : block.thinking).join("\n\n");
+	const contentParts = [];
+	for (const block of content) switch (block.type) {
+		case "text":
+			contentParts.push({
+				type: "text",
+				text: block.text
+			});
+			break;
+		case "thinking":
+			contentParts.push({
+				type: "text",
+				text: block.thinking
+			});
+			break;
+		case "image":
+			contentParts.push({
+				type: "image_url",
+				image_url: { url: `data:${block.source.media_type};base64,${block.source.data}` }
+			});
+			break;
 	}
-	return handleTranslatedCompletion(c, sanitizedPayload, ctx, initiatorOverride);
+	return contentParts;
 }
-/**
-* Log tool-related information for debugging
-*/
-function logToolInfo(anthropicPayload) {
-	if (anthropicPayload.tools?.length) {
-		const toolInfo = anthropicPayload.tools.map((t) => ({
-			name: t.name,
-			type: t.type ?? "(custom)"
-		}));
-		consola.debug(`[Tools] Defined tools:`, JSON.stringify(toolInfo));
+function getTruncatedToolName(originalName, toolNameMapping) {
+	if (originalName.length <= OPENAI_TOOL_NAME_LIMIT) return originalName;
+	const existingTruncated = toolNameMapping.originalToTruncated.get(originalName);
+	if (existingTruncated) return existingTruncated;
+	let hash = 0;
+	for (let i = 0; i < originalName.length; i++) {
+		const char = originalName.codePointAt(i) ?? 0;
+		hash = (hash << 5) - hash + char;
+		hash = Math.trunc(hash);
 	}
-	for (const msg of anthropicPayload.messages) if (typeof msg.content !== "string") for (const block of msg.content) {
-		if (block.type === "tool_use") consola.debug(`[Tools] tool_use in message: ${block.name} (id: ${block.id})`);
-		if (block.type === "tool_result") consola.debug(`[Tools] tool_result in message: id=${block.tool_use_id}, is_error=${block.is_error ?? false}`);
+	const hashSuffix = Math.abs(hash).toString(36).slice(0, 8);
+	const truncatedName = originalName.slice(0, OPENAI_TOOL_NAME_LIMIT - 9) + "_" + hashSuffix;
+	toolNameMapping.originalToTruncated.set(originalName, truncatedName);
+	consola.debug(`Truncated tool name: "${originalName}" -> "${truncatedName}"`);
+	return truncatedName;
+}
+function translateAnthropicToolsToOpenAI(anthropicTools, toolNameMapping) {
+	if (!anthropicTools) return;
+	return anthropicTools.map((tool) => ({
+		type: "function",
+		function: {
+			name: getTruncatedToolName(tool.name, toolNameMapping),
+			description: tool.description,
+			parameters: tool.input_schema ?? {}
+		}
+	}));
+}
+function translateAnthropicToolChoiceToOpenAI(anthropicToolChoice, toolNameMapping) {
+	if (!anthropicToolChoice) return;
+	switch (anthropicToolChoice.type) {
+		case "auto": return "auto";
+		case "any": return "required";
+		case "tool":
+			if (anthropicToolChoice.name) return {
+				type: "function",
+				function: { name: getTruncatedToolName(anthropicToolChoice.name, toolNameMapping) }
+			};
+			return;
+		case "none": return "none";
+		default: return;
 	}
 }
 
@@ -9164,6 +8651,26 @@ const createResponses = async (payload, { vision, initiator, resolvedModel, sign
 	return await response.json();
 };
 
+//#endregion
+//#region src/routes/responses/model-shortcut.ts
+/**
+* Client-facing shortcut aliases for /responses model ids.
+*
+* Copilot exposes gpt-5.6 only as three named variants — Luna (lightweight),
+* Sol (powerful), Terra (versatile). A client sending a bare "gpt-5.6" would
+* otherwise fail findModelById. Map the shortcut to Sol because upstream tags
+* it `model_picker_category: "powerful"` — the closest match for an
+* unqualified "GPT-5.6" ask.
+*
+* Applied inside `normalizePayload`, i.e. AFTER `captureRequestedModel`, so
+* the client-facing echo (ADR-0001) still shows the original "gpt-5.6".
+*/
+const SHORTCUT_MAP = Object.assign(Object.create(null), { "gpt-5.6": "gpt-5.6-sol" });
+function resolveResponsesModelShortcut(model) {
+	if (typeof model !== "string") return model;
+	return SHORTCUT_MAP[model.toLowerCase()] ?? model;
+}
+
 //#endregion
 //#region src/routes/responses/stream-id-sync.ts
 const createStreamIdTracker = () => ({ outputItems: /* @__PURE__ */ new Map() });
@@ -9402,7 +8909,12 @@ const handleResponses = async (c) => {
 		rawPayload,
 		endpoint: "openai",
 		normalizePayload: (p) => {
-			const np = state.normalizeResponsesCallIds ? normalizeCallIds(p) : p;
+			const resolvedModel = resolveResponsesModelShortcut(p.model);
+			const withModel = resolvedModel === p.model ? p : {
+				...p,
+				model: resolvedModel
+			};
+			const np = state.normalizeResponsesCallIds ? normalizeCallIds(withModel) : withModel;
 			useFunctionApplyPatch(np);
 			filterUnsupportedBuiltins(np);
 			injectPromptCacheKey(np, clientName);