@dianshuv/copilot-api 0.7.9 → 0.8.0

package/dist/main.mjs

@@ -243,7 +243,7 @@ function compressToolResultContent(content) {
 	return `${start}\n\n[... ${(content.length - COMPRESSED_SUMMARY_LENGTH).toLocaleString()} characters omitted for brevity ...]\n\n${end}`;
 }
 function calculateLimits(model, config, defaultContextWindow) {
-	const rawTokenLimit = getEffectiveTokenLimit(model.id) ?? model.capabilities?.limits?.max_context_window_tokens ?? model.capabilities?.limits?.max_prompt_tokens ?? defaultContextWindow;
+	const rawTokenLimit = getEffectiveTokenLimit(config.tokenLimitCacheKeyOverride ?? model.id) ?? config.contextWindowOverride ?? model.capabilities?.limits?.max_context_window_tokens ?? model.capabilities?.limits?.max_prompt_tokens ?? defaultContextWindow;
 	return {
 		tokenLimit: Math.floor(rawTokenLimit * (1 - config.safetyMarginPercent / 100)),
 		byteLimit: getEffectiveByteLimitBytes()
@@ -478,10 +478,128 @@ async function getGitHubUser() {
 	return await response.json();
 }
 
+//#endregion
+//#region src/lib/fetch-retry.ts
+const RETRYABLE_CAUSE_CODES = new Set([
+	"UND_ERR_SOCKET",
+	"ECONNRESET",
+	"ENOTFOUND",
+	"UND_ERR_CONNECT_TIMEOUT"
+]);
+const RETRY_DELAYS_MS = [200, 600];
+function getCauseCode(error) {
+	if (!(error instanceof Error)) return void 0;
+	const cause = error.cause;
+	if (typeof cause !== "object" || cause === null) return void 0;
+	const code = cause.code;
+	return typeof code === "string" ? code : void 0;
+}
+function isRetryable(error) {
+	const code = getCauseCode(error);
+	return code !== void 0 && RETRYABLE_CAUSE_CODES.has(code);
+}
+const RETRY_ATTEMPTS_KEY = "__copilotRetryAttempts";
+const RETRY_AUTH_REFRESHED_KEY = "__copilotRetryAuthRefreshed";
+/**
+* Read retry metadata recorded on an error or response by fetchWithRetry.
+* Returns attempts=1 (no retry) if the value is missing or malformed.
+*/
+function getRetryAttempts(target) {
+	if (typeof target !== "object" || target === null) return {
+		attempts: 1,
+		authRefreshed: false
+	};
+	const meta = target;
+	return {
+		attempts: typeof meta[RETRY_ATTEMPTS_KEY] === "number" ? meta[RETRY_ATTEMPTS_KEY] : 1,
+		authRefreshed: meta[RETRY_AUTH_REFRESHED_KEY] === true
+	};
+}
+async function fetchWithRetry(input, init, options) {
+	let currentInit = init;
+	let authRefreshed = false;
+	let networkAttempts = 0;
+	for (let attempt = 0; attempt <= RETRY_DELAYS_MS.length; attempt++) try {
+		networkAttempts++;
+		const response = await fetch(input, currentInit);
+		if (response.status === 401 && !authRefreshed && options?.onUnauthorized) {
+			const refreshed = await tryRefreshAuth(options.onUnauthorized);
+			if (refreshed) {
+				await response.body?.cancel().catch(() => {});
+				consola.warn("Got 401 from upstream; refreshed token and retrying");
+				currentInit = refreshed;
+				authRefreshed = true;
+				attempt--;
+				continue;
+			}
+		}
+		annotateRetryMeta(response, networkAttempts, authRefreshed);
+		return response;
+	} catch (error) {
+		if (attempt === RETRY_DELAYS_MS.length || !isRetryable(error)) {
+			annotateRetryMeta(error, networkAttempts, authRefreshed);
+			throw error;
+		}
+		const delay = RETRY_DELAYS_MS[attempt];
+		consola.warn(`Upstream network error (${getCauseCode(error)}); retry ${attempt + 1}/${RETRY_DELAYS_MS.length} in ${delay}ms`);
+		await new Promise((resolve) => setTimeout(resolve, delay));
+	}
+	throw new Error("fetchWithRetry exhausted attempts without resolution");
+}
+function annotateRetryMeta(target, attempts, authRefreshed) {
+	if (typeof target !== "object" || target === null) return;
+	try {
+		const meta = target;
+		meta[RETRY_ATTEMPTS_KEY] = attempts;
+		meta[RETRY_AUTH_REFRESHED_KEY] = authRefreshed;
+	} catch {}
+}
+async function tryRefreshAuth(onUnauthorized) {
+	try {
+		return await onUnauthorized();
+	} catch (error) {
+		consola.warn("onUnauthorized callback failed:", error instanceof Error ? error.message : error);
+		return null;
+	}
+}
+/**
+* Build an onUnauthorized callback that refreshes the Copilot token and
+* returns a new RequestInit with an updated Authorization header.
+*/
+function makeCopilotAuthRetry(refreshToken, init) {
+	return async () => {
+		const newToken = await refreshToken();
+		if (!newToken) return null;
+		const headers = new Headers(init.headers);
+		headers.set("Authorization", `Bearer ${newToken}`);
+		return {
+			...init,
+			headers
+		};
+	};
+}
+
+//#endregion
+//#region src/services/copilot/copilot-fetch.ts
+/**
+* Single transport seam for all upstream Copilot API calls.
+*
+* Wraps every request with:
+* - Network-error retry (UND_ERR_SOCKET, ECONNRESET, ENOTFOUND, connect timeouts)
+* - 401 → forceRefreshCopilotToken → retry once with the new bearer token
+*
+* Callers supply the path (e.g. "/chat/completions") and the usual RequestInit.
+* The host prefix and resilience wiring are applied here so every endpoint
+* gets the same treatment and adding a new endpoint is one call site.
+*/
+function copilotFetch(path, init) {
+	return fetchWithRetry(`${copilotBaseUrl(state)}${path}`, init, { onUnauthorized: makeCopilotAuthRetry(forceRefreshCopilotToken, init) });
+}
+
 //#endregion
 //#region src/services/copilot/get-models.ts
 const getModels = async () => {
-	const response = await fetch(`${copilotBaseUrl(state)}/models`, { headers: copilotHeaders(state) });
+	const response = await copilotFetch("/models", { headers: copilotHeaders(state) });
 	if (!response.ok) throw await HTTPError.fromResponse("Failed to get models", response);
 	return await response.json();
 };
@@ -586,6 +704,23 @@ async function refreshCopilotTokenWithRetry(maxRetries = 3) {
 	return null;
 }
 /**
+* Force-refresh the Copilot token on demand (e.g. after a 401 response).
+* Updates state.copilotToken on success and returns the new token, or null
+* if refresh failed. Coalesces concurrent callers so multiple in-flight 401s
+* only trigger one refresh.
+*/
+let refreshInFlight = null;
+async function forceRefreshCopilotToken() {
+	if (refreshInFlight) return refreshInFlight;
+	refreshInFlight = refreshCopilotTokenWithRetry().then((token) => {
+		if (token) state.copilotToken = token;
+		return token;
+	}).finally(() => {
+		refreshInFlight = null;
+	});
+	return refreshInFlight;
+}
+/**
 * Clear any existing token refresh timer.
 * Call this before setting up a new timer or during cleanup.
 */
@@ -1213,7 +1348,7 @@ const patchClaude = defineCommand({
 
 //#endregion
 //#region package.json
-var version = "0.7.9";
+var version = "0.8.0";
 
 //#endregion
 //#region src/lib/adaptive-rate-limiter.ts
@@ -3260,9 +3395,66 @@ 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";
+/**
+* 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/services/copilot/create-chat-completions.ts
 const GPT_MODEL_PATTERN = /^gpt-/i;
+/** 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);
+}
 const createChatCompletions = async (payload, options) => {
 	if (!state.copilotToken) throw new Error("Copilot token not found");
 	const vendor = options?.resolvedModel?.vendor;
@@ -3288,14 +3480,19 @@ const createChatCompletions = async (payload, options) => {
 		}),
 		"X-Initiator": options?.initiator ?? (isAgentCall ? "agent" : "user")
 	};
-	const response = await fetch(`${copilotBaseUrl(state)}/chat/completions`, {
+	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, payload.model);
+		throw await HTTPError.fromResponse("Failed to create chat completions", response, options?.errorModelIdOverride ?? payload.model);
 	}
 	if (payload.stream) return events(response);
 	return await response.json();
@@ -3723,6 +3920,7 @@ function recordErrorResponse(ctx, model, error, endpoint, stream) {
 	}, Date.now() - ctx.startTime);
 	if (endpoint !== void 0) {
 		const metrics = extractErrorMetrics(error);
+		const { attempts } = getRetryAttempts(error);
 		captureRequest({
 			model,
 			inputTokens: 0,
@@ -3734,7 +3932,7 @@ function recordErrorResponse(ctx, model, error, endpoint, stream) {
 			...metrics,
 			errorPhase: stream ? "pre_stream" : "non_stream",
 			endpoint,
-			attempt: 1
+			attempt: attempts
 		});
 	}
 }
@@ -3829,7 +4027,7 @@ function isNonStreaming(response) {
 	return Object.hasOwn(response, "choices");
 }
 /** Build final payload with auto-truncate if needed */
-async function buildFinalPayload(payload, model) {
+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 {
@@ -3838,7 +4036,7 @@ async function buildFinalPayload(payload, model) {
 		};
 	}
 	try {
-		const check = await checkNeedsCompactionOpenAI(payload, model);
+		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,
@@ -3849,7 +4047,7 @@ async function buildFinalPayload(payload, model) {
 		else if (check.reason === "bytes") reasonText = "size";
 		else reasonText = "tokens";
 		consola.info(`Auto-truncate triggered: exceeds ${reasonText} limit`);
-		const truncateResult = await autoTruncateOpenAI(payload, model);
+		const truncateResult = await autoTruncateOpenAI(payload, model, autoTruncateConfig);
 		return {
 			finalPayload: truncateResult.payload,
 			truncateResult
@@ -4120,7 +4318,24 @@ async function handleStreamingResponse$1(opts) {
 			endpoint: "chat_completions"
 		});
 		failTracking(ctx.trackingId, error);
-		throw error;
+		try {
+			const markerChunk = {
+				id: `error-marker-${Date.now()}`,
+				object: "chat.completion.chunk",
+				created: Math.floor(Date.now() / 1e3),
+				model: acc.model || payload.model,
+				choices: [{
+					index: 0,
+					delta: { content: `\n\n[copilot-api: upstream stream terminated. Please retry.]` },
+					finish_reason: "length",
+					logprobs: null
+				}]
+			};
+			await stream.writeSSE({
+				data: JSON.stringify(markerChunk),
+				event: "message"
+			});
+		} catch {}
 	}
 }
 function parseStreamChunk(chunk, acc, checkRepetition) {
@@ -4223,7 +4438,7 @@ completionRoutes.post("/", async (c) => {
 //#region src/services/copilot/create-embeddings.ts
 const createEmbeddings = async (payload) => {
 	if (!state.copilotToken) throw new Error("Copilot token not found");
-	const response = await fetch(`${copilotBaseUrl(state)}/embeddings`, {
+	const response = await copilotFetch("/embeddings", {
 		method: "POST",
 		headers: copilotHeaders(state),
 		body: JSON.stringify(payload)
@@ -4665,6 +4880,16 @@ async function handleGeminiGenerate(c, model, isStream) {
 					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) {
@@ -6677,7 +6902,7 @@ function modelSupportsContextEditing(modelId) {
 }
 function modelSupportsToolSearch(modelId) {
 	const n = normalizeForMatching(modelId);
-	return n.includes("claude") && (n.includes("opus45") || n.includes("opus46") || n.includes("sonnet45") || n.includes("sonnet46"));
+	return n.includes("claude") && (n.includes("opus45") || n.includes("opus46") || n.includes("opus47") || n.includes("opus48") || n.includes("sonnet45") || n.includes("sonnet46"));
 }
 function isContextEditingEnabled(modelId) {
 	return modelSupportsContextEditing(modelId) && state.contextEditingMode !== "off";
@@ -6903,6 +7128,7 @@ async function createAnthropicMessages(payload, options) {
 	};
 	const betaHeaders = buildAnthropicBetaHeaders(filteredPayload.model, resolvedModel);
 	Object.assign(headers, betaHeaders);
+	if (options?.injectContext1mBeta) headers["anthropic-beta"] = appendContext1mBeta(headers["anthropic-beta"]);
 	if (isContextEditingEnabled(filteredPayload.model)) {
 		const hasThinking = filteredPayload.thinking?.type === "enabled";
 		const cm = buildContextManagement(state.contextEditingMode, hasThinking);
@@ -6912,7 +7138,7 @@ async function createAnthropicMessages(payload, options) {
 		}
 	}
 	consola.debug("Sending direct Anthropic request to Copilot /v1/messages");
-	const response = await fetch(`${copilotBaseUrl(state)}/v1/messages`, {
+	const response = await copilotFetch("/v1/messages", {
 		method: "POST",
 		headers,
 		body: JSON.stringify(filteredPayload)
@@ -6929,7 +7155,7 @@ async function createAnthropicMessages(payload, options) {
 			thinking: filteredPayload.thinking,
 			messageCount: filteredPayload.messages.length
 		});
-		throw await HTTPError.fromResponse("Failed to create Anthropic messages", response, filteredPayload.model);
+		throw await HTTPError.fromResponse("Failed to create Anthropic messages", response, options?.errorModelIdOverride ?? filteredPayload.model);
 	}
 	if (payload.stream) return events(response);
 	return await response.json();
@@ -6952,13 +7178,58 @@ function stripServerToolsFromPayload(tools) {
 	}
 	return result.length > 0 ? result : void 0;
 }
+/** Context window unlocked by the context-1m-2025-08-07 beta header. */
+const ONE_MILLION_CONTEXT_WINDOW_TOKENS = 1e6;
+/**
+* Convert a Claude model id from the client-facing dash convention to the
+* upstream Copilot dot convention. The two conventions co-exist because
+* Anthropic-style clients use dashes ("claude-opus-4-8") and Copilot lists
+* the same model with dots ("claude-opus-4.8"). Only the first dash inside
+* the version segment is converted (a model id like "claude-opus-4.8-1m"
+* already in dot form is returned unchanged).
+*/
+function dashToDotClaudeId(modelId) {
+	if (!modelId.startsWith("claude-")) return modelId;
+	return modelId.replace(/^(claude-[a-z]+-)(\d+)-(\d+)/, "$1$2.$3");
+}
+function resolveAnthropicModelForDirectPath(modelId) {
+	const exact = findModelById(modelId);
+	if (exact?.vendor === "Anthropic") return {
+		model: exact,
+		baseModelId: modelId,
+		oneMillionFallback: false,
+		effectiveContextWindowTokens: exact.capabilities?.limits?.max_context_window_tokens ?? 2e5
+	};
+	const dotted = dashToDotClaudeId(modelId);
+	if (dotted !== modelId) {
+		const dottedExact = findModelById(dotted);
+		if (dottedExact?.vendor === "Anthropic") return {
+			model: dottedExact,
+			baseModelId: dotted,
+			oneMillionFallback: false,
+			effectiveContextWindowTokens: dottedExact.capabilities?.limits?.max_context_window_tokens ?? 2e5
+		};
+	}
+	if (modelId.endsWith("-1m")) {
+		const baseId = modelId.slice(0, -3);
+		for (const candidateId of [baseId, dashToDotClaudeId(baseId)]) {
+			const base = findModelById(candidateId);
+			if (base?.vendor === "Anthropic") return {
+				model: base,
+				baseModelId: candidateId,
+				oneMillionFallback: true,
+				effectiveContextWindowTokens: ONE_MILLION_CONTEXT_WINDOW_TOKENS
+			};
+		}
+	}
+}
 /**
 * Check if a model supports direct Anthropic API.
 * Returns true if redirect is disabled (direct API is on) and the model is from Anthropic vendor.
 */
 function supportsDirectAnthropicApi(modelId) {
 	if (state.redirectAnthropic) return false;
-	return findModelById(modelId)?.vendor === "Anthropic";
+	return resolveAnthropicModelForDirectPath(modelId) !== void 0;
 }
 
 //#endregion
@@ -7197,18 +7468,42 @@ function findLatestModel(familyPrefix, fallback) {
 	const candidates = models.filter((m) => m.id.startsWith(familyPrefix));
 	if (candidates.length === 0) return fallback;
 	candidates.sort((a, b) => {
-		const versionA = extractVersion(a.id, familyPrefix);
-		return extractVersion(b.id, familyPrefix) - versionA;
+		const [aMajor, aMinor] = extractVersion(a.id, familyPrefix);
+		const [bMajor, bMinor] = extractVersion(b.id, familyPrefix);
+		if (aMajor !== bMajor) return bMajor - aMajor;
+		return bMinor - aMinor;
 	});
 	return candidates[0].id;
 }
 /**
-* Extract numeric version from model ID.
-* e.g., "claude-opus-4.5" with prefix "claude-opus" -> 4.5
+* Extract numeric [major, minor] version from a model id.
+*
+* Supports both naming conventions Anthropic/Copilot have used:
+*  - dot:  "claude-opus-4.5"  → [4, 5]
+*  - dash: "claude-opus-4-8"  → [4, 8]
+*  - dash double-digit: "claude-opus-4-10" → [4, 10]
+*
+* The dash form previously parsed as just the major via the regex
+* /^(\d+(?:\.\d+)?)/ (the dash stopped the match), which silently
+* downgraded dash-named candidates against any dot-named candidate in
+* findLatestModel. Parsing into a tuple also avoids the parseFloat
+* lossiness on double-digit minors ("4.10" → 4.1).
+*
+* Anything after the major/minor segment (date stamps, "-1m") is ignored.
+* The minor capture is bounded to 1-3 digits so that an 8-digit date suffix
+* directly after the major (e.g. "claude-opus-4-20250514") is NOT mistaken
+* for a minor version of 20_250_514 — without that bound, dated ids would
+* outrank legitimate dotted candidates like "claude-opus-4.8" in
+* findLatestModel's sort.
+*
+* Returns [0, 0] when no version can be extracted.
 */
 function extractVersion(modelId, prefix) {
-	const match = modelId.slice(prefix.length + 1).match(/^(\d+(?:\.\d+)?)/);
-	return match ? Number.parseFloat(match[1]) : 0;
+	const match = modelId.slice(prefix.length + 1).match(/^(\d+)(?:[.-](\d{1,3}))?/);
+	if (!match) return [0, 0];
+	const major = Number.parseInt(match[1], 10);
+	const rawMinor = match[2];
+	return [major, rawMinor === void 0 ? 0 : Number.parseInt(rawMinor, 10) || 0];
 }
 function translateModelName(model) {
 	const aliasMap = {
@@ -7222,6 +7517,8 @@ function translateModelName(model) {
 	}
 	if (/^claude-sonnet-4-5-\d+$/.test(model)) return "claude-sonnet-4.5";
 	if (/^claude-sonnet-4-\d+$/.test(model)) return "claude-sonnet-4";
+	if (model === "claude-opus-4-8-1m") return "claude-opus-4.8";
+	if (model === "claude-opus-4-8") return "claude-opus-4.8";
 	if (model === "claude-opus-4-7-1m") return "claude-opus-4.7-1m-internal";
 	if (/^claude-opus-4-7$/.test(model)) return "claude-opus-4.7";
 	if (model === "claude-opus-4-6-1m") return "claude-opus-4.6-1m";
@@ -7601,14 +7898,30 @@ function translateErrorToAnthropicErrorEvent(error) {
 */
 async function handleDirectAnthropicCompletion(c, anthropicPayload, ctx, initiatorOverride) {
 	consola.debug("Using direct Anthropic API path for model:", anthropicPayload.model);
-	const selectedModel = findModelById(anthropicPayload.model);
-	let effectivePayload = anthropicPayload;
+	const resolution = resolveAnthropicModelForDirectPath(anthropicPayload.model);
+	const selectedModel = resolution?.model;
+	const baseModelId = resolution?.baseModelId ?? anthropicPayload.model;
+	const needsContext1mBeta = resolution?.oneMillionFallback ?? false;
+	const originalModelId = anthropicPayload.model;
+	const resolvedPayload = resolution && baseModelId !== originalModelId ? {
+		...anthropicPayload,
+		model: baseModelId
+	} : anthropicPayload;
+	if (baseModelId !== originalModelId) {
+		consola.debug(`[Anthropic] Mapping model for upstream: ${originalModelId} → ${baseModelId}${needsContext1mBeta ? " (+context-1m beta)" : ""}`);
+		updateTrackerResolvedModel(ctx.trackingId, baseModelId);
+	}
+	const autoTruncateConfig = resolution && resolution.oneMillionFallback ? {
+		contextWindowOverride: resolution.effectiveContextWindowTokens,
+		tokenLimitCacheKeyOverride: originalModelId
+	} : {};
+	let effectivePayload = resolvedPayload;
 	let truncateResult;
 	if (state.autoTruncate && selectedModel) {
-		const check = await checkNeedsCompactionAnthropic(anthropicPayload, selectedModel);
+		const check = await checkNeedsCompactionAnthropic(resolvedPayload, selectedModel, autoTruncateConfig);
 		consola.debug(`[Anthropic] 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) try {
-			truncateResult = await autoTruncateAnthropic(anthropicPayload, selectedModel);
+			truncateResult = await autoTruncateAnthropic(resolvedPayload, selectedModel, autoTruncateConfig);
 			if (truncateResult.wasCompacted) effectivePayload = truncateResult.payload;
 		} catch (error) {
 			consola.warn("[Anthropic] Auto-truncate failed, proceeding with original payload:", error instanceof Error ? error.message : error);
@@ -7616,7 +7929,11 @@ async function handleDirectAnthropicCompletion(c, anthropicPayload, ctx, initiat
 	} else if (state.autoTruncate && !selectedModel) consola.debug(`[Anthropic] Model '${anthropicPayload.model}' not found, skipping auto-truncate`);
 	if (state.manualApprove) await awaitApproval();
 	try {
-		const { result: response, queueWaitMs } = await executeWithAdaptiveRateLimit(() => createAnthropicMessages(effectivePayload, { initiator: initiatorOverride }));
+		const { result: response, queueWaitMs } = await executeWithAdaptiveRateLimit(() => createAnthropicMessages(effectivePayload, {
+			initiator: initiatorOverride,
+			injectContext1mBeta: needsContext1mBeta,
+			errorModelIdOverride: needsContext1mBeta ? originalModelId : void 0
+		}));
 		ctx.queueWaitMs = queueWaitMs;
 		if (Symbol.asyncIterator in response) {
 			consola.debug("Streaming response from Copilot (direct Anthropic)");
@@ -7814,17 +8131,33 @@ const parseSubagentMarkerFromSystemReminder = (text) => {
 * Handle completion using OpenAI translation path (legacy)
 */
 async function handleTranslatedCompletion(c, anthropicPayload, ctx, initiatorOverride) {
+	const originalModelId = anthropicPayload.model;
+	const hasOneMillionSuffix = isOneMillionSuffixedClaudeId(originalModelId);
+	const oneMResolution = resolveAnthropicModelForDirectPath(originalModelId);
+	const needsContext1mBeta = hasOneMillionSuffix || (oneMResolution?.oneMillionFallback ?? false);
 	const { payload: translatedPayload, toolNameMapping } = translateToOpenAI(anthropicPayload);
 	consola.debug("Translated OpenAI request payload:", JSON.stringify(translatedPayload));
 	updateTrackerResolvedModel(ctx.trackingId, translatedPayload.model);
 	const selectedModel = findModelById(translatedPayload.model);
-	const { finalPayload: openAIPayload, truncateResult } = await buildFinalPayload(translatedPayload, selectedModel);
+	const autoTruncateConfig = oneMResolution?.oneMillionFallback ? {
+		contextWindowOverride: oneMResolution.effectiveContextWindowTokens,
+		tokenLimitCacheKeyOverride: originalModelId
+	} : {};
+	const { finalPayload: openAIPayload, truncateResult } = await buildFinalPayload(translatedPayload, selectedModel, autoTruncateConfig);
 	if (truncateResult) ctx.truncateResult = truncateResult;
+	let anthropicBeta = c.req.header("anthropic-beta");
+	if (needsContext1mBeta) anthropicBeta = appendContext1mBeta(anthropicBeta);
 	if (state.manualApprove) await awaitApproval();
+	let errorModelIdOverride;
+	if (autoTruncateConfig.tokenLimitCacheKeyOverride !== void 0) errorModelIdOverride = autoTruncateConfig.tokenLimitCacheKeyOverride;
+	else if (needsContext1mBeta && selectedModel) errorModelIdOverride = selectedModel.id;
+	else if (hasOneMillionSuffix) errorModelIdOverride = originalModelId;
 	try {
 		const { result: response, queueWaitMs } = await executeWithAdaptiveRateLimit(() => createChatCompletions(openAIPayload, {
 			initiator: initiatorOverride,
-			resolvedModel: selectedModel
+			resolvedModel: selectedModel,
+			anthropicBeta,
+			errorModelIdOverride
 		}));
 		ctx.queueWaitMs = queueWaitMs;
 		if (isNonStreaming(response)) return handleNonStreamingResponse({
@@ -8092,10 +8425,15 @@ async function handleCountTokens(c) {
 			consola.warn("Model not found, returning default token count");
 			return c.json({ input_tokens: 1 });
 		}
+		const directResolution = resolveAnthropicModelForDirectPath(anthropicPayload.model);
+		const autoTruncateConfig = directResolution?.oneMillionFallback ? {
+			contextWindowOverride: directResolution.effectiveContextWindowTokens,
+			tokenLimitCacheKeyOverride: anthropicPayload.model
+		} : {};
 		if (state.autoTruncate) {
-			const truncateCheck = await checkNeedsCompactionAnthropic(anthropicPayload, selectedModel);
+			const truncateCheck = await checkNeedsCompactionAnthropic(anthropicPayload, selectedModel, autoTruncateConfig);
 			if (truncateCheck.needed) {
-				const contextWindow = selectedModel.capabilities?.limits?.max_context_window_tokens ?? 2e5;
+				const contextWindow = autoTruncateConfig.contextWindowOverride ?? selectedModel.capabilities?.limits?.max_context_window_tokens ?? 2e5;
 				const inflatedTokens = Math.floor(contextWindow * .95);
 				consola.debug(`[count_tokens] Would trigger auto-truncate: ${truncateCheck.currentTokens} tokens > ${truncateCheck.tokenLimit}, returning inflated count: ${inflatedTokens}`);
 				return c.json({ input_tokens: inflatedTokens });
@@ -8191,7 +8529,7 @@ const createResponses = async (payload, { vision, initiator, resolvedModel }) =>
 		"X-Initiator": initiator
 	};
 	payload.service_tier = null;
-	const response = await fetch(`${copilotBaseUrl(state)}/responses`, {
+	const response = await copilotFetch("/responses", {
 		method: "POST",
 		headers,
 		body: JSON.stringify(payload)
@@ -8474,6 +8812,7 @@ const handleResponses = async (c) => {
 				const idTracker = createStreamIdTracker();
 				let finalResult;
 				let streamErrorMessage;
+				let lastSequenceNumber = -1;
 				try {
 					for await (const chunk of response) {
 						consola.debug("Responses stream chunk:", JSON.stringify(chunk));
@@ -8484,6 +8823,10 @@ const handleResponses = async (c) => {
 							if ("response" in parsed) finalResult = parsed.response;
 							else if (eventType === "error" && "message" in parsed) streamErrorMessage = parsed.message;
 						} catch {}
+						try {
+							const parsed = JSON.parse(rawData);
+							if (typeof parsed.sequence_number === "number") lastSequenceNumber = parsed.sequence_number;
+						} catch {}
 						const processedData = fixStreamIds(rawData, eventType, idTracker);
 						await stream.writeSSE({
 							id: chunk.id,
@@ -8522,7 +8865,18 @@ const handleResponses = async (c) => {
 						endpoint: "responses"
 					});
 					failTracking(trackingId, error);
-					throw error;
+					try {
+						await stream.writeSSE({
+							event: "error",
+							data: JSON.stringify({
+								type: "error",
+								code: "upstream_stream_terminated",
+								message: "Upstream stream terminated mid-response. Please retry.",
+								param: null,
+								sequence_number: lastSequenceNumber + 1
+							})
+						});
+					} catch {}
 				}
 			});
 		}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dianshuv/copilot-api",
-  "version": "0.7.9",
+  "version": "0.8.0",
   "description": "Turn GitHub Copilot into OpenAI/Anthropic API compatible server. Usable with Claude Code!",
   "author": "dianshuv",
   "type": "module",