copilot-api-plus 1.2.58 → 1.3.1

package/dist/main.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { GITHUB_BASE_URL, GITHUB_CLIENT_ID, HTTPError, PATHS, accountManager, cacheModels, cacheVSCodeVersion, copilotBaseUrl, copilotHeaders, ensurePaths, findModel, forwardError, getAccountDispatcher, getCopilotUsage, initProxyFromEnv, isAccountProxied, isNullish, isProxyActive, notifyStreamEnd, notifyStreamStart, resetAccountConnections, resetConnections, rootCause, sleep, standardHeaders, state } from "./account-manager-BhLImNhx.js";
-import { clearGithubToken, getDeviceCode, pollAccessToken, refreshCopilotToken, setupCopilotToken, setupGitHubToken, stopCopilotTokenRefresh } from "./token-Bk6wTVD5.js";
+import { GITHUB_BASE_URL, GITHUB_CLIENT_ID, HTTPError, PATHS, accountManager, cacheModels, cacheVSCodeVersion, copilotBaseUrl, copilotHeaders, ensurePaths, findModel, forwardError, getAccountDispatcher, getCopilotUsage, initProxyFromEnv, isAccountProxied, isNullish, isProxyActive, notifyStreamEnd, notifyStreamStart, resetAccountConnections, resetConnections, rootCause, sleep, standardHeaders, state } from "./account-manager-C6u4XrO1.js";
+import { clearGithubToken, getDeviceCode, pollAccessToken, refreshCopilotToken, setupCopilotToken, setupGitHubToken, stopCopilotTokenRefresh } from "./token-DOQwaFAc.js";
 import { createRequire } from "node:module";
 import { defineCommand, runMain } from "citty";
 import consola from "consola";
@@ -1932,7 +1932,7 @@ function stripOpenAIReminders(payload) {
 * Copilot's slow models (e.g. claude-opus with thinking) can take up to
 * ~120s to start streaming, so we give a generous timeout for headers.
 */
-const FETCH_TIMEOUT_MS = 12e4;
+const FETCH_TIMEOUT_MS$1 = 12e4;
 /** Minimum interval (ms) between requests on the same account. */
 const MIN_SAME_ACCOUNT_INTERVAL_MS = 1e3;
 /** Random jitter range (ms) added when switching between accounts. */
@@ -1946,7 +1946,7 @@ let lastUsedAccountId;
 * arrive – once the body starts streaming, the timeout is cleared so that
 * long SSE responses are not interrupted.
 */
-async function fetchWithTimeout(url, init, { timeoutMs = FETCH_TIMEOUT_MS, accountId, accountProxy } = {}) {
+async function fetchWithTimeout$1(url, init, { timeoutMs = FETCH_TIMEOUT_MS$1, accountId, accountProxy } = {}) {
 	const controller = new AbortController();
 	const timer = setTimeout(() => controller.abort(), timeoutMs);
 	try {
@@ -1976,8 +1976,8 @@ async function fetchWithTimeout(url, init, { timeoutMs = FETCH_TIMEOUT_MS, accou
 */
 async function fetchWithRetry(url, buildInit, { accountId, accountProxy } = {}) {
 	try {
-		return await fetchWithTimeout(url, buildInit(), {
-			timeoutMs: FETCH_TIMEOUT_MS,
+		return await fetchWithTimeout$1(url, buildInit(), {
+			timeoutMs: FETCH_TIMEOUT_MS$1,
 			accountId,
 			accountProxy
 		});
@@ -2241,9 +2241,9 @@ async function retryWithModifiedPayload(payload, releaseSlot) {
 * Dispatch request to either single-account or multi-account path.
 */
 function dispatchRequest(payload) {
-	return state.multiAccountEnabled && accountManager.hasAccounts() ? createWithMultiAccount(payload) : createWithSingleAccount(payload);
+	return state.multiAccountEnabled && accountManager.hasAccounts() ? createWithMultiAccount$1(payload) : createWithSingleAccount$1(payload);
 }
-async function createWithSingleAccount(payload) {
+async function createWithSingleAccount$1(payload) {
 	if (!state.copilotToken) throw new Error("Copilot token not found");
 	const enableVision = payload.messages.some((msg) => typeof msg.content !== "string" && msg.content?.some((part) => part.type === "image_url"));
 	const isAgentCall = payload.messages.some((msg) => ["assistant", "tool"].includes(msg.role));
@@ -2270,7 +2270,7 @@ async function createWithSingleAccount(payload) {
 		consola.warn("Copilot token expired, refreshing and retrying...");
 		try {
 			await refreshCopilotToken();
-			response = await fetchWithTimeout(url, {
+			response = await fetchWithTimeout$1(url, {
 				method: "POST",
 				headers: buildHeaders(),
 				body: bodyString
@@ -2422,7 +2422,7 @@ function recordBreakerFailure(reason) {
 		consola.warn(`Circuit breaker OPEN for ${CB_OPEN_MS / 1e3}s after ${breaker.failures} consecutive failures (last: ${reason})`);
 	}
 }
-async function createWithMultiAccount(payload) {
+async function createWithMultiAccount$1(payload) {
 	const remaining = breakerOpenRemainingMs();
 	if (remaining > 0) throw new HTTPError("Upstream temporarily unavailable", new Response(JSON.stringify({ error: {
 		type: "service_unavailable",
@@ -3157,6 +3157,448 @@ async function handleCountTokens(c) {
 	}
 }
 
+//#endregion
+//#region src/lib/anthropic-sanitizer.ts
+/** Upstream message that triggers the assistant-thinking-strip retry. */
+const INVALID_THINKING_SIGNATURE_PATTERN = /invalid [`'"]?signature[`'"]? in [`'"]?thinking[`'"]? block/i;
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Strip fields the Copilot backend rejects.
+*
+* Mutates the payload in place.
+*/
+function sanitizeForCopilotBackend(payload) {
+	const extended = payload;
+	if ("context_management" in extended) {
+		consola.debug("Stripping context_management (unsupported by Copilot backend)");
+		delete extended.context_management;
+	}
+	sanitizeOutputConfigFormat(extended.output_config?.format);
+}
+function sanitizeOutputConfigFormat(format) {
+	if (!isRecord(format) || format.type !== "json_schema") return;
+	const nested = isRecord(format.json_schema) ? format.json_schema : void 0;
+	const hasFlat = isRecord(format.schema);
+	const hasNested = isRecord(nested?.schema);
+	if (!hasFlat && hasNested) format.schema = nested.schema;
+	if ("json_schema" in format) {
+		consola.debug("Flattening output_config.format.json_schema → format.schema");
+		delete format.json_schema;
+	}
+	if ("name" in format) {
+		consola.debug("Stripping output_config.format.name (Copilot reject)");
+		delete format.name;
+	}
+	if ("strict" in format) {
+		consola.debug("Stripping output_config.format.strict (Copilot reject)");
+		delete format.strict;
+	}
+}
+/**
+* Adaptive thinking has a slightly different shape than enabled thinking;
+* Copilot rejects `budget_tokens_max`. Mutates in place.
+*/
+function normalizeAdaptiveThinkingForCopilot(payload) {
+	const thinking = payload.thinking;
+	if (!isRecord(thinking) || thinking.type !== "adaptive") return;
+	if ("budget_tokens_max" in thinking) {
+		consola.debug("Stripping budget_tokens_max from adaptive thinking (Copilot reject)");
+		delete thinking.budget_tokens_max;
+	}
+}
+/**
+* If the client did not specify a `thinking` field, inject the maximum
+* thinking budget the model supports — pulled from Copilot's `/models`
+* capabilities. Mutates in place.
+*
+*   - Models with `adaptive_thinking: true` (claude-opus-4.7,
+*     claude-sonnet-4.6) get `{ type: "adaptive" }` so the model
+*     decides depth dynamically — recommended by Anthropic for
+*     these models.
+*   - Other thinking-capable models get
+*     `{ type: "enabled", budget_tokens: max_thinking_budget }`.
+*   - Models without thinking capability are left untouched.
+*
+* Skipped if the client already specified `thinking` (any value) — we
+* always defer to explicit client intent.
+*/
+function injectMaxThinkingBudget(payload) {
+	if (payload.thinking !== void 0) return;
+	const supports = findModel(payload.model)?.capabilities.supports;
+	if (!supports) return;
+	const maxBudget = supports.max_thinking_budget;
+	if (!maxBudget || maxBudget <= 0) return;
+	if (supports.adaptive_thinking === true) {
+		payload.thinking = { type: "adaptive" };
+		consola.debug(`Injected adaptive thinking for ${payload.model} (no client preference)`);
+		return;
+	}
+	payload.thinking = {
+		type: "enabled",
+		budget_tokens: maxBudget
+	};
+	consola.debug(`Injected enabled thinking budget=${maxBudget} for ${payload.model} (no client preference)`);
+}
+/**
+* Remove all `thinking` and `redacted_thinking` blocks from assistant
+* messages, and drop any assistant turns left empty as a result.
+*
+* Pure — returns a new payload, never mutates the input.
+*/
+function stripAssistantThinkingBlocks(payload) {
+	let strippedBlocks = 0;
+	let droppedAssistantMessages = 0;
+	const messages = payload.messages.flatMap((message) => {
+		if (message.role !== "assistant" || !Array.isArray(message.content)) return [message];
+		const content = message.content.filter((block) => {
+			const shouldStrip = block.type === "thinking" || block.type === "redacted_thinking";
+			if (shouldStrip) strippedBlocks += 1;
+			return !shouldStrip;
+		});
+		if (content.length === message.content.length) return [message];
+		if (content.length === 0) {
+			droppedAssistantMessages += 1;
+			return [];
+		}
+		return [{
+			...message,
+			content
+		}];
+	});
+	if (strippedBlocks === 0) return {
+		payload,
+		stripped: false,
+		strippedBlocks: 0,
+		droppedAssistantMessages: 0
+	};
+	return {
+		payload: {
+			...payload,
+			messages
+		},
+		stripped: true,
+		strippedBlocks,
+		droppedAssistantMessages
+	};
+}
+/** Detect the upstream "invalid thinking signature" 400 to trigger retry. */
+async function isInvalidThinkingSignatureError(error) {
+	if (!(error instanceof HTTPError) || error.response.status !== 400) return false;
+	const message = await readUpstreamErrorMessage(error.response);
+	return typeof message === "string" && INVALID_THINKING_SIGNATURE_PATTERN.test(message);
+}
+async function readUpstreamErrorMessage(response) {
+	let text;
+	try {
+		text = await response.clone().text();
+	} catch {
+		return;
+	}
+	if (!text) return void 0;
+	try {
+		return extractErrorMessage(JSON.parse(text)) ?? text;
+	} catch {
+		return text;
+	}
+}
+function extractErrorMessage(payload) {
+	if (!isRecord(payload)) return void 0;
+	if (typeof payload.message === "string") return payload.message;
+	const errorField = payload.error;
+	if (isRecord(errorField) && typeof errorField.message === "string") return errorField.message;
+}
+function overrideAnthropicResponseModel(response, requestedModel) {
+	return {
+		...response,
+		model: requestedModel
+	};
+}
+/**
+* Override the `model` field in a `message_start` SSE event payload.
+* Returns the original JSON string if the event is not a message_start
+* or cannot be parsed.
+*/
+function overrideMessageStartEventModel(rawData, requestedModel) {
+	try {
+		const parsed = JSON.parse(rawData);
+		if (parsed.type !== "message_start" || !parsed.message) return rawData;
+		parsed.message.model = requestedModel;
+		return JSON.stringify(parsed);
+	} catch {
+		return rawData;
+	}
+}
+
+//#endregion
+//#region src/lib/route-resolver.ts
+/**
+* Heuristic fallback when the model has no `supported_endpoints` field
+* (e.g. older Copilot deployments or a stripped models list). We only
+* use this when the wire-level capability is missing — never to override
+* an explicitly-advertised capability.
+*
+* Anthropic-published Claude models all natively support /v1/messages on
+* the Copilot backend at the time of writing. Non-Claude models do not.
+*/
+function looksLikeClaudeModel(model) {
+	return /^claude-/i.test(model);
+}
+/** Per-process cache of the routing decision keyed by model id. */
+const routeCache = /* @__PURE__ */ new Map();
+/**
+* Endpoint identifiers that mean "native Anthropic /v1/messages".
+*
+* Copilot's `/models` response uses the literal `/v1/messages` path,
+* but jer-y/copilot-proxy and earlier Copilot betas used the symbolic
+* name `anthropic-messages`. Accept both so we are forward- and
+* backward-compatible with whichever wire format Copilot returns.
+*/
+const NATIVE_ANTHROPIC_ENDPOINT_IDS = new Set(["/v1/messages", "anthropic-messages"]);
+/**
+* Resolve the upstream route for an Anthropic /v1/messages payload.
+*
+* Order of precedence:
+*   1. User force-disabled native passthrough — always translate.
+*   2. Model advertises a native Anthropic endpoint → native.
+*   3. Model advertises supported_endpoints WITHOUT a native one → translate.
+*   4. Capability missing → fall back to name heuristic (claude-* → native).
+*/
+function resolveAnthropicRoute(model) {
+	if (state.disableAnthropicPassthrough) return "translate-openai";
+	const cached = routeCache.get(model);
+	if (cached) return cached;
+	const decision = decideRoute(model);
+	routeCache.set(model, decision);
+	return decision;
+}
+function decideRoute(model) {
+	const endpoints = findModel(model)?.supported_endpoints;
+	if (Array.isArray(endpoints) && endpoints.length > 0) return endpoints.some((ep) => NATIVE_ANTHROPIC_ENDPOINT_IDS.has(ep)) ? "native-anthropic" : "translate-openai";
+	return looksLikeClaudeModel(model) ? "native-anthropic" : "translate-openai";
+}
+
+//#endregion
+//#region src/services/copilot/create-anthropic-messages.ts
+const FETCH_TIMEOUT_MS = 12e4;
+async function fetchWithTimeout(url, init, { timeoutMs = FETCH_TIMEOUT_MS, accountId, accountProxy, externalSignal } = {}) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+	const onExternalAbort = () => controller.abort();
+	if (externalSignal) if (externalSignal.aborted) controller.abort();
+	else externalSignal.addEventListener("abort", onExternalAbort, { once: true });
+	try {
+		const fetchOptions = {
+			...init,
+			signal: controller.signal
+		};
+		if (accountId) fetchOptions.dispatcher = getAccountDispatcher(accountId, accountProxy);
+		return await fetch(url, fetchOptions);
+	} catch (error) {
+		if (error instanceof DOMException && error.name === "AbortError") throw new Error(`Request timed out after ${timeoutMs}ms`);
+		throw error;
+	} finally {
+		clearTimeout(timer);
+		if (externalSignal) externalSignal.removeEventListener("abort", onExternalAbort);
+	}
+}
+function messageContainsVisionInput(message) {
+	if (message.role !== "user" || !Array.isArray(message.content)) return false;
+	return message.content.some((block) => block.type === "image" || block.type === "tool_result" && toolResultContainsImage(block));
+}
+function toolResultContainsImage(block) {
+	if (!Array.isArray(block.content)) return false;
+	return block.content.some((contentBlock) => contentBlock.type === "image");
+}
+function messageContinuesAgentLoop(message) {
+	if (message.role === "assistant") return true;
+	if (!Array.isArray(message.content)) return false;
+	return message.content.some((block) => block.type === "tool_result");
+}
+function buildAnthropicHeaders(payload, source, options$1) {
+	const enableVision = payload.messages.some((m) => messageContainsVisionInput(m));
+	const isAgentCall = payload.messages.some((m) => messageContinuesAgentLoop(m));
+	return {
+		...copilotHeaders(source, enableVision),
+		"X-Initiator": isAgentCall ? "agent" : "user",
+		...options$1?.anthropicBeta ? { "anthropic-beta": options$1.anthropicBeta } : {}
+	};
+}
+async function createAnthropicMessages(payload, options$1) {
+	injectMaxThinkingBudget(payload);
+	sanitizeForCopilotBackend(payload);
+	normalizeAdaptiveThinkingForCopilot(payload);
+	try {
+		return await dispatchAnthropicRequest(payload, options$1);
+	} catch (error) {
+		if (!await isInvalidThinkingSignatureError(error)) throw error;
+		const stripped = stripAssistantThinkingBlocks(payload);
+		if (!stripped.stripped) throw error;
+		const droppedSuffix = stripped.droppedAssistantMessages > 0 ? ` and dropping ${stripped.droppedAssistantMessages} thinking-only assistant turn(s)` : "";
+		consola.warn(`Native /v1/messages signature retry: stripped ${stripped.strippedBlocks} thinking block(s)${droppedSuffix}`);
+		return await dispatchAnthropicRequest(stripped.payload, options$1);
+	}
+}
+async function dispatchAnthropicRequest(payload, options$1) {
+	if (state.multiAccountEnabled && accountManager.hasAccounts()) return createWithMultiAccount(payload, options$1);
+	return createWithSingleAccount(payload, options$1);
+}
+async function createWithSingleAccount(payload, options$1) {
+	if (!state.copilotToken) throw new Error("Copilot token not found");
+	const url = `${copilotBaseUrl(state)}/v1/messages`;
+	const buildHeaders = () => buildAnthropicHeaders(payload, state, options$1);
+	const bodyString = JSON.stringify(payload);
+	consola.debug("Sending request to Copilot (native Anthropic):", {
+		model: payload.model,
+		endpoint: url,
+		stream: payload.stream
+	});
+	let response = await fetchWithTimeout(url, {
+		method: "POST",
+		headers: buildHeaders(),
+		body: bodyString,
+		signal: options$1?.signal
+	});
+	if (response.status === 401) {
+		consola.warn("Copilot token expired, refreshing and retrying...");
+		try {
+			await refreshCopilotToken();
+			response = await fetchWithTimeout(url, {
+				method: "POST",
+				headers: buildHeaders(),
+				body: bodyString,
+				signal: options$1?.signal
+			});
+		} catch (refreshError) {
+			consola.warn(`Failed to refresh token: ${rootCause(refreshError)}`);
+			consola.debug("Failed to refresh token:", refreshError);
+		}
+	}
+	if (!response.ok) await throwUpstreamError(response);
+	if (payload.stream) {
+		const gen = events(response);
+		gen.__accountInfo = { apiBaseUrl: copilotBaseUrl(state) };
+		return gen;
+	}
+	return await response.json();
+}
+function buildTokenSource(account) {
+	return {
+		copilotToken: account.copilotToken,
+		copilotApiEndpoint: account.copilotApiEndpoint,
+		accountType: account.accountType,
+		githubToken: account.githubToken,
+		vsCodeVersion: state.vsCodeVersion,
+		machineId: account.machineId,
+		sessionId: account.sessionId,
+		proxy: account.proxy
+	};
+}
+function tagStreamWithAccount(result, account, source) {
+	if (typeof result === "object" && Symbol.asyncIterator in result) result.__accountInfo = {
+		accountId: account.id,
+		accountProxy: account.proxy,
+		apiBaseUrl: copilotBaseUrl(source)
+	};
+	return result;
+}
+async function handleMultiAccount401(ctx, account) {
+	try {
+		await accountManager.refreshAccountToken(account);
+		ctx.source.copilotToken = account.copilotToken;
+		const retried = await doFetchAnthropic(ctx);
+		accountManager.markAccountSuccess(account.id);
+		return tagStreamWithAccount(retried, account, ctx.source);
+	} catch (refreshError) {
+		accountManager.markAccountStatus(account.id, "banned", "GitHub token invalid");
+		throw refreshError;
+	}
+}
+async function createWithMultiAccount(payload, options$1) {
+	const triedAccountIds = /* @__PURE__ */ new Set();
+	let lastError;
+	let networkRetried = false;
+	for (let attempt = 0; attempt < 3; attempt++) {
+		const account = accountManager.getActiveAccount();
+		if (!account || triedAccountIds.has(account.id)) break;
+		triedAccountIds.add(account.id);
+		if (!account.copilotToken) {
+			consola.debug(`Account ${account.label} has no copilot token, refreshing...`);
+			await accountManager.refreshAccountToken(account);
+			if (!account.copilotToken) {
+				accountManager.markAccountStatus(account.id, "error", "No copilot token");
+				continue;
+			}
+		}
+		const ctx = {
+			payload,
+			source: buildTokenSource(account),
+			accountId: account.id,
+			options: options$1
+		};
+		try {
+			const result = await doFetchAnthropic(ctx);
+			account.lastRequestAt = Date.now();
+			accountManager.markAccountSuccess(account.id);
+			return tagStreamWithAccount(result, account, ctx.source);
+		} catch (error) {
+			lastError = error;
+			if (error instanceof HTTPError) {
+				if (error.response.status === 401) return handleMultiAccount401(ctx, account);
+				if (error.response.status >= 400 && error.response.status < 500) throw error;
+				consola.warn(`Account ${account.label}: 5xx from /v1/messages, trying next account`);
+				continue;
+			}
+			const errMsg = error.message || String(error);
+			if (!networkRetried) {
+				networkRetried = true;
+				consola.warn(`Account ${account.label}: network error on /v1/messages, resetting pool and retrying once: ${errMsg}`);
+				resetAccountConnections(account.id);
+				triedAccountIds.delete(account.id);
+				continue;
+			}
+			consola.warn(`Account ${account.label}: network error after retry on /v1/messages (giving up): ${errMsg}`);
+			throw error;
+		}
+	}
+	if (lastError) throw lastError instanceof Error ? lastError : /* @__PURE__ */ new Error("Network request failed");
+	throw new Error("No available accounts");
+}
+async function doFetchAnthropic(ctx) {
+	const { payload, source, accountId, options: options$1 } = ctx;
+	const url = `${copilotBaseUrl(source)}/v1/messages`;
+	const bodyString = JSON.stringify(payload);
+	consola.debug("Sending request to Copilot (multi-account, native Anthropic):", {
+		model: payload.model,
+		endpoint: url,
+		stream: payload.stream
+	});
+	const response = await fetchWithTimeout(url, {
+		method: "POST",
+		headers: buildAnthropicHeaders(payload, source, options$1),
+		body: bodyString,
+		signal: options$1?.signal
+	}, {
+		accountId,
+		accountProxy: source.proxy,
+		externalSignal: options$1?.signal
+	});
+	if (!response.ok) await throwUpstreamError(response);
+	if (payload.stream) return events(response);
+	return await response.json();
+}
+async function throwUpstreamError(response) {
+	const errorBody = await response.text();
+	if (response.status === 400) consola.debug(`/v1/messages 400: ${errorBody}`);
+	else consola.error("Failed native Anthropic request", {
+		status: response.status,
+		statusText: response.statusText,
+		body: errorBody
+	});
+	throw new HTTPError(`Failed to call /v1/messages: ${response.status} ${errorBody}`, response);
+}
+
 //#endregion
 //#region src/routes/messages/stream-translation.ts
 function isToolBlockOpen(state$1) {
@@ -3445,8 +3887,146 @@ async function handleCompletion(c) {
 		messages_count: anthropicPayload.messages.length,
 		max_tokens: anthropicPayload.max_tokens
 	});
-	const openAIPayload = translateToOpenAI(stripSystemReminders(anthropicPayload));
 	if (state.manualApprove) await awaitApproval();
+	const route = resolveAnthropicRoute(anthropicPayload.model);
+	consola.debug(`Anthropic route resolved: ${route}`);
+	if (route === "native-anthropic") return handleNativePassthrough(c, anthropicPayload);
+	return handleTranslatedCompletion(c, anthropicPayload);
+}
+async function handleNativePassthrough(c, anthropicPayload) {
+	const anthropicBeta = c.req.header("anthropic-beta");
+	let result;
+	try {
+		result = await createAnthropicMessages(stripSystemReminders(anthropicPayload), { anthropicBeta });
+	} catch (error) {
+		consola.warn(`Native /v1/messages failed: ${error.message || String(error)}`);
+		throw error;
+	}
+	if (!anthropicPayload.stream) return c.json(overrideAnthropicResponseModel(result, anthropicPayload.model));
+	const stream = result;
+	const accountInfo = stream.__accountInfo;
+	const proxied = accountInfo ? isAccountProxied(accountInfo.accountProxy) : isProxyActive();
+	const heartbeatMs = proxied ? HEARTBEAT_PROXIED_MS : HEARTBEAT_DIRECT_MS;
+	const upstreamTimeoutMs = proxied ? UPSTREAM_TIMEOUT_PROXIED_MS : UPSTREAM_TIMEOUT_DIRECT_MS;
+	consola.debug(`Native SSE config: proxied=${proxied}, heartbeat=${heartbeatMs / 1e3}s, timeout=${upstreamTimeoutMs / 1e3}s`);
+	return streamSSE(c, async (sse) => {
+		const abortController = new AbortController();
+		sse.onAbort(() => abortController.abort());
+		try {
+			await consumeNativeStreamWithHeartbeat(stream, sse, {
+				heartbeatMs,
+				upstreamTimeoutMs,
+				abortSignal: abortController.signal,
+				requestedModel: anthropicPayload.model
+			});
+		} catch (error) {
+			if (!abortController.signal.aborted) {
+				const message = error.message || String(error);
+				consola.warn(`Native SSE stream interrupted: ${message}`);
+				resetConnections();
+				await sendErrorEvent(sse);
+			}
+		}
+	});
+}
+/** Resolve the Anthropic event type for a raw SSE frame. */
+function resolveAnthropicEventType(rawEvent) {
+	if (rawEvent.event) return rawEvent.event;
+	if (!rawEvent.data) return void 0;
+	try {
+		return JSON.parse(rawEvent.data).type;
+	} catch {
+		return;
+	}
+}
+async function handleNativeHeartbeatTick(stream, silenceMs, upstreamTimeoutMs) {
+	if (silenceMs >= upstreamTimeoutMs) {
+		consola.warn(`Upstream silent for ${Math.round(silenceMs / 1e3)}s (limit ${upstreamTimeoutMs / 1e3}s), closing native stream`);
+		resetConnections();
+		await sendErrorEvent(stream);
+		return { action: "break" };
+	}
+	await stream.writeSSE({
+		event: "ping",
+		data: "{\"type\":\"ping\"}"
+	});
+	return { action: "continue" };
+}
+/** Forward one native event; returns true if it was `message_stop`. */
+async function forwardNativeEvent(stream, rawEvent, requestedModel) {
+	if (rawEvent.data === "[DONE]") return {
+		forwarded: false,
+		isMessageStop: false
+	};
+	if (!rawEvent.data) return {
+		forwarded: true,
+		isMessageStop: false
+	};
+	const eventType = resolveAnthropicEventType(rawEvent);
+	if (!eventType) {
+		consola.debug("Skipping native SSE chunk with no resolvable type");
+		return {
+			forwarded: true,
+			isMessageStop: false
+		};
+	}
+	const dataToSend = eventType === "message_start" && requestedModel ? overrideMessageStartEventModel(rawEvent.data, requestedModel) : rawEvent.data;
+	await stream.writeSSE({
+		event: eventType,
+		data: dataToSend
+	});
+	return {
+		forwarded: true,
+		isMessageStop: eventType === "message_stop"
+	};
+}
+/**
+* Consume an upstream Anthropic SSE generator and forward events untouched.
+* Heartbeat and upstream-timeout logic mirrors the translated path.
+*/
+async function consumeNativeStreamWithHeartbeat(response, stream, opts) {
+	const { heartbeatMs, upstreamTimeoutMs, abortSignal, requestedModel } = opts;
+	const iter = response[Symbol.asyncIterator]();
+	let pendingNext = iter.next();
+	let lastDataAt = Date.now();
+	let sawMessageStop = false;
+	try {
+		while (true) {
+			if (abortSignal?.aborted) {
+				consola.debug("Client disconnected, stopping native SSE consumption");
+				break;
+			}
+			const raceResult = await Promise.race([pendingNext.then((r) => ({
+				kind: "data",
+				result: r
+			})), heartbeatDelay(heartbeatMs)]);
+			if (raceResult === HEARTBEAT) {
+				if ((await handleNativeHeartbeatTick(stream, Date.now() - lastDataAt, upstreamTimeoutMs)).action === "break") break;
+				continue;
+			}
+			const { result: iterResult } = raceResult;
+			if (iterResult.done) break;
+			lastDataAt = Date.now();
+			pendingNext = iter.next();
+			const rawEvent = iterResult.value;
+			const result = await forwardNativeEvent(stream, rawEvent, requestedModel);
+			if (!result.forwarded) break;
+			if (result.isMessageStop) sawMessageStop = true;
+		}
+		if (!sawMessageStop && !abortSignal?.aborted) try {
+			await stream.writeSSE({
+				event: "message_stop",
+				data: "{\"type\":\"message_stop\"}"
+			});
+		} catch {}
+	} finally {
+		try {
+			await iter.return(void 0);
+		} catch {}
+	}
+}
+async function handleTranslatedCompletion(c, anthropicPayload) {
+	const openAIPayload = translateToOpenAI(stripSystemReminders(anthropicPayload));
 	const response = await createChatCompletions(openAIPayload);
 	if (isNonStreaming(response)) return c.json(translateToAnthropic(response));
 	const accountInfo = response.__accountInfo;
@@ -3680,7 +4260,7 @@ async function validateGitHubToken(token) {
 	state.githubToken = token;
 	consola.info("Using provided GitHub token");
 	try {
-		const { getGitHubUser } = await import("./get-user-gLE45Z2B.js");
+		const { getGitHubUser } = await import("./get-user-Brre_x1N.js");
 		const user = await getGitHubUser();
 		consola.info(`Logged in as ${user.login}`);
 	} catch (error) {
@@ -3719,6 +4299,8 @@ async function runServer(options$1) {
 	state.rateLimitWait = options$1.rateLimitWait;
 	state.showToken = options$1.showToken;
 	state.apiKeys = options$1.apiKeys;
+	state.disableAnthropicPassthrough = options$1.disableAnthropicPassthrough;
+	if (options$1.disableAnthropicPassthrough) consola.info("Native Anthropic passthrough DISABLED — all /v1/messages requests will translate via /chat/completions");
 	if (state.apiKeys && state.apiKeys.length > 0) consola.info(`API key authentication enabled with ${state.apiKeys.length} key(s)`);
 	await ensurePaths();
 	await cacheVSCodeVersion();
@@ -3731,10 +4313,10 @@ async function runServer(options$1) {
 	try {
 		await setupCopilotToken();
 	} catch (error) {
-		const { HTTPError: HTTPError$1 } = await import("./error-BUk1uczJ.js");
+		const { HTTPError: HTTPError$1 } = await import("./error-DO0tIuq0.js");
 		if (error instanceof HTTPError$1 && error.response.status === 401) {
 			consola.error("Failed to get Copilot token - GitHub token may be invalid or Copilot access revoked");
-			const { clearGithubToken: clearGithubToken$1 } = await import("./token-SOdr_xJ0.js");
+			const { clearGithubToken: clearGithubToken$1 } = await import("./token-Dv2Iyk1S.js");
 			await clearGithubToken$1();
 			consola.info("Please restart to re-authenticate");
 		}
@@ -3817,6 +4399,11 @@ const start = defineCommand({
 		"api-key": {
 			type: "string",
 			description: "API keys for authentication"
+		},
+		"disable-anthropic-passthrough": {
+			type: "boolean",
+			default: false,
+			description: "Force translate all /v1/messages requests via /chat/completions (disable native Copilot Anthropic endpoint)"
 		}
 	},
 	run({ args }) {
@@ -3836,7 +4423,8 @@ const start = defineCommand({
 			claudeCode: args["claude-code"],
 			showToken: args["show-token"],
 			proxyEnv: args["proxy-env"],
-			apiKeys
+			apiKeys,
+			disableAnthropicPassthrough: args["disable-anthropic-passthrough"]
 		});
 	}
 });