@dianshuv/copilot-api 0.8.1 → 0.9.1

package/dist/main.mjs

@@ -10,14 +10,13 @@ import { createHash, randomUUID } from "node:crypto";
 import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import clipboard from "clipboardy";
 import { serve } from "srvx";
-import invariant from "tiny-invariant";
 import { PostHog } from "posthog-node";
 import { execSync } from "node:child_process";
 import process$1 from "node:process";
 import pc from "picocolors";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
-import { stream, streamSSE } from "hono/streaming";
+import { streamSSE } from "hono/streaming";
 import { events } from "fetch-event-stream";
 
 //#region src/lib/paths.ts
@@ -125,6 +124,7 @@ const state = {
 	accountType: "individual",
 	manualApprove: false,
 	showToken: false,
+	showAllModels: false,
 	verbose: false,
 	autoTruncate: true,
 	compressToolResults: false,
@@ -1348,7 +1348,7 @@ const patchClaude = defineCommand({
 
 //#endregion
 //#region package.json
-var version = "0.8.1";
+var version = "0.9.1";
 
 //#endregion
 //#region src/lib/adaptive-rate-limiter.ts
@@ -1876,6 +1876,56 @@ function createRequestContextManager(staleMaxAgeSec) {
 	};
 }
 
+//#endregion
+//#region src/lib/hidden-models.ts
+/**
+* Hardcoded list of GitHub Copilot model ids that are hidden from listing
+* endpoints (the /v1/models response, the startup ASCII banner, and the
+* --claude-code interactive prompts), unless `--show-all-models` is passed.
+*
+* Note: this is a DISPLAY filter only. Explicit POSTs to handler endpoints
+* with a hidden id are NOT rejected — they pass through to upstream verbatim.
+*
+* Bumping the list requires a code change + release. No env var, no config
+* file, no CLI append interface.
+*/
+const HIDDEN_MODEL_IDS = new Set([
+	"gpt-3.5-turbo",
+	"gpt-3.5-turbo-0613",
+	"gpt-4",
+	"gpt-4-0613",
+	"gpt-4-0125-preview",
+	"gpt-4o",
+	"gpt-4o-mini",
+	"gpt-4-o-preview",
+	"gpt-4o-2024-05-13",
+	"gpt-4o-2024-08-06",
+	"gpt-4o-2024-11-20",
+	"gpt-4o-mini-2024-07-18",
+	"gpt-4.1",
+	"gpt-4.1-2025-04-14",
+	"gpt-41-copilot",
+	"gpt-5-mini",
+	"gpt-5.3-codex",
+	"gpt-5.4",
+	"text-embedding-ada-002",
+	"text-embedding-3-small",
+	"text-embedding-3-small-inference",
+	"gemini-2.5-pro",
+	"gemini-3-flash-preview",
+	"claude-opus-4.5",
+	"claude-opus-4.6",
+	"claude-opus-4.7-high",
+	"claude-opus-4.7-xhigh",
+	"claude-sonnet-4.5",
+	"mai-code-1-flash-internal",
+	"trajectory-compaction"
+]);
+function isHiddenModel(id, showAll) {
+	if (showAll) return false;
+	return HIDDEN_MODEL_IDS.has(id);
+}
+
 //#endregion
 //#region src/lib/history-ws.ts
 /**
@@ -3062,127 +3112,6 @@ function removeSystemReminderTags(text) {
 	return result;
 }
 
-//#endregion
-//#region src/lib/repetition-detector.ts
-/**
-* Stream repetition detector.
-*
-* Uses the KMP failure function (prefix function) to detect repeated patterns
-* in streaming text output. When a model gets stuck in a repetitive loop,
-* it wastes tokens producing the same content over and over. This detector
-* identifies such loops early so the caller can take action (log warning,
-* abort stream, etc.).
-*
-* The algorithm works by maintaining a sliding buffer of recent text and
-* computing the longest proper prefix that is also a suffix — if this
-* length exceeds `(text.length - period) >= minRepetitions * period`,
-* it means a pattern of length `period` has repeated enough times.
-*/
-const DEFAULT_CONFIG = {
-	minPatternLength: 10,
-	minRepetitions: 3,
-	maxBufferSize: 5e3
-};
-var RepetitionDetector = class {
-	buffer = "";
-	config;
-	detected = false;
-	constructor(config) {
-		this.config = {
-			...DEFAULT_CONFIG,
-			...config
-		};
-	}
-	/**
-	* Feed a text chunk into the detector.
-	* Returns `true` if repetition has been detected (now or previously).
-	* Once detected, subsequent calls return `true` without further analysis.
-	*/
-	feed(text) {
-		if (this.detected) return true;
-		if (!text) return false;
-		this.buffer += text;
-		if (this.buffer.length > this.config.maxBufferSize) this.buffer = this.buffer.slice(-this.config.maxBufferSize);
-		const minRequired = this.config.minPatternLength * this.config.minRepetitions;
-		if (this.buffer.length < minRequired) return false;
-		this.detected = detectRepetition(this.buffer, this.config.minPatternLength, this.config.minRepetitions);
-		return this.detected;
-	}
-	/** Reset detector state for a new stream */
-	reset() {
-		this.buffer = "";
-		this.detected = false;
-	}
-	/** Whether repetition has been detected */
-	get isDetected() {
-		return this.detected;
-	}
-};
-/**
-* Detect if the tail of `text` contains a repeating pattern.
-*
-* Uses the KMP prefix function: for a string S, the prefix function π[i]
-* gives the length of the longest proper prefix of S[0..i] that is also
-* a suffix. If π[n-1] ≥ (n - period) where period = n - π[n-1], then
-* the string is composed of a repeating unit of length `period`.
-*
-* We check the suffix of the buffer (last `checkLength` chars) to detect
-* if a pattern of at least `minPatternLength` chars repeats at least
-* `minRepetitions` times.
-*/
-function detectRepetition(text, minPatternLength, minRepetitions) {
-	const minWindow = minPatternLength * minRepetitions;
-	const maxWindow = Math.min(text.length, 2e3);
-	const windowSizes = [
-		minWindow,
-		Math.floor(maxWindow * .5),
-		maxWindow
-	].filter((w) => w >= minWindow && w <= text.length);
-	for (const windowSize of windowSizes) {
-		const window = text.slice(-windowSize);
-		const period = findRepeatingPeriod(window);
-		if (period >= minPatternLength) {
-			if (Math.floor(window.length / period) >= minRepetitions) return true;
-		}
-	}
-	return false;
-}
-/**
-* Find the shortest repeating period in a string using KMP prefix function.
-* Returns the period length, or the string length if no repetition found.
-*/
-function findRepeatingPeriod(s) {
-	const n = s.length;
-	if (n === 0) return 0;
-	const pi = new Int32Array(n);
-	for (let i = 1; i < n; i++) {
-		let j = pi[i - 1] ?? 0;
-		while (j > 0 && s[i] !== s[j]) j = pi[j - 1] ?? 0;
-		if (s[i] === s[j]) j++;
-		pi[i] = j;
-	}
-	const period = n - pi[n - 1];
-	if (period < n && n % period === 0) return period;
-	if (period < n && pi[n - 1] >= period) return period;
-	return n;
-}
-/**
-* Create a repetition detector callback for use in stream processing.
-* Returns a function that accepts text deltas and logs a warning on first detection.
-*/
-function createStreamRepetitionChecker(label, config) {
-	const detector = new RepetitionDetector(config);
-	let warned = false;
-	return (textDelta) => {
-		const isRepetitive = detector.feed(textDelta);
-		if (isRepetitive && !warned) {
-			warned = true;
-			consola.warn(`[RepetitionDetector] ${label}: Repetitive output detected in stream`);
-		}
-		return isRepetitive;
-	};
-}
-
 //#endregion
 //#region src/lib/tokenizer.ts
 const ENCODING_MAP = {
@@ -3396,197 +3325,68 @@ const getTokenCount = async (payload, model) => {
 };
 
 //#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";
+//#region src/lib/auto-truncate-openai.ts
 /**
-* 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.
+* Auto-truncate module: Automatically truncates conversation history
+* when it exceeds token or byte limits (OpenAI format).
 *
-* Either input may be undefined / empty.
+* Key features:
+* - Binary search for optimal truncation point
+* - Considers both token and byte limits
+* - Preserves system messages
+* - Filters orphaned tool_result and tool_use messages
+* - Dynamic byte limit adjustment on 413 errors
+* - Optional smart compression of old tool_result content
 */
-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);
-		}
+/** Estimate tokens for a single message (fast approximation) */
+function estimateMessageTokens$1(msg) {
+	let charCount = 0;
+	if (typeof msg.content === "string") charCount = msg.content.length;
+	else if (Array.isArray(msg.content)) {
+		for (const part of msg.content) if (part.type === "text") charCount += part.text.length;
+		else if ("image_url" in part) charCount += Math.min(part.image_url.url.length, 1e4);
 	}
-	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);
+	if (msg.tool_calls) charCount += JSON.stringify(msg.tool_calls).length;
+	return Math.ceil(charCount / 4) + 10;
 }
-/**
-* 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");
+/** Extract system/developer messages from the beginning */
+function extractSystemMessages(messages) {
+	let splitIndex = 0;
+	while (splitIndex < messages.length) {
+		const role = messages[splitIndex].role;
+		if (role !== "system" && role !== "developer") break;
+		splitIndex++;
+	}
+	return {
+		systemMessages: messages.slice(0, splitIndex),
+		conversationMessages: messages.slice(splitIndex)
+	};
 }
-
-//#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);
+/** Get tool_use IDs from an assistant message */
+function getToolCallIds(msg) {
+	if (msg.role === "assistant" && msg.tool_calls) return msg.tool_calls.map((tc) => tc.id);
+	return [];
 }
-/** Case-insensitive read of a header value. */
-function getHeader(headers, name) {
-	const key = findHeaderKey(headers, name);
-	return key === void 0 ? void 0 : headers[key];
+/** Filter orphaned tool_result messages */
+function filterOrphanedToolResults$1(messages) {
+	const toolUseIds = /* @__PURE__ */ new Set();
+	for (const msg of messages) for (const id of getToolCallIds(msg)) toolUseIds.add(id);
+	let removedCount = 0;
+	const filtered = messages.filter((msg) => {
+		if (msg.role === "tool" && msg.tool_call_id && !toolUseIds.has(msg.tool_call_id)) {
+			removedCount++;
+			return false;
+		}
+		return true;
+	});
+	if (removedCount > 0) consola.debug(`[AutoTruncate:OpenAI] Filtered ${removedCount} orphaned tool_result`);
+	return filtered;
 }
-/**
-* 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;
-const createChatCompletions = async (payload, options) => {
-	if (!state.copilotToken) throw new Error("Copilot token not found");
-	const vendor = options?.resolvedModel?.vendor;
-	const isOpenAIVendor = vendor === "OpenAI" || vendor === "Azure OpenAI";
-	const isLikelyGPT = !options?.resolvedModel && GPT_MODEL_PATTERN.test(payload.model);
-	let wire = payload;
-	if (isOpenAIVendor || isLikelyGPT) {
-		const { max_tokens, max_completion_tokens, ...rest } = payload;
-		const effective = max_completion_tokens ?? max_tokens;
-		wire = {
-			...rest,
-			...effective !== null && effective !== void 0 && { max_completion_tokens: effective }
-		};
-	}
-	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,
-			intent: isAgentCall ? "conversation-agent" : "conversation-panel"
-		}),
-		"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,
-		body: JSON.stringify(wire)
-	});
-	if (!response.ok) {
-		consola.error("Failed to create chat completions", response);
-		throw await HTTPError.fromResponse("Failed to create chat completions", response, options?.errorModelIdOverride ?? payload.model);
-	}
-	if (payload.stream) return events(response);
-	return await response.json();
-};
-
-//#endregion
-//#region src/lib/auto-truncate-openai.ts
-/**
-* Auto-truncate module: Automatically truncates conversation history
-* when it exceeds token or byte limits (OpenAI format).
-*
-* Key features:
-* - Binary search for optimal truncation point
-* - Considers both token and byte limits
-* - Preserves system messages
-* - Filters orphaned tool_result and tool_use messages
-* - Dynamic byte limit adjustment on 413 errors
-* - Optional smart compression of old tool_result content
-*/
-/** Estimate tokens for a single message (fast approximation) */
-function estimateMessageTokens$1(msg) {
-	let charCount = 0;
-	if (typeof msg.content === "string") charCount = msg.content.length;
-	else if (Array.isArray(msg.content)) {
-		for (const part of msg.content) if (part.type === "text") charCount += part.text.length;
-		else if ("image_url" in part) charCount += Math.min(part.image_url.url.length, 1e4);
-	}
-	if (msg.tool_calls) charCount += JSON.stringify(msg.tool_calls).length;
-	return Math.ceil(charCount / 4) + 10;
-}
-/** Extract system/developer messages from the beginning */
-function extractSystemMessages(messages) {
-	let splitIndex = 0;
-	while (splitIndex < messages.length) {
-		const role = messages[splitIndex].role;
-		if (role !== "system" && role !== "developer") break;
-		splitIndex++;
-	}
-	return {
-		systemMessages: messages.slice(0, splitIndex),
-		conversationMessages: messages.slice(splitIndex)
-	};
-}
-/** Get tool_use IDs from an assistant message */
-function getToolCallIds(msg) {
-	if (msg.role === "assistant" && msg.tool_calls) return msg.tool_calls.map((tc) => tc.id);
-	return [];
-}
-/** Filter orphaned tool_result messages */
-function filterOrphanedToolResults$1(messages) {
-	const toolUseIds = /* @__PURE__ */ new Set();
-	for (const msg of messages) for (const id of getToolCallIds(msg)) toolUseIds.add(id);
-	let removedCount = 0;
-	const filtered = messages.filter((msg) => {
-		if (msg.role === "tool" && msg.tool_call_id && !toolUseIds.has(msg.tool_call_id)) {
-			removedCount++;
-			return false;
-		}
-		return true;
-	});
-	if (removedCount > 0) consola.debug(`[AutoTruncate:OpenAI] Filtered ${removedCount} orphaned tool_result`);
-	return filtered;
-}
-/** Get tool_result IDs from all tool messages */
-function getToolResultIds$1(messages) {
-	const ids = /* @__PURE__ */ new Set();
-	for (const msg of messages) if (msg.role === "tool" && msg.tool_call_id) ids.add(msg.tool_call_id);
-	return ids;
+/** Get tool_result IDs from all tool messages */
+function getToolResultIds$1(messages) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const msg of messages) if (msg.role === "tool" && msg.tool_call_id) ids.add(msg.tool_call_id);
+	return ids;
 }
 /** Filter orphaned tool_use messages (those without matching tool_result) */
 function filterOrphanedToolUse$1(messages) {
@@ -3713,7 +3513,7 @@ function createTruncationSystemContext$1(removedCount, compressedCount, summary)
 	return context;
 }
 /** Create a truncation marker message (fallback when no system message) */
-function createTruncationMarker$2(removedCount, compressedCount, summary) {
+function createTruncationMarker$1(removedCount, compressedCount, summary) {
 	const parts = [];
 	if (removedCount > 0) parts.push(`${removedCount} earlier messages removed`);
 	if (compressedCount > 0) parts.push(`${compressedCount} tool results compressed`);
@@ -3840,7 +3640,7 @@ async function autoTruncateOpenAI(payload, model, config = {}) {
 			content: typeof lastSystem.content === "string" ? lastSystem.content + truncationContext : lastSystem.content
 		};
 		newSystemMessages = [...systemMessages.slice(0, lastSystemIdx), updatedSystem];
-	} else newMessages = [createTruncationMarker$2(removedCount, compressedCount, summary), ...preserved];
+	} else newMessages = [createTruncationMarker$1(removedCount, compressedCount, summary), ...preserved];
 	const newPayload = {
 		...payload,
 		messages: [...newSystemMessages, ...newMessages]
@@ -3866,73 +3666,530 @@ async function autoTruncateOpenAI(payload, model, config = {}) {
 }
 
 //#endregion
-//#region src/lib/error-metrics.ts
-function safeString(value, max = 200) {
-	try {
-		if (typeof value !== "string") return void 0;
-		return value.length > max ? value.slice(0, max) : value;
-	} catch {
-		return;
-	}
+//#region src/lib/openai-payload-prep.ts
+/**
+* OpenAI-shape payload preparation.
+*
+* 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).
+*/
+/** Type guard for non-streaming responses */
+function isNonStreaming(response) {
+	return Object.hasOwn(response, "choices");
 }
-function getStringProp(obj, key, max = 200) {
+/** Build final payload with auto-truncate if needed */
+async function buildFinalPayload(payload, model, autoTruncateConfig = {}) {
+	if (!state.autoTruncate || !model) {
+		if (state.autoTruncate && !model) consola.warn(`Auto-truncate: Model '${payload.model}' not found in cached models, skipping`);
+		return {
+			finalPayload: payload,
+			truncateResult: null
+		};
+	}
 	try {
-		if (typeof obj !== "object" || obj === null) return void 0;
-		return safeString(obj[key], max);
-	} catch {
-		return;
+		const check = await checkNeedsCompactionOpenAI(payload, model, autoTruncateConfig);
+		consola.debug(`Auto-truncate check: ${check.currentTokens} tokens (limit ${check.tokenLimit}), ${Math.round(check.currentBytes / 1024)}KB (limit ${check.byteLimit === Infinity ? "unlimited" : `${Math.round(check.byteLimit / 1024)}KB`}), needed: ${check.needed}${check.reason ? ` (${check.reason})` : ""}`);
+		if (!check.needed) return {
+			finalPayload: payload,
+			truncateResult: null
+		};
+		let reasonText;
+		if (check.reason === "both") reasonText = "tokens and size";
+		else if (check.reason === "bytes") reasonText = "size";
+		else reasonText = "tokens";
+		consola.info(`Auto-truncate triggered: exceeds ${reasonText} limit`);
+		const truncateResult = await autoTruncateOpenAI(payload, model, autoTruncateConfig);
+		return {
+			finalPayload: truncateResult.payload,
+			truncateResult
+		};
+	} catch (error) {
+		consola.warn("Auto-truncate failed, proceeding with original payload:", error instanceof Error ? error.message : error);
+		return {
+			finalPayload: payload,
+			truncateResult: null
+		};
 	}
 }
-function extractErrorMetrics(error) {
-	if (error instanceof HTTPError) {
-		const metrics = { status: error.status };
-		try {
-			const parsed = JSON.parse(error.responseText);
-			if (parsed.error?.code) metrics.copilotErrorCode = parsed.error.code;
-		} catch {}
-		return metrics;
-	}
-	if (!(error instanceof Error)) return {};
-	const metrics = {};
-	try {
-		metrics.errorName = getStringProp(error, "name");
-		metrics.errorMessage = getStringProp(error, "message");
-		metrics.errorCode = getStringProp(error, "code");
-		const cause = error.cause;
-		if (cause !== void 0 && cause !== null) {
-			metrics.causeName = getStringProp(cause, "name");
-			metrics.causeCode = getStringProp(cause, "code");
+/**
+* Log helpful debugging information when a 413 error occurs.
+* Also adjusts the dynamic byte limit for future requests.
+*/
+async function logPayloadSizeInfo(payload, model) {
+	const messageCount = payload.messages.length;
+	const bodySize = JSON.stringify(payload).length;
+	const bodySizeKB = Math.round(bodySize / 1024);
+	onRequestTooLarge(bodySize);
+	let imageCount = 0;
+	let largeMessages = 0;
+	let totalImageSize = 0;
+	for (const msg of payload.messages) {
+		if (Array.isArray(msg.content)) {
+			for (const part of msg.content) if (part.type === "image_url") {
+				imageCount++;
+				if (part.image_url.url.startsWith("data:")) totalImageSize += part.image_url.url.length;
+			}
 		}
+		if ((typeof msg.content === "string" ? msg.content.length : JSON.stringify(msg.content).length) > 5e4) largeMessages++;
+	}
+	consola.info("");
+	consola.info("╭─────────────────────────────────────────────────────────╮");
+	consola.info("│           413 Request Entity Too Large                  │");
+	consola.info("╰─────────────────────────────────────────────────────────╯");
+	consola.info("");
+	consola.info(`  Request body size: ${bodySizeKB} KB (${bodySize.toLocaleString()} bytes)`);
+	consola.info(`  Message count: ${messageCount}`);
+	if (model) try {
+		const tokenCount = await getTokenCount(payload, model);
+		const limit = model.capabilities?.limits?.max_prompt_tokens ?? 128e3;
+		consola.info(`  Estimated tokens: ${tokenCount.input.toLocaleString()} / ${limit.toLocaleString()}`);
 	} catch {}
-	return metrics;
+	if (imageCount > 0) {
+		const imageSizeKB = Math.round(totalImageSize / 1024);
+		consola.info(`  Images: ${imageCount} (${imageSizeKB} KB base64 data)`);
+	}
+	if (largeMessages > 0) consola.info(`  Large messages (>50KB): ${largeMessages}`);
+	consola.info("");
+	consola.info("  Suggestions:");
+	if (!state.autoTruncate) consola.info("    • Enable --auto-truncate to automatically truncate history");
+	if (imageCount > 0) consola.info("    • Remove or resize large images in the conversation");
+	consola.info("    • Start a new conversation with /clear or /reset");
+	consola.info("    • Reduce conversation history by deleting old messages");
+	consola.info("");
 }
 
 //#endregion
-//#region src/routes/shared.ts
+//#region src/lib/repetition-detector.ts
 /**
-* Shared utilities for request handlers.
-* Contains common functions used by both OpenAI and Anthropic message handlers.
+* Stream repetition detector.
+*
+* Uses the KMP failure function (prefix function) to detect repeated patterns
+* in streaming text output. When a model gets stuck in a repetitive loop,
+* it wastes tokens producing the same content over and over. This detector
+* identifies such loops early so the caller can take action (log warning,
+* abort stream, etc.).
+*
+* The algorithm works by maintaining a sliding buffer of recent text and
+* computing the longest proper prefix that is also a suffix — if this
+* length exceeds `(text.length - period) >= minRepetitions * period`,
+* it means a pattern of length `period` has repeated enough times.
 */
-/** Helper to update tracker model */
-function updateTrackerModel(trackingId, model, resolvedModel) {
-	if (!trackingId) return;
-	const request = requestTracker.getRequest(trackingId);
-	if (!request) return;
-	request.model = model;
-	request.resolvedModel = resolvedModel ?? model;
-}
-/** Helper to update only the resolved (post-translation) model */
-function updateTrackerResolvedModel(trackingId, resolvedModel) {
-	if (!trackingId) return;
-	const request = requestTracker.getRequest(trackingId);
-	if (request) request.resolvedModel = resolvedModel;
-}
-/** Helper to update tracker status */
-function updateTrackerStatus(trackingId, status) {
-	if (!trackingId) return;
-	requestTracker.updateRequest(trackingId, { status });
-}
-/** Record error response to history */
+const DEFAULT_CONFIG = {
+	minPatternLength: 10,
+	minRepetitions: 3,
+	maxBufferSize: 5e3
+};
+var RepetitionDetector = class {
+	buffer = "";
+	config;
+	detected = false;
+	constructor(config) {
+		this.config = {
+			...DEFAULT_CONFIG,
+			...config
+		};
+	}
+	/**
+	* Feed a text chunk into the detector.
+	* Returns `true` if repetition has been detected (now or previously).
+	* Once detected, subsequent calls return `true` without further analysis.
+	*/
+	feed(text) {
+		if (this.detected) return true;
+		if (!text) return false;
+		this.buffer += text;
+		if (this.buffer.length > this.config.maxBufferSize) this.buffer = this.buffer.slice(-this.config.maxBufferSize);
+		const minRequired = this.config.minPatternLength * this.config.minRepetitions;
+		if (this.buffer.length < minRequired) return false;
+		this.detected = detectRepetition(this.buffer, this.config.minPatternLength, this.config.minRepetitions);
+		return this.detected;
+	}
+	/** Reset detector state for a new stream */
+	reset() {
+		this.buffer = "";
+		this.detected = false;
+	}
+	/** Whether repetition has been detected */
+	get isDetected() {
+		return this.detected;
+	}
+};
+/**
+* Detect if the tail of `text` contains a repeating pattern.
+*
+* Uses the KMP prefix function: for a string S, the prefix function π[i]
+* gives the length of the longest proper prefix of S[0..i] that is also
+* a suffix. If π[n-1] ≥ (n - period) where period = n - π[n-1], then
+* the string is composed of a repeating unit of length `period`.
+*
+* We check the suffix of the buffer (last `checkLength` chars) to detect
+* if a pattern of at least `minPatternLength` chars repeats at least
+* `minRepetitions` times.
+*/
+function detectRepetition(text, minPatternLength, minRepetitions) {
+	const minWindow = minPatternLength * minRepetitions;
+	const maxWindow = Math.min(text.length, 2e3);
+	const windowSizes = [
+		minWindow,
+		Math.floor(maxWindow * .5),
+		maxWindow
+	].filter((w) => w >= minWindow && w <= text.length);
+	for (const windowSize of windowSizes) {
+		const window = text.slice(-windowSize);
+		const period = findRepeatingPeriod(window);
+		if (period >= minPatternLength) {
+			if (Math.floor(window.length / period) >= minRepetitions) return true;
+		}
+	}
+	return false;
+}
+/**
+* Find the shortest repeating period in a string using KMP prefix function.
+* Returns the period length, or the string length if no repetition found.
+*/
+function findRepeatingPeriod(s) {
+	const n = s.length;
+	if (n === 0) return 0;
+	const pi = new Int32Array(n);
+	for (let i = 1; i < n; i++) {
+		let j = pi[i - 1] ?? 0;
+		while (j > 0 && s[i] !== s[j]) j = pi[j - 1] ?? 0;
+		if (s[i] === s[j]) j++;
+		pi[i] = j;
+	}
+	const period = n - pi[n - 1];
+	if (period < n && n % period === 0) return period;
+	if (period < n && pi[n - 1] >= period) return period;
+	return n;
+}
+/**
+* Create a repetition detector callback for use in stream processing.
+* Returns a function that accepts text deltas and logs a warning on first detection.
+*/
+function createStreamRepetitionChecker(label, config) {
+	const detector = new RepetitionDetector(config);
+	let warned = false;
+	return (textDelta) => {
+		const isRepetitive = detector.feed(textDelta);
+		if (isRepetitive && !warned) {
+			warned = true;
+			consola.warn(`[RepetitionDetector] ${label}: Repetitive output detected in stream`);
+		}
+		return isRepetitive;
+	};
+}
+
+//#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;
+const createChatCompletions = async (payload, options) => {
+	if (!state.copilotToken) throw new Error("Copilot token not found");
+	const vendor = options?.resolvedModel?.vendor;
+	const isOpenAIVendor = vendor === "OpenAI" || vendor === "Azure OpenAI";
+	const isLikelyGPT = !options?.resolvedModel && GPT_MODEL_PATTERN.test(payload.model);
+	let wire = payload;
+	if (isOpenAIVendor || isLikelyGPT) {
+		const { max_tokens, max_completion_tokens, ...rest } = payload;
+		const effective = max_completion_tokens ?? max_tokens;
+		wire = {
+			...rest,
+			...effective !== null && effective !== void 0 && { max_completion_tokens: effective }
+		};
+	}
+	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,
+			intent: isAgentCall ? "conversation-agent" : "conversation-panel"
+		}),
+		"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,
+		body: JSON.stringify(wire)
+	});
+	if (!response.ok) {
+		consola.error("Failed to create chat completions", response);
+		throw await HTTPError.fromResponse("Failed to create chat completions", response, options?.errorModelIdOverride ?? payload.model);
+	}
+	if (payload.stream) return events(response);
+	return await response.json();
+};
+
+//#endregion
+//#region src/lib/echo-model.ts
+/**
+* Capture the requested model id from a raw request `model` value, classifying
+* it into the three-state contract. `undefined`/missing → `absent`; `""` →
+* `empty`; any other string → `present`.
+*/
+function captureRequestedModel(rawModel) {
+	if (rawModel === void 0 || rawModel === null) return { kind: "absent" };
+	if (typeof rawModel !== "string") return { kind: "absent" };
+	if (rawModel === "") return { kind: "empty" };
+	return {
+		kind: "present",
+		value: rawModel
+	};
+}
+/**
+* Resolve a {@link RequestedModel} into the action to take on a model field:
+*  - `{ write: true, value }` → set the field to `value`.
+*  - `{ write: false, omit: true }` → remove the field (absent case).
+*  - `null` → leave the field untouched (context-missing case).
+*/
+function resolveFieldAction(requested) {
+	if (requested.kind === "present") return { value: requested.value };
+	if (requested.kind === "empty") return { value: "" };
+	if (requested.kind === "absent") return { omit: true };
+	return null;
+}
+/**
+* Apply the requested-model action to a single `model`-like key on a shallow
+* clone of `obj`. Returns a new object; never mutates `obj`. If `obj` does not
+* own `key`, it is returned (cloned) unchanged regardless of the action — we
+* only ever rewrite a field the upstream payload actually carries (supports
+* AC-MALFORMED-SSE: no model field → original passthrough).
+*/
+function rewriteKey(obj, key, requested) {
+	if (!Object.hasOwn(obj, key)) return obj;
+	const action = resolveFieldAction(requested);
+	if (action === null) return obj;
+	if ("omit" in action) {
+		const { [key]: _omitted, ...rest } = obj;
+		return rest;
+	}
+	return {
+		...obj,
+		[key]: action.value
+	};
+}
+/**
+* Core rewrite over a plain record. Rewrites the documented model fields:
+*  - top-level `model`,
+*  - nested `message.model` (Anthropic message_start),
+*  - nested `response.model` (OpenAI Responses event).
+* Returns a shallow clone; never mutates the input.
+*/
+function echoRecord(body, requested) {
+	let out = rewriteKey(body, "model", requested);
+	if (isRecord(out.message) && Object.hasOwn(out.message, "model")) {
+		const newMessage = rewriteKey(out.message, "model", requested);
+		if (newMessage !== out.message) out = {
+			...out,
+			message: newMessage
+		};
+	}
+	if (isRecord(out.response) && Object.hasOwn(out.response, "model")) {
+		const newResponse = rewriteKey(out.response, "model", requested);
+		if (newResponse !== out.response) out = {
+			...out,
+			response: newResponse
+		};
+	}
+	return out;
+}
+/**
+* Rewrite the documented client-facing model field(s) of a JSON response body
+* to the requested model id. Handles every supported non-stream/body shape:
+*  - top-level `model` (OpenAI chat/completions & Responses bodies, Anthropic
+*    messages body),
+*  - nested `message.model` (Anthropic `message_start` event object),
+*  - nested `response.model` (OpenAI Responses streaming event object).
+*
+* Returns a shallow-cloned object; the input is never mutated. Fields that are
+* not present are left as-is (a payload with no model field round-trips
+* unchanged), supporting AC-MALFORMED-SSE.
+*
+* The generic is constrained to `object` (not an index-signature shape) so it
+* accepts the project's domain interfaces (`AnthropicResponse`,
+* `ChatCompletionChunk`, …) directly without forcing callers to widen them.
+*/
+function echoModelInResponseBody(body, requested) {
+	return echoRecord(body, requested);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Rewrite the model field of an already-parsed SSE event payload to the
+* requested model id, dispatched by protocol shape:
+*  - Anthropic `message_start` → `message.model`,
+*  - OpenAI chunk → top-level `model`,
+*  - OpenAI Responses event → nested `response.model`.
+*
+* The field dispatch is identical to {@link echoModelInResponseBody} (both
+* operate on the same documented model fields), so this delegates to the same
+* core rather than duplicating the shape logic — the two exports exist to name
+* the two responsibilities (body vs parsed-event) at call sites, per the PRD's
+* single-policy-point design. Events with no model field round-trip unchanged
+* (AC-MALFORMED-SSE); the input is never mutated.
+*/
+function echoModelInParsedEvent(event, requested) {
+	return echoRecord(event, requested);
+}
+
+//#endregion
+//#region src/lib/error-metrics.ts
+function safeString(value, max = 200) {
+	try {
+		if (typeof value !== "string") return void 0;
+		return value.length > max ? value.slice(0, max) : value;
+	} catch {
+		return;
+	}
+}
+function getStringProp(obj, key, max = 200) {
+	try {
+		if (typeof obj !== "object" || obj === null) return void 0;
+		return safeString(obj[key], max);
+	} catch {
+		return;
+	}
+}
+function extractErrorMetrics(error) {
+	if (error instanceof HTTPError) {
+		const metrics = { status: error.status };
+		try {
+			const parsed = JSON.parse(error.responseText);
+			if (parsed.error?.code) metrics.copilotErrorCode = parsed.error.code;
+		} catch {}
+		return metrics;
+	}
+	if (!(error instanceof Error)) return {};
+	const metrics = {};
+	try {
+		metrics.errorName = getStringProp(error, "name");
+		metrics.errorMessage = getStringProp(error, "message");
+		metrics.errorCode = getStringProp(error, "code");
+		const cause = error.cause;
+		if (cause !== void 0 && cause !== null) {
+			metrics.causeName = getStringProp(cause, "name");
+			metrics.causeCode = getStringProp(cause, "code");
+		}
+	} catch {}
+	return metrics;
+}
+
+//#endregion
+//#region src/routes/observability-recording.ts
+/**
+* Observability recording for error paths.
+*
+* Writes failed requests to history and emits matching PostHog analytics
+* events for both non-streaming errors (before the stream starts) and
+* mid-stream errors (after the accumulator has partial data). Success-path
+* analytics live in `tracker-mutations.ts` alongside `completeTracking`.
+*/
+function formatError(error) {
+	if (error instanceof Error) return error.message || error.name;
+	if (typeof error === "string") return error;
+	try {
+		const s = JSON.stringify(error);
+		if (s && s !== "{}") return s;
+	} catch {}
+	try {
+		return String(error);
+	} catch {
+		return "Unknown error";
+	}
+}
+/** Record error response to history */
 function recordErrorResponse(ctx, model, error, endpoint, stream) {
 	recordResponse(ctx.historyId, {
 		success: false,
@@ -3941,26 +4198,83 @@ function recordErrorResponse(ctx, model, error, endpoint, stream) {
 			input_tokens: 0,
 			output_tokens: 0
 		},
-		error: error instanceof Error ? error.message : "Unknown error",
+		error: formatError(error),
 		content: null
 	}, Date.now() - ctx.startTime);
-	if (endpoint !== void 0) {
-		const metrics = extractErrorMetrics(error);
-		const { attempts } = getRetryAttempts(error);
-		captureRequest({
-			model,
-			inputTokens: 0,
-			outputTokens: 0,
-			durationMs: Date.now() - ctx.startTime,
-			success: false,
-			stream: stream ?? false,
-			toolCount: 0,
-			...metrics,
-			errorPhase: stream ? "pre_stream" : "non_stream",
-			endpoint,
-			attempt: attempts
-		});
-	}
+	const metrics = extractErrorMetrics(error);
+	const { attempts } = getRetryAttempts(error);
+	captureRequest({
+		model,
+		inputTokens: 0,
+		outputTokens: 0,
+		durationMs: Date.now() - ctx.startTime,
+		success: false,
+		stream: stream ?? false,
+		toolCount: 0,
+		...metrics,
+		errorPhase: stream ? "pre_stream" : "non_stream",
+		endpoint,
+		attempt: attempts
+	});
+}
+/** Record streaming error to history (works with any accumulator type) */
+function recordStreamError(opts) {
+	const { acc, fallbackModel, ctx, error, endpoint } = opts;
+	const model = acc.model || fallbackModel;
+	recordResponse(ctx.historyId, {
+		success: false,
+		model,
+		usage: {
+			input_tokens: 0,
+			output_tokens: 0
+		},
+		error: formatError(error),
+		content: null
+	}, Date.now() - ctx.startTime);
+	const metrics = extractErrorMetrics(error);
+	captureRequest({
+		model,
+		inputTokens: acc.inputTokens ?? 0,
+		outputTokens: acc.outputTokens ?? 0,
+		durationMs: Date.now() - ctx.startTime,
+		success: false,
+		stream: true,
+		toolCount: 0,
+		...metrics,
+		errorPhase: "mid_stream",
+		endpoint,
+		attempt: 1
+	});
+}
+
+//#endregion
+//#region src/routes/tracker-mutations.ts
+/**
+* TUI tracker mutations and analytics completion.
+*
+* All in-place updates to the TUI request tracker (model, status, resolved
+* model) and the success/failure terminal transitions. `completeTracking`
+* additionally emits a PostHog analytics event for successful requests; error
+* paths emit their PostHog events through `observability-recording.ts`.
+*/
+/** Helper to update tracker model */
+function updateTrackerModel(trackingId, model, resolvedModel) {
+	if (!trackingId) return;
+	const request = requestTracker.getRequest(trackingId);
+	if (!request) return;
+	request.model = model;
+	request.resolvedModel = resolvedModel ?? model;
+}
+/** Helper to update only the resolved (post-translation) model */
+function updateTrackerResolvedModel(trackingId, resolvedModel) {
+	if (!trackingId) return;
+	const request = requestTracker.getRequest(trackingId);
+	if (request) request.resolvedModel = resolvedModel;
+}
+/** Helper to update tracker status */
+function updateTrackerStatus(trackingId, status) {
+	if (!trackingId) return;
+	requestTracker.updateRequest(trackingId, { status });
 }
 /** Complete TUI tracking and send PostHog analytics */
 function completeTracking(trackingId, inputTokens, outputTokens, queueWaitMs, reasoningTokens, analytics) {
@@ -3988,149 +4302,90 @@ function completeTracking(trackingId, inputTokens, outputTokens, queueWaitMs, re
 		stopReason: analytics.stopReason
 	});
 }
-function formatError(error) {
-	if (error instanceof Error) return error.message || error.name;
-	if (typeof error === "string") return error;
-	try {
-		const s = JSON.stringify(error);
-		if (s && s !== "{}") return s;
-	} catch {}
-	try {
-		return String(error);
-	} catch {
-		return "Unknown error";
-	}
-}
 /** Fail TUI tracking */
 function failTracking(trackingId, error) {
 	if (!trackingId) return;
 	requestTracker.failRequest(trackingId, formatError(error));
 }
+
+//#endregion
+//#region src/routes/entry-context.ts
 /**
-* Create a marker to prepend to responses indicating auto-truncation occurred.
-* Works with both OpenAI and Anthropic truncate results.
+* Construct the route-entry context for any handler.
+*
+* Returns `{ ctx, payload }` where `payload` is the normalized version of
+* `rawPayload` (possibly unchanged) and `ctx` is fully populated with the
+* captured R, history id, tracking id, and start time.
 */
-function createTruncationMarker$1(result) {
-	if (!result.wasCompacted) return "";
-	const { originalTokens, compactedTokens, removedMessageCount } = result;
-	if (originalTokens === void 0 || compactedTokens === void 0 || removedMessageCount === void 0) return `\n\n---\n[Auto-truncated: conversation history was reduced to fit context limits]`;
-	const reduction = originalTokens - compactedTokens;
-	return `\n\n---\n[Auto-truncated: ${removedMessageCount} messages removed, ${originalTokens} → ${compactedTokens} tokens (${Math.round(reduction / originalTokens * 100)}% reduction)]`;
-}
-/** Record streaming error to history (works with any accumulator type) */
-function recordStreamError(opts) {
-	const { acc, fallbackModel, ctx, error, endpoint } = opts;
-	const model = acc.model || fallbackModel;
-	recordResponse(ctx.historyId, {
-		success: false,
-		model,
-		usage: {
-			input_tokens: 0,
-			output_tokens: 0
-		},
-		error: formatError(error),
-		content: null
-	}, Date.now() - ctx.startTime);
-	if (endpoint !== void 0) {
-		const metrics = extractErrorMetrics(error);
-		captureRequest({
-			model,
-			inputTokens: acc.inputTokens ?? 0,
-			outputTokens: acc.outputTokens ?? 0,
-			durationMs: Date.now() - ctx.startTime,
-			success: false,
-			stream: true,
-			toolCount: 0,
-			...metrics,
-			errorPhase: "mid_stream",
-			endpoint,
-			attempt: 1
-		});
-	}
+function createEntryContext(args) {
+	const requestedModel = captureRequestedModel(args.rawPayload.model);
+	const payload = args.normalizePayload ? args.normalizePayload(args.rawPayload) : args.rawPayload;
+	const trackingId = args.c.get("trackingId");
+	const startTime = (trackingId ? requestTracker.getRequest(trackingId) : void 0)?.startTime ?? Date.now();
+	updateTrackerModel(trackingId, payload.model);
+	return {
+		payload,
+		ctx: {
+			historyId: recordRequest(args.endpoint, args.buildHistoryRequest(payload)),
+			trackingId,
+			startTime,
+			requestedModel
+		}
+	};
 }
-/** Type guard for non-streaming responses */
-function isNonStreaming(response) {
-	return Object.hasOwn(response, "choices");
+
+//#endregion
+//#region src/routes/response-context.ts
+/**
+* Resolve the requested model id (R) carried on the response context into a
+* {@link RequestedModel}. A context that never captured R (`undefined`) is
+* treated as `context-missing` so the echo passes the upstream value through
+* unchanged — it must never invent an id or throw.
+*
+* `createEntryContext` always populates `requestedModel`, so callers operating
+* on a ctx that came from the entry adapter never hit the `context-missing`
+* branch. The fallback exists for the (theoretically impossible) case where
+* a ctx was constructed by hand without `requestedModel` — e.g., a test
+* fixture or a future code path that bypasses the adapter.
+*/
+function requestedModelOf(ctx) {
+	return ctx.requestedModel ?? { kind: "context-missing" };
 }
-/** Build final payload with auto-truncate if needed */
-async function buildFinalPayload(payload, model, autoTruncateConfig = {}) {
-	if (!state.autoTruncate || !model) {
-		if (state.autoTruncate && !model) consola.warn(`Auto-truncate: Model '${payload.model}' not found in cached models, skipping`);
-		return {
-			finalPayload: payload,
-			truncateResult: null
-		};
-	}
-	try {
-		const check = await checkNeedsCompactionOpenAI(payload, model, autoTruncateConfig);
-		consola.debug(`Auto-truncate check: ${check.currentTokens} tokens (limit ${check.tokenLimit}), ${Math.round(check.currentBytes / 1024)}KB (limit ${check.byteLimit === Infinity ? "unlimited" : `${Math.round(check.byteLimit / 1024)}KB`}), needed: ${check.needed}${check.reason ? ` (${check.reason})` : ""}`);
-		if (!check.needed) return {
-			finalPayload: payload,
-			truncateResult: null
-		};
-		let reasonText;
-		if (check.reason === "both") reasonText = "tokens and size";
-		else if (check.reason === "bytes") reasonText = "size";
-		else reasonText = "tokens";
-		consola.info(`Auto-truncate triggered: exceeds ${reasonText} limit`);
-		const truncateResult = await autoTruncateOpenAI(payload, model, autoTruncateConfig);
-		return {
-			finalPayload: truncateResult.payload,
-			truncateResult
-		};
-	} catch (error) {
-		consola.warn("Auto-truncate failed, proceeding with original payload:", error instanceof Error ? error.message : error);
-		return {
-			finalPayload: payload,
-			truncateResult: null
-		};
-	}
+/**
+* Echo the requested model id into a JSON response body at the client write-out
+* boundary. Thin context-aware wrapper over {@link echoModelInResponseBody};
+* MUST be called AFTER history/posthog/TUI have read the upstream value.
+*/
+function echoResponseBody(body, ctx) {
+	return echoModelInResponseBody(body, requestedModelOf(ctx));
 }
 /**
-* Log helpful debugging information when a 413 error occurs.
-* Also adjusts the dynamic byte limit for future requests.
+* Echo the requested model id into an already-parsed SSE event payload at the
+* client write-out boundary. Thin context-aware wrapper over
+* {@link echoModelInParsedEvent}; MUST be called AFTER the stream accumulator
+* (the observability data source) has read the upstream value.
 */
-async function logPayloadSizeInfo(payload, model) {
-	const messageCount = payload.messages.length;
-	const bodySize = JSON.stringify(payload).length;
-	const bodySizeKB = Math.round(bodySize / 1024);
-	onRequestTooLarge(bodySize);
-	let imageCount = 0;
-	let largeMessages = 0;
-	let totalImageSize = 0;
-	for (const msg of payload.messages) {
-		if (Array.isArray(msg.content)) {
-			for (const part of msg.content) if (part.type === "image_url") {
-				imageCount++;
-				if (part.image_url.url.startsWith("data:")) totalImageSize += part.image_url.url.length;
-			}
-		}
-		if ((typeof msg.content === "string" ? msg.content.length : JSON.stringify(msg.content).length) > 5e4) largeMessages++;
-	}
-	consola.info("");
-	consola.info("╭─────────────────────────────────────────────────────────╮");
-	consola.info("│           413 Request Entity Too Large                  │");
-	consola.info("╰─────────────────────────────────────────────────────────╯");
-	consola.info("");
-	consola.info(`  Request body size: ${bodySizeKB} KB (${bodySize.toLocaleString()} bytes)`);
-	consola.info(`  Message count: ${messageCount}`);
-	if (model) try {
-		const tokenCount = await getTokenCount(payload, model);
-		const limit = model.capabilities?.limits?.max_prompt_tokens ?? 128e3;
-		consola.info(`  Estimated tokens: ${tokenCount.input.toLocaleString()} / ${limit.toLocaleString()}`);
-	} catch {}
-	if (imageCount > 0) {
-		const imageSizeKB = Math.round(totalImageSize / 1024);
-		consola.info(`  Images: ${imageCount} (${imageSizeKB} KB base64 data)`);
-	}
-	if (largeMessages > 0) consola.info(`  Large messages (>50KB): ${largeMessages}`);
-	consola.info("");
-	consola.info("  Suggestions:");
-	if (!state.autoTruncate) consola.info("    • Enable --auto-truncate to automatically truncate history");
-	if (imageCount > 0) consola.info("    • Remove or resize large images in the conversation");
-	consola.info("    • Start a new conversation with /clear or /reset");
-	consola.info("    • Reduce conversation history by deleting old messages");
-	consola.info("");
+function echoParsedEvent(event, ctx) {
+	return echoModelInParsedEvent(event, requestedModelOf(ctx));
+}
+
+//#endregion
+//#region src/routes/truncation-marker.ts
+/**
+* Create a marker to prepend to responses indicating auto-truncation occurred.
+* Works with both OpenAI and Anthropic truncate results.
+*
+* Distinct from the file-private `createTruncationMarker` helpers in
+* `lib/auto-truncate-{openai,anthropic}.ts` — those build a synthetic upstream
+* `Message`/`AnthropicMessage` used as a no-system-message fallback inside the
+* truncate algorithm; this one returns the client-facing display suffix.
+*/
+function formatClientTruncationMarker(result) {
+	if (!result.wasCompacted) return "";
+	const { originalTokens, compactedTokens, removedMessageCount } = result;
+	if (originalTokens === void 0 || compactedTokens === void 0 || removedMessageCount === void 0) return `\n\n---\n[Auto-truncated: conversation history was reduced to fit context limits]`;
+	const reduction = originalTokens - compactedTokens;
+	return `\n\n---\n[Auto-truncated: ${removedMessageCount} messages removed, ${originalTokens} → ${compactedTokens} tokens (${Math.round(reduction / originalTokens * 100)}% reduction)]`;
 }
 
 //#endregion
@@ -4139,26 +4394,24 @@ function getReasoningTokensFromOpenAIUsage(usage) {
 	return usage?.completion_tokens_details?.reasoning_tokens;
 }
 async function handleCompletion$1(c) {
-	const originalPayload = await c.req.json();
-	consola.debug("Request payload:", JSON.stringify(originalPayload).slice(-400));
-	const trackingId = c.get("trackingId");
-	const startTime = (trackingId ? requestTracker.getRequest(trackingId) : void 0)?.startTime ?? Date.now();
-	updateTrackerModel(trackingId, originalPayload.model);
-	const ctx = {
-		historyId: recordRequest("openai", {
-			model: originalPayload.model,
-			messages: convertOpenAIMessages(originalPayload.messages),
-			stream: originalPayload.stream ?? false,
-			tools: originalPayload.tools?.map((t) => ({
+	const rawPayload = await c.req.json();
+	consola.debug("Request payload:", JSON.stringify(rawPayload).slice(-400));
+	const { ctx, payload: originalPayload } = createEntryContext({
+		c,
+		rawPayload,
+		endpoint: "openai",
+		buildHistoryRequest: (p) => ({
+			model: p.model,
+			messages: convertOpenAIMessages(p.messages),
+			stream: p.stream ?? false,
+			tools: p.tools?.map((t) => ({
 				name: t.function.name,
 				description: t.function.description
 			})),
-			max_tokens: originalPayload.max_tokens ?? void 0,
-			temperature: originalPayload.temperature ?? void 0
-		}),
-		trackingId,
-		startTime
-	};
+			max_tokens: p.max_tokens ?? void 0,
+			temperature: p.temperature ?? void 0
+		})
+	});
 	const selectedModel = findModelById(originalPayload.model);
 	await logTokenCount(originalPayload, selectedModel);
 	const { finalPayload, truncateResult } = await buildFinalPayload(originalPayload, selectedModel);
@@ -4173,21 +4426,20 @@ async function handleCompletion$1(c) {
 		c,
 		payload,
 		selectedModel,
-		ctx,
-		trackingId
+		ctx
 	});
 }
 /**
 * Execute the API call with enhanced error handling for 413 errors.
 */
 async function executeRequest(opts) {
-	const { c, payload, selectedModel, ctx, trackingId } = opts;
+	const { c, payload, selectedModel, ctx } = opts;
 	try {
 		const { result: response, queueWaitMs } = await executeWithAdaptiveRateLimit(() => createChatCompletions(payload, { resolvedModel: selectedModel }));
 		ctx.queueWaitMs = queueWaitMs;
 		if (isNonStreaming(response)) return handleNonStreamingResponse$1(c, response, ctx, payload);
 		consola.debug("Streaming response");
-		updateTrackerStatus(trackingId, "streaming");
+		updateTrackerStatus(ctx.trackingId, "streaming");
 		return streamSSE(c, async (stream) => {
 			await handleStreamingResponse$1({
 				stream,
@@ -4217,7 +4469,7 @@ function handleNonStreamingResponse$1(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) {
-		const marker = createTruncationMarker$1(ctx.truncateResult);
+		const marker = formatClientTruncationMarker(ctx.truncateResult);
 		response = {
 			...response,
 			choices: response.choices.map((choice, i) => i === 0 ? {
@@ -4262,7 +4514,7 @@ function handleNonStreamingResponse$1(c, originalResponse, ctx, payload) {
 		reasoningTokens,
 		stopReason: choice.finish_reason
 	});
-	return c.json(response);
+	return c.json(echoResponseBody(response, ctx));
 }
 function buildResponseContent(choice) {
 	return {
@@ -4303,7 +4555,7 @@ async function handleStreamingResponse$1(opts) {
 	const checkRepetition = createStreamRepetitionChecker(`openai:${payload.model}`);
 	try {
 		if (state.verbose && ctx.truncateResult?.wasCompacted) {
-			const marker = createTruncationMarker$1(ctx.truncateResult);
+			const marker = formatClientTruncationMarker(ctx.truncateResult);
 			const markerChunk = {
 				id: `compact-marker-${Date.now()}`,
 				object: "chat.completion.chunk",
@@ -4317,15 +4569,14 @@ async function handleStreamingResponse$1(opts) {
 				}]
 			};
 			await stream.writeSSE({
-				data: JSON.stringify(markerChunk),
+				data: JSON.stringify(echoParsedEvent(markerChunk, ctx)),
 				event: "message"
 			});
 			acc.content += marker;
 		}
 		for await (const chunk of response) {
 			consola.debug("Streaming chunk:", JSON.stringify(chunk));
-			parseStreamChunk(chunk, acc, checkRepetition);
-			await stream.writeSSE(chunk);
+			await accumulateAndEchoChunk(chunk, acc, checkRepetition, ctx, stream);
 		}
 		recordStreamSuccess(acc, payload.model, ctx);
 		completeTracking(ctx.trackingId, acc.inputTokens, acc.outputTokens, ctx.queueWaitMs, acc.reasoningTokens, {
@@ -4358,45 +4609,70 @@ async function handleStreamingResponse$1(opts) {
 				}]
 			};
 			await stream.writeSSE({
-				data: JSON.stringify(markerChunk),
+				data: JSON.stringify(echoParsedEvent(markerChunk, ctx)),
 				event: "message"
 			});
 		} catch {}
 	}
 }
-function parseStreamChunk(chunk, acc, checkRepetition) {
-	if (!chunk.data || chunk.data === "[DONE]") return;
+async function accumulateAndEchoChunk(chunk, acc, checkRepetition, ctx, stream) {
+	if (!chunk.data || chunk.data === "[DONE]") {
+		await stream.writeSSE(chunk);
+		return;
+	}
+	let parsed;
 	try {
-		const parsed = JSON.parse(chunk.data);
-		if (parsed.model && !acc.model) acc.model = parsed.model;
-		if (parsed.usage) {
-			acc.inputTokens = parsed.usage.prompt_tokens;
-			acc.outputTokens = parsed.usage.completion_tokens;
-			acc.reasoningTokens = getReasoningTokensFromOpenAIUsage(parsed.usage) ?? 0;
-		}
-		const choice = parsed.choices[0];
-		if (choice) {
-			if (choice.delta.content) {
-				acc.content += choice.delta.content;
-				checkRepetition(choice.delta.content);
-			}
-			if (choice.delta.tool_calls) for (const tc of choice.delta.tool_calls) {
-				const idx = tc.index;
-				if (!acc.toolCallMap.has(idx)) acc.toolCallMap.set(idx, {
-					id: tc.id ?? "",
-					name: tc.function?.name ?? "",
-					arguments: ""
-				});
-				const item = acc.toolCallMap.get(idx);
-				if (item) {
-					if (tc.id) item.id = tc.id;
-					if (tc.function?.name) item.name = tc.function.name;
-					if (tc.function?.arguments) item.arguments += tc.function.arguments;
-				}
+		parsed = JSON.parse(chunk.data);
+	} catch {
+		await stream.writeSSE(chunk);
+		return;
+	}
+	if (typeof parsed !== "object" || parsed === null) {
+		await stream.writeSSE(chunk);
+		return;
+	}
+	try {
+		accumulateParsedChunk(parsed, acc, checkRepetition);
+	} catch {}
+	if (!Object.hasOwn(parsed, "model")) {
+		await stream.writeSSE(chunk);
+		return;
+	}
+	const echoed = echoParsedEvent(parsed, ctx);
+	await stream.writeSSE({
+		...chunk,
+		data: JSON.stringify(echoed)
+	});
+}
+function accumulateParsedChunk(parsed, acc, checkRepetition) {
+	if (parsed.model && !acc.model) acc.model = parsed.model;
+	if (parsed.usage) {
+		acc.inputTokens = parsed.usage.prompt_tokens;
+		acc.outputTokens = parsed.usage.completion_tokens;
+		acc.reasoningTokens = getReasoningTokensFromOpenAIUsage(parsed.usage) ?? 0;
+	}
+	const choice = parsed.choices?.[0];
+	if (choice) {
+		if (choice.delta?.content) {
+			acc.content += choice.delta.content;
+			checkRepetition(choice.delta.content);
+		}
+		if (choice.delta?.tool_calls) for (const tc of choice.delta.tool_calls) {
+			const idx = tc.index;
+			if (!acc.toolCallMap.has(idx)) acc.toolCallMap.set(idx, {
+				id: tc.id ?? "",
+				name: tc.function?.name ?? "",
+				arguments: ""
+			});
+			const item = acc.toolCallMap.get(idx);
+			if (item) {
+				if (tc.id) item.id = tc.id;
+				if (tc.function?.name) item.name = tc.function.name;
+				if (tc.function?.arguments) item.arguments += tc.function.arguments;
 			}
-			if (choice.finish_reason) acc.finishReason = choice.finish_reason;
 		}
-	} catch {}
+		if (choice.finish_reason) acc.finishReason = choice.finish_reason;
+	}
 }
 function recordStreamSuccess(acc, fallbackModel, ctx) {
 	for (const tc of acc.toolCallMap.values()) if (tc.id && tc.name) acc.toolCalls.push(tc);
@@ -4460,31 +4736,6 @@ completionRoutes.post("/", async (c) => {
 	}
 });
 
-//#endregion
-//#region src/services/copilot/create-embeddings.ts
-const createEmbeddings = async (payload) => {
-	if (!state.copilotToken) throw new Error("Copilot token not found");
-	const response = await copilotFetch("/embeddings", {
-		method: "POST",
-		headers: copilotHeaders(state),
-		body: JSON.stringify(payload)
-	});
-	if (!response.ok) throw await HTTPError.fromResponse("Failed to create embeddings", response);
-	return await response.json();
-};
-
-//#endregion
-//#region src/routes/embeddings/route.ts
-const embeddingRoutes = new Hono();
-embeddingRoutes.post("/", async (c) => {
-	try {
-		const response = await createEmbeddings(await c.req.json());
-		return c.json(response);
-	} catch (error) {
-		return forwardError(c, error);
-	}
-});
-
 //#endregion
 //#region src/routes/event-logging/route.ts
 const eventLoggingRoutes = new Hono();
@@ -4492,507 +4743,6 @@ eventLoggingRoutes.post("/batch", (c) => {
 	return c.text("OK", 200);
 });
 
-//#endregion
-//#region src/routes/gemini/error.ts
-const STATUS_MAP = {
-	400: "INVALID_ARGUMENT",
-	401: "PERMISSION_DENIED",
-	403: "PERMISSION_DENIED",
-	404: "NOT_FOUND",
-	413: "INVALID_ARGUMENT",
-	429: "RESOURCE_EXHAUSTED",
-	500: "INTERNAL"
-};
-function geminiError(c, code, status, message) {
-	return c.json({ error: {
-		code,
-		message,
-		status
-	} }, code);
-}
-function forwardGeminiError(c, error) {
-	if (error instanceof HTTPError) {
-		const status = STATUS_MAP[error.status] ?? "INTERNAL";
-		const code = error.status;
-		let message = error.responseText;
-		try {
-			const parsed = JSON.parse(error.responseText);
-			if (parsed.error?.message) message = parsed.error.message;
-		} catch {}
-		consola.error(`HTTP ${code}:`, message.slice(0, 200));
-		return geminiError(c, code, status, message);
-	}
-	consola.error("Unexpected error:", error);
-	return geminiError(c, 500, "INTERNAL", error instanceof Error ? error.message : "Unknown error");
-}
-
-//#endregion
-//#region src/routes/gemini/gemini-to-openai.ts
-function translateGeminiToOpenAI(request, model) {
-	const messages = [];
-	if (request.systemInstruction) {
-		const systemText = extractTextFromParts(request.systemInstruction.parts);
-		if (systemText) messages.push({
-			role: "system",
-			content: systemText
-		});
-	}
-	let globalCallIndex = 0;
-	const callIdQueue = /* @__PURE__ */ new Map();
-	if (!Array.isArray(request.contents)) return { payload: {
-		messages: [],
-		model
-	} };
-	for (const content of request.contents) {
-		const translated = translateContent(content, callIdQueue, () => `call_gemini_${globalCallIndex++}`);
-		messages.push(...translated);
-	}
-	const payload = {
-		messages,
-		model
-	};
-	const config = request.generationConfig;
-	if (config) {
-		if (config.temperature !== void 0) payload.temperature = config.temperature;
-		if (config.topP !== void 0) payload.top_p = config.topP;
-		if (config.maxOutputTokens !== void 0) payload.max_tokens = config.maxOutputTokens;
-		if (config.stopSequences !== void 0) payload.stop = config.stopSequences;
-		if (config.responseMimeType === "application/json") payload.response_format = { type: "json_object" };
-	}
-	if (request.tools) {
-		const tools = translateTools(request.tools);
-		if (tools.length > 0) payload.tools = tools;
-	}
-	if (request.toolConfig?.functionCallingConfig?.mode) payload.tool_choice = {
-		AUTO: "auto",
-		ANY: "required",
-		NONE: "none"
-	}[request.toolConfig.functionCallingConfig.mode];
-	return { payload };
-}
-function mapFunctionCallsToToolCalls(functionCalls, callIdQueue, generateId) {
-	return functionCalls.map((fc) => {
-		const id = generateId();
-		pushToQueue(callIdQueue, fc.functionCall.name, id);
-		return {
-			id,
-			type: "function",
-			function: {
-				name: fc.functionCall.name,
-				arguments: JSON.stringify(fc.functionCall.args)
-			}
-		};
-	});
-}
-function translateContent(content, callIdQueue, generateId) {
-	const role = content.role === "model" ? "assistant" : "user";
-	const messages = [];
-	const textParts = [];
-	const imageParts = [];
-	const functionCalls = [];
-	const functionResponses = [];
-	for (const part of content.parts) if (isTextPart(part)) {
-		if (!part.thought) textParts.push(part);
-	} else if (isInlineDataPart(part)) imageParts.push(part);
-	else if (isFunctionCallPart(part)) functionCalls.push(part);
-	else if (isFunctionResponsePart(part)) functionResponses.push(part);
-	else if (isFileDataPart(part)) throw new HTTPError("fileData parts are not supported", 400, "fileData parts are not supported");
-	if (imageParts.length > 0) {
-		const contentParts = [];
-		for (const part of content.parts) if (isTextPart(part) && !part.thought) contentParts.push({
-			type: "text",
-			text: part.text
-		});
-		else if (isInlineDataPart(part)) contentParts.push({
-			type: "image_url",
-			image_url: { url: `data:${part.inlineData.mimeType};base64,${part.inlineData.data}` }
-		});
-		const msg = {
-			role,
-			content: contentParts
-		};
-		if (functionCalls.length > 0 && role === "assistant") msg.tool_calls = mapFunctionCallsToToolCalls(functionCalls, callIdQueue, generateId);
-		messages.push(msg);
-	} else if (functionCalls.length > 0 && role === "assistant") {
-		const textContent = textParts.length > 0 ? textParts.map((p) => p.text).join("") : null;
-		messages.push({
-			role: "assistant",
-			content: textContent,
-			tool_calls: mapFunctionCallsToToolCalls(functionCalls, callIdQueue, generateId)
-		});
-	} else if (textParts.length > 0) messages.push({
-		role,
-		content: textParts.map((p) => p.text).join("")
-	});
-	let orphanIndex = 0;
-	for (const fr of functionResponses) {
-		const queue = callIdQueue.get(fr.functionResponse.name);
-		const id = queue && queue.length > 0 ? queue.shift() : `call_gemini_orphan_${orphanIndex++}`;
-		messages.push({
-			role: "tool",
-			content: JSON.stringify(fr.functionResponse.response),
-			tool_call_id: id
-		});
-	}
-	return messages;
-}
-function translateTools(geminiTools) {
-	const tools = [];
-	for (const tool of geminiTools) if (tool.functionDeclarations) for (const decl of tool.functionDeclarations) tools.push({
-		type: "function",
-		function: {
-			name: decl.name,
-			description: decl.description,
-			parameters: decl.parameters ?? {
-				type: "object",
-				properties: {}
-			}
-		}
-	});
-	return tools;
-}
-function pushToQueue(queue, name, id) {
-	const existing = queue.get(name);
-	if (existing) existing.push(id);
-	else queue.set(name, [id]);
-}
-function extractTextFromParts(parts) {
-	return parts.filter((p) => "text" in p && (!("thought" in p) || !p.thought)).map((p) => p.text).join("\n");
-}
-function isTextPart(part) {
-	return "text" in part;
-}
-function isInlineDataPart(part) {
-	return "inlineData" in part;
-}
-function isFunctionCallPart(part) {
-	return "functionCall" in part;
-}
-function isFunctionResponsePart(part) {
-	return "functionResponse" in part;
-}
-function isFileDataPart(part) {
-	return "fileData" in part;
-}
-
-//#endregion
-//#region src/routes/gemini/count-tokens-handler.ts
-async function handleGeminiCountTokens(c, model) {
-	try {
-		const { payload } = translateGeminiToOpenAI(await c.req.json(), model);
-		const selectedModel = findModelById(model);
-		if (!selectedModel) {
-			consola.warn("Model not found for count_tokens, returning estimate");
-			return c.json({ totalTokens: 1 });
-		}
-		const tokenCount = await getTokenCount(payload, selectedModel);
-		const totalTokens = tokenCount.input + tokenCount.output;
-		consola.debug(`Gemini countTokens: ${totalTokens} tokens`);
-		return c.json({ totalTokens });
-	} catch (error) {
-		return forwardGeminiError(c, error);
-	}
-}
-
-//#endregion
-//#region src/routes/gemini/openai-to-gemini.ts
-function translateOpenAIResponseToGemini(response, model) {
-	const choice = response.choices.at(0);
-	if (!choice) return {
-		candidates: [],
-		usageMetadata: buildUsageMetadata(response.usage),
-		modelVersion: model
-	};
-	const parts = [];
-	if (choice.message.content) parts.push({ text: choice.message.content });
-	if (choice.message.tool_calls) for (const tc of choice.message.tool_calls) {
-		const args = parseArgs(tc.function.arguments);
-		parts.push({ functionCall: {
-			name: tc.function.name,
-			args
-		} });
-	}
-	if (parts.length === 0) parts.push({ text: "" });
-	return {
-		candidates: [{
-			content: {
-				role: "model",
-				parts
-			},
-			finishReason: mapFinishReason(choice.finish_reason),
-			index: 0
-		}],
-		usageMetadata: buildUsageMetadata(response.usage),
-		modelVersion: model
-	};
-}
-function createGeminiStreamState() {
-	return {
-		toolCalls: /* @__PURE__ */ new Map(),
-		usage: {
-			promptTokens: 0,
-			completionTokens: 0,
-			totalTokens: 0
-		},
-		model: "",
-		finishReason: ""
-	};
-}
-function translateOpenAIChunkToGemini(chunk, state) {
-	const results = [];
-	if (!state.model && chunk.model) state.model = chunk.model;
-	if (chunk.usage) {
-		state.usage.promptTokens = chunk.usage.prompt_tokens;
-		state.usage.completionTokens = chunk.usage.completion_tokens;
-		state.usage.totalTokens = chunk.usage.total_tokens;
-	}
-	const choice = chunk.choices.at(0);
-	if (!choice) return results;
-	const delta = choice.delta;
-	if (delta.tool_calls) for (const tc of delta.tool_calls) {
-		const existing = state.toolCalls.get(tc.index);
-		if (existing) {
-			if (tc.function?.arguments) existing.args += tc.function.arguments;
-		} else {
-			const flushed = flushToolCalls(state, tc.index);
-			if (flushed) results.push(flushed);
-			state.toolCalls.set(tc.index, {
-				name: tc.function?.name ?? "",
-				args: tc.function?.arguments ?? ""
-			});
-		}
-	}
-	if (delta.content) results.push(buildGeminiChunk([{ text: delta.content }], choice.finish_reason, state));
-	if (choice.finish_reason) {
-		state.finishReason = choice.finish_reason;
-		const flushed = flushToolCalls(state);
-		if (flushed) results.push(flushed);
-		if (!delta.content) results.push(buildGeminiChunk([], choice.finish_reason, state));
-	}
-	return results;
-}
-function flushToolCalls(state, belowIndex) {
-	if (state.toolCalls.size === 0) return null;
-	const parts = [];
-	for (const [idx, tc] of state.toolCalls) {
-		if (belowIndex !== void 0 && idx >= belowIndex) continue;
-		const args = parseArgs(tc.args);
-		parts.push({ functionCall: {
-			name: tc.name,
-			args
-		} });
-		state.toolCalls.delete(idx);
-	}
-	if (parts.length === 0) return null;
-	return buildGeminiChunk(parts, null, state);
-}
-function buildGeminiChunk(parts, finishReason, state) {
-	const candidate = {
-		content: {
-			role: "model",
-			parts: parts.length > 0 ? parts : [{ text: "" }]
-		},
-		index: 0
-	};
-	if (finishReason) candidate.finishReason = mapFinishReason(finishReason);
-	return {
-		candidates: [candidate],
-		usageMetadata: {
-			promptTokenCount: state.usage.promptTokens,
-			candidatesTokenCount: state.usage.completionTokens,
-			totalTokenCount: state.usage.totalTokens
-		},
-		modelVersion: state.model
-	};
-}
-function parseArgs(raw) {
-	try {
-		return JSON.parse(raw);
-	} catch {
-		return { raw };
-	}
-}
-function mapFinishReason(reason) {
-	switch (reason) {
-		case "stop":
-		case "tool_calls": return "STOP";
-		case "length": return "MAX_TOKENS";
-		case "content_filter": return "SAFETY";
-		default: return "OTHER";
-	}
-}
-function buildUsageMetadata(usage) {
-	return {
-		promptTokenCount: usage?.prompt_tokens ?? 0,
-		candidatesTokenCount: usage?.completion_tokens ?? 0,
-		totalTokenCount: usage?.total_tokens ?? 0
-	};
-}
-
-//#endregion
-//#region src/routes/gemini/handler.ts
-async function handleGeminiGenerate(c, model, isStream) {
-	try {
-		const geminiRequest = await c.req.json();
-		consola.debug("Gemini request for model:", model, "stream:", isStream);
-		const trackingId = c.get("trackingId");
-		const startTime = Date.now();
-		updateTrackerModel(trackingId, model);
-		const { payload } = translateGeminiToOpenAI(geminiRequest, model);
-		payload.stream = isStream;
-		const selectedModel = findModelById(model);
-		if (isNullish(payload.max_tokens) && selectedModel) payload.max_tokens = selectedModel.capabilities?.limits?.max_output_tokens;
-		const ctx = {
-			historyId: recordRequest("gemini", {
-				model,
-				messages: payload.messages.map((m) => ({
-					role: m.role,
-					content: typeof m.content === "string" ? m.content : JSON.stringify(m.content),
-					tool_calls: m.tool_calls,
-					tool_call_id: m.tool_call_id
-				})),
-				stream: isStream,
-				max_tokens: payload.max_tokens ?? void 0,
-				temperature: payload.temperature ?? void 0
-			}),
-			trackingId,
-			startTime
-		};
-		const { result: response, queueWaitMs } = await executeWithAdaptiveRateLimit(() => createChatCompletions(payload, { resolvedModel: selectedModel }));
-		ctx.queueWaitMs = queueWaitMs;
-		if (isNonStreaming(response)) return handleNonStreamResponse(c, response, model, ctx, payload);
-		consola.debug("Streaming Gemini response");
-		updateTrackerStatus(trackingId, "streaming");
-		return stream(c, async (s) => {
-			c.header("Content-Type", "text/event-stream");
-			c.header("Cache-Control", "no-cache");
-			c.header("Connection", "keep-alive");
-			const streamState = createGeminiStreamState();
-			try {
-				for await (const rawEvent of response) {
-					if (rawEvent.data === "[DONE]") break;
-					let chunk;
-					try {
-						chunk = JSON.parse(rawEvent.data);
-					} catch (parseError) {
-						consola.debug("Failed to parse stream chunk:", parseError);
-						continue;
-					}
-					const geminiChunks = translateOpenAIChunkToGemini(chunk, streamState);
-					for (const gc of geminiChunks) await s.write(`data: ${JSON.stringify(gc)}\n\n`);
-				}
-				recordResponse(ctx.historyId, {
-					success: true,
-					model: streamState.model || model,
-					usage: {
-						input_tokens: streamState.usage.promptTokens,
-						output_tokens: streamState.usage.completionTokens
-					},
-					content: null
-				}, Date.now() - ctx.startTime);
-				completeTracking(ctx.trackingId, streamState.usage.promptTokens, streamState.usage.completionTokens, ctx.queueWaitMs, void 0, {
-					model: streamState.model || model,
-					stream: true,
-					durationMs: Date.now() - ctx.startTime,
-					stopReason: streamState.finishReason || void 0,
-					toolCount: payload.tools?.length ?? 0
-				});
-			} catch (error) {
-				recordStreamError({
-					acc: { model: streamState.model || model },
-					fallbackModel: model,
-					ctx,
-					error,
-					endpoint: "chat_completions"
-				});
-				failTracking(ctx.trackingId, error);
-				try {
-					await s.write(`data: ${JSON.stringify({ candidates: [{
-						content: {
-							role: "model",
-							parts: [{ text: `\n\n[copilot-api: upstream stream terminated. Please retry.]` }]
-						},
-						finishReason: "OTHER",
-						index: 0
-					}] })}\n\n`);
-				} catch {}
-			}
-		});
-	} catch (error) {
-		const trackingId = c.get("trackingId");
-		if (trackingId) failTracking(trackingId, error);
-		return forwardGeminiError(c, error);
-	}
-}
-function handleNonStreamResponse(c, response, model, ctx, payload) {
-	const geminiResponse = translateOpenAIResponseToGemini(response, model);
-	const usage = response.usage;
-	recordResponse(ctx.historyId, {
-		success: true,
-		model: response.model || model,
-		usage: {
-			input_tokens: usage?.prompt_tokens ?? 0,
-			output_tokens: usage?.completion_tokens ?? 0
-		},
-		stop_reason: response.choices[0]?.finish_reason,
-		content: response.choices[0] ? {
-			role: "assistant",
-			content: response.choices[0].message.content ?? ""
-		} : null
-	}, Date.now() - ctx.startTime);
-	completeTracking(ctx.trackingId, usage?.prompt_tokens ?? 0, usage?.completion_tokens ?? 0, ctx.queueWaitMs, void 0, {
-		model: response.model || model,
-		stream: false,
-		durationMs: Date.now() - ctx.startTime,
-		stopReason: response.choices[0]?.finish_reason,
-		toolCount: payload.tools?.length ?? 0
-	});
-	return c.json(geminiResponse);
-}
-
-//#endregion
-//#region src/routes/gemini/model-alias.ts
-/**
-* Maps Gemini model names to equivalent models available on GitHub Copilot.
-*
-* Two types of aliases:
-*
-* - **Forced**: Always applied regardless of Copilot model availability.
-*   Use when the old model name should never reach the backend.
-*
-* - **Conditional**: Only applied when the requested model is absent from
-*   the Copilot model list, so if Copilot adds native support the request
-*   goes through unchanged.
-*/
-const GEMINI_FORCED_ALIASES = { "gemini-3.1-pro-preview-customtools": "gemini-3.1-pro-preview" };
-const GEMINI_CONDITIONAL_ALIASES = {
-	"gemini-2.5-flash-lite": "gemini-3.5-flash",
-	"gemini-2.5-flash": "gemini-3.5-flash"
-};
-function resolveGeminiModelAlias(model) {
-	if (model in GEMINI_FORCED_ALIASES) return GEMINI_FORCED_ALIASES[model];
-	if (!(model in GEMINI_CONDITIONAL_ALIASES)) return model;
-	if (findModelById(model)) return model;
-	return GEMINI_CONDITIONAL_ALIASES[model];
-}
-
-//#endregion
-//#region src/routes/gemini/route.ts
-const geminiRoutes = new Hono();
-geminiRoutes.post("/:modelAction", async (c) => {
-	const modelAction = c.req.param("modelAction");
-	const colonIndex = modelAction.lastIndexOf(":");
-	if (colonIndex === -1) return geminiError(c, 400, "INVALID_ARGUMENT", "Missing action in URL");
-	const model = resolveGeminiModelAlias(modelAction.slice(0, Math.max(0, colonIndex)));
-	const action = modelAction.slice(Math.max(0, colonIndex + 1));
-	switch (action) {
-		case "generateContent": return handleGeminiGenerate(c, model, false);
-		case "streamGenerateContent": return handleGeminiGenerate(c, model, true);
-		case "countTokens": return handleGeminiCountTokens(c, model);
-		default: return geminiError(c, 400, "INVALID_ARGUMENT", `Unknown action: ${action}`);
-	}
-});
-
 //#endregion
 //#region src/routes/history/api.ts
 function handleGetEntries(c) {
@@ -8064,10 +7814,43 @@ function handleDirectAnthropicNonStreamingResponse(c, response, ctx, truncateRes
 		stopReason: response.stop_reason ?? void 0
 	});
 	let finalResponse = response;
-	if (state.verbose && truncateResult?.wasCompacted) finalResponse = prependMarkerToResponse(response, createTruncationMarker$1(truncateResult));
+	if (state.verbose && truncateResult?.wasCompacted) finalResponse = prependMarkerToResponse(response, formatClientTruncationMarker(truncateResult));
 	logServerToolBlocks(finalResponse.content);
 	finalResponse = filterServerToolBlocksFromResponse(finalResponse);
-	return c.json(finalResponse);
+	return c.json(echoResponseBody(finalResponse, ctx));
+}
+/**
+* Echo the requester's original model id into a single already-serialized
+* native-Anthropic SSE `data:` payload at the write-out boundary.
+*
+* In the native Anthropic stream only `message_start` carries a model field
+* (`message.model`), so every other event type is forwarded byte-for-byte —
+* this both avoids a needless re-parse per text delta and guarantees events
+* with no model field round-trip unchanged. For `message_start`, the payload
+* is parsed and run through the shared echo policy point; the re-serialized
+* form is returned ONLY when the echo actually rewrote the object (identity
+* change). When nothing was rewritten — a model-less `message_start`, or
+* `context-missing` R — the original `forwardData` bytes are returned verbatim
+* so a passthrough never re-minifies / re-orders the upstream frame. If the
+* payload fails to parse (malformed upstream frame), the original string is
+* likewise returned untouched so the stream is never corrupted or interrupted
+* (AC-MALFORMED-SSE).
+*
+* Operates on the serialized output of the server-tool rewrite (not the raw
+* upstream frame), so the echo composes with any index remap that step made.
+*/
+function echoForwardData(forwardData, eventType, ctx) {
+	if (eventType !== "message_start") return forwardData;
+	let parsed;
+	try {
+		parsed = JSON.parse(forwardData);
+	} catch {
+		return forwardData;
+	}
+	if (typeof parsed !== "object" || parsed === null) return forwardData;
+	const echoed = echoParsedEvent(parsed, ctx);
+	if (echoed === parsed) return forwardData;
+	return JSON.stringify(echoed);
 }
 /**
 * Handle streaming direct Anthropic response (passthrough SSE events)
@@ -8094,9 +7877,10 @@ async function handleDirectAnthropicStreamingResponse(opts) {
 			if (event.type === "content_block_delta" && event.delta.type === "text_delta") checkRepetition(event.delta.text);
 			const forwardData = serverToolFilter.rewriteEvent(event, rawEvent.data);
 			if (forwardData === null) continue;
+			const echoedData = echoForwardData(forwardData, event.type, ctx);
 			await stream.writeSSE({
 				event: rawEvent.event || event.type,
-				data: forwardData
+				data: echoedData
 			});
 		}
 		recordAnthropicStreamingResponse(acc, anthropicPayload.model, ctx);
@@ -8235,7 +8019,7 @@ function handleNonStreamingResponse(opts) {
 	let anthropicResponse = translateToAnthropic(response, toolNameMapping);
 	consola.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
 	if (state.verbose && ctx.truncateResult?.wasCompacted) {
-		const marker = createTruncationMarker$1(ctx.truncateResult);
+		const marker = formatClientTruncationMarker(ctx.truncateResult);
 		anthropicResponse = prependMarkerToResponse(anthropicResponse, marker);
 	}
 	recordResponse(ctx.historyId, {
@@ -8276,7 +8060,7 @@ function handleNonStreamingResponse(opts) {
 		toolCount: anthropicPayload.tools?.length ?? 0,
 		stopReason: anthropicResponse.stop_reason ?? void 0
 	});
-	return c.json(anthropicResponse);
+	return c.json(echoResponseBody(anthropicResponse, ctx));
 }
 async function handleStreamingResponse(opts) {
 	const { stream, response, toolNameMapping, anthropicPayload, ctx } = opts;
@@ -8290,7 +8074,7 @@ async function handleStreamingResponse(opts) {
 	const checkRepetition = createStreamRepetitionChecker(`translated:${anthropicPayload.model}`);
 	try {
 		if (ctx.truncateResult?.wasCompacted) {
-			const marker = createTruncationMarker$1(ctx.truncateResult);
+			const marker = formatClientTruncationMarker(ctx.truncateResult);
 			await sendTruncationMarkerEvent(stream, streamState, marker);
 			acc.content += marker;
 		}
@@ -8300,7 +8084,8 @@ async function handleStreamingResponse(opts) {
 			toolNameMapping,
 			streamState,
 			acc,
-			checkRepetition
+			checkRepetition,
+			ctx
 		});
 		recordAnthropicStreamingResponse(acc, anthropicPayload.model, ctx);
 		completeTracking(ctx.trackingId, acc.inputTokens, acc.outputTokens, ctx.queueWaitMs, void 0, {
@@ -8363,7 +8148,7 @@ async function sendTruncationMarkerEvent(stream, streamState, marker) {
 	streamState.contentBlockIndex++;
 }
 async function processStreamChunks(opts) {
-	const { stream, response, toolNameMapping, streamState, acc, checkRepetition } = 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;
@@ -8381,9 +8166,10 @@ async function processStreamChunks(opts) {
 			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: event.type,
-				data: JSON.stringify(event)
+				event: echoed.type,
+				data: JSON.stringify(echoed)
 			});
 		}
 	}
@@ -8400,35 +8186,34 @@ function resolveModelFromBetaHeader(model, betaHeader) {
 	return resolved;
 }
 async function handleCompletion(c) {
-	const anthropicPayload = await c.req.json();
-	consola.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
-	const betaHeader = c.req.header("anthropic-beta");
-	anthropicPayload.model = resolveModelFromBetaHeader(anthropicPayload.model, betaHeader);
+	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)
+		})
+	});
 	logToolInfo(anthropicPayload);
 	const subagentMarker = parseSubagentMarkerFromFirstUser(anthropicPayload);
 	const initiatorOverride = subagentMarker ? "agent" : void 0;
 	if (subagentMarker) consola.debug("Detected Subagent marker:", JSON.stringify(subagentMarker));
-	const useDirectAnthropicApi = supportsDirectAnthropicApi(anthropicPayload.model);
-	const trackingId = c.get("trackingId");
-	const startTime = (trackingId ? requestTracker.getRequest(trackingId) : void 0)?.startTime ?? Date.now();
-	updateTrackerModel(trackingId, anthropicPayload.model);
-	const ctx = {
-		historyId: recordRequest("anthropic", {
-			model: anthropicPayload.model,
-			messages: convertAnthropicMessages(anthropicPayload.messages),
-			stream: anthropicPayload.stream ?? false,
-			tools: anthropicPayload.tools?.map((t) => ({
-				name: t.name,
-				description: t.description
-			})),
-			max_tokens: anthropicPayload.max_tokens,
-			temperature: anthropicPayload.temperature,
-			system: extractSystemPrompt(anthropicPayload.system)
-		}),
-		trackingId,
-		startTime
-	};
-	if (useDirectAnthropicApi) return handleDirectAnthropicCompletion(c, anthropicPayload, ctx, initiatorOverride);
+	if (supportsDirectAnthropicApi(anthropicPayload.model)) return handleDirectAnthropicCompletion(c, anthropicPayload, ctx, initiatorOverride);
 	return handleTranslatedCompletion(c, anthropicPayload, ctx, initiatorOverride);
 }
 /**
@@ -8528,7 +8313,7 @@ const modelRoutes = new Hono();
 modelRoutes.get("/", async (c) => {
 	try {
 		if (!state.models) await cacheModels();
-		const models = state.models?.data.map((model) => ({
+		const models = state.models?.data.filter((model) => !isHiddenModel(model.id, state.showAllModels)).map((model) => ({
 			id: model.id,
 			object: "model",
 			type: "model",
@@ -8590,13 +8375,23 @@ const createResponses = async (payload, { vision, initiator, resolvedModel }) =>
 //#endregion
 //#region src/routes/responses/stream-id-sync.ts
 const createStreamIdTracker = () => ({ outputItems: /* @__PURE__ */ new Map() });
-const fixStreamIds = (data, event, tracker) => {
+/**
+* Rewrite a single Responses SSE event's `data`: synchronize item ids AND echo
+* the requester's model id into any nested `response.model` the event carries,
+* from one parse/serialize. Events whose payload has no `response.model` (text
+* deltas, the `error` event, …) round-trip with their model untouched
+* (AC-MALFORMED-SSE); unparseable/empty `data` is forwarded byte-for-byte.
+*
+* The echo is applied AFTER the handler's history/tracking has read the upstream
+* values from the same chunks, preserving the observability split (AC-OBS).
+*/
+const fixStreamIds = (data, event, tracker, requestedModel) => {
 	if (!data) return data;
-	const parsed = JSON.parse(data);
+	const echoed = echoModelInParsedEvent(JSON.parse(data), requestedModel);
 	switch (event) {
-		case "response.output_item.added": return handleOutputItemAdded(parsed, tracker);
-		case "response.output_item.done": return handleOutputItemDone(parsed, tracker);
-		default: return handleItemId(parsed, tracker);
+		case "response.output_item.added": return handleOutputItemAdded(echoed, tracker);
+		case "response.output_item.done": return handleOutputItemDone(echoed, tracker);
+		default: return handleItemId(echoed, tracker);
 	}
 };
 const handleOutputItemAdded = (parsed, tracker) => {
@@ -8808,31 +8603,34 @@ const TERMINAL_EVENTS = new Set([
 	"error"
 ]);
 const handleResponses = async (c) => {
-	let payload = await c.req.json();
-	if (state.normalizeResponsesCallIds) payload = normalizeCallIds(payload);
+	const { ctx, payload } = createEntryContext({
+		c,
+		rawPayload: await c.req.json(),
+		endpoint: "openai",
+		normalizePayload: (p) => {
+			const np = state.normalizeResponsesCallIds ? normalizeCallIds(p) : p;
+			useFunctionApplyPatch(np);
+			removeWebSearchTool(np);
+			return np;
+		},
+		buildHistoryRequest: (p) => {
+			const historyTools = convertResponsesToolsToDefinitions(p.tools);
+			return {
+				model: p.model,
+				messages: convertResponsesInputToMessages(p.input),
+				stream: p.stream ?? false,
+				tools: historyTools.length > 0 ? historyTools : void 0,
+				max_tokens: p.max_output_tokens ?? void 0,
+				temperature: p.temperature ?? void 0,
+				system: p.instructions ?? void 0
+			};
+		}
+	});
 	consola.debug("Responses request payload:", JSON.stringify(payload));
-	const trackingId = c.get("trackingId");
-	const startTime = (trackingId ? requestTracker.getRequest(trackingId) : void 0)?.startTime ?? Date.now();
-	updateTrackerModel(trackingId, payload.model);
-	useFunctionApplyPatch(payload);
-	removeWebSearchTool(payload);
 	const model = payload.model;
 	const stream = payload.stream ?? false;
 	const tools = convertResponsesToolsToDefinitions(payload.tools);
-	const historyId = recordRequest("openai", {
-		model,
-		messages: convertResponsesInputToMessages(payload.input),
-		stream,
-		tools: tools.length > 0 ? tools : void 0,
-		max_tokens: payload.max_output_tokens ?? void 0,
-		temperature: payload.temperature ?? void 0,
-		system: payload.instructions ?? void 0
-	});
-	const ctx = {
-		historyId,
-		trackingId,
-		startTime
-	};
+	const { historyId, trackingId, startTime } = ctx;
 	const selectedModel = findModelById(payload.model);
 	if (!(selectedModel?.supported_endpoints?.includes(RESPONSES_ENDPOINT) ?? false)) {
 		recordErrorResponse(ctx, model, /* @__PURE__ */ new Error("This model does not support the responses endpoint."), "responses", stream);
@@ -8872,7 +8670,7 @@ const handleResponses = async (c) => {
 							const parsed = JSON.parse(rawData);
 							if (typeof parsed.sequence_number === "number") lastSequenceNumber = parsed.sequence_number;
 						} catch {}
-						const processedData = fixStreamIds(rawData, eventType, idTracker);
+						const processedData = fixStreamIds(rawData, eventType, idTracker, requestedModelOf(ctx));
 						await stream.writeSSE({
 							id: chunk.id,
 							event: eventType,
@@ -8935,7 +8733,7 @@ const handleResponses = async (c) => {
 			toolCount: tools.length
 		});
 		consola.debug("Forwarding native Responses result:", JSON.stringify(result).slice(-400));
-		return c.json(result);
+		return c.json(echoResponseBody(result, ctx));
 	} catch (error) {
 		recordErrorResponse(ctx, model, error, "responses", stream);
 		failTracking(trackingId, error);
@@ -9046,17 +8844,14 @@ server.get("/health", (c) => {
 });
 server.route("/chat/completions", completionRoutes);
 server.route("/models", modelRoutes);
-server.route("/embeddings", embeddingRoutes);
 server.route("/usage", usageRoute);
 server.route("/token", tokenRoute);
 server.route("/v1/chat/completions", completionRoutes);
 server.route("/v1/models", modelRoutes);
-server.route("/v1/embeddings", embeddingRoutes);
 server.route("/v1/messages", messageRoutes);
 server.route("/api/event_logging", eventLoggingRoutes);
 server.route("/v1/responses", responsesRoutes);
 server.route("/responses", responsesRoutes);
-server.route("/v1beta/models", geminiRoutes);
 server.route("/history", historyRoutes);
 
 //#endregion
@@ -9104,6 +8899,8 @@ async function runServer(options) {
 	if (options.accountType !== "individual") consola.info(`Using ${options.accountType} plan GitHub account`);
 	state.manualApprove = options.manual;
 	state.showToken = options.showToken;
+	state.showAllModels = options.showAllModels;
+	if (options.showAllModels) consola.warn("--show-all-models: hidden model blacklist is BYPASSED for this run");
 	state.autoTruncate = options.autoTruncate;
 	state.compressToolResults = options.compressToolResults;
 	state.redirectAnthropic = options.redirectAnthropic;
@@ -9148,17 +8945,27 @@ async function runServer(options) {
 		consola.error(error instanceof Error ? error.message : String(error));
 		process.exit(1);
 	}
-	consola.info(`Available models:\n${state.models?.data.map((m) => formatModelInfo(m)).join("\n")}`);
+	const allModels = state.models?.data ?? [];
+	if (allModels.length === 0) {
+		consola.error(`Upstream returned zero models for account type "${state.accountType}". Verify the account type matches your Copilot plan and that upstream is reachable.`);
+		process.exit(1);
+	}
+	const visibleModels = allModels.filter((m) => !isHiddenModel(m.id, state.showAllModels));
+	if (visibleModels.length === 0) consola.warn("All upstream models are filtered by the hardcoded blacklist. /v1/models will return an empty list, but explicit POSTs with a hidden id still pass through to upstream. Restart with --show-all-models to see the full catalogue.");
+	else consola.info(`Available models:\n${visibleModels.map((m) => formatModelInfo(m)).join("\n")}`);
 	const serverUrl = `http://${options.host ?? "localhost"}:${options.port}`;
 	if (options.claudeCode) {
-		invariant(state.models, "Models should be loaded by now");
+		if (visibleModels.length === 0) {
+			consola.error("--claude-code interactive setup needs at least one visible model. Restart with --show-all-models or update src/lib/hidden-models.ts.");
+			process.exit(1);
+		}
 		const selectedModel = await consola.prompt("Select a model to use with Claude Code", {
 			type: "select",
-			options: state.models.data.map((model) => model.id)
+			options: visibleModels.map((model) => model.id)
 		});
 		const selectedSmallModel = await consola.prompt("Select a small model to use with Claude Code", {
 			type: "select",
-			options: state.models.data.map((model) => model.id)
+			options: visibleModels.map((model) => model.id)
 		});
 		const command = generateEnvScript({
 			ANTHROPIC_BASE_URL: serverUrl,
@@ -9278,6 +9085,11 @@ const start = defineCommand({
 			default: false,
 			description: "Show GitHub and Copilot tokens on fetch and refresh"
 		},
+		"show-all-models": {
+			type: "boolean",
+			default: false,
+			description: "Show ALL upstream models, including the hardcoded blacklist (default: false, blacklist filtered from listings)"
+		},
 		"proxy-env": {
 			type: "boolean",
 			default: false,
@@ -9343,6 +9155,7 @@ const start = defineCommand({
 			githubToken: args["github-token"],
 			claudeCode: args["claude-code"],
 			showToken: args["show-token"],
+			showAllModels: args["show-all-models"],
 			proxyEnv: args["proxy-env"],
 			history: !args["no-history"],
 			historyLimit: Number.parseInt(args["history-limit"], 10),