@dianshuv/copilot-api 0.7.10 → 0.8.1

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()
@@ -1348,7 +1348,7 @@ const patchClaude = defineCommand({
 
 //#endregion
 //#region package.json
-var version = "0.7.10";
+var version = "0.8.1";
 
 //#endregion
 //#region src/lib/adaptive-rate-limiter.ts
@@ -3395,6 +3395,89 @@ 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/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;
@@ -3415,21 +3498,27 @@ const createChatCompletions = async (payload, options) => {
 	const enableVision = wire.messages.some((x) => typeof x.content !== "string" && x.content?.some((x) => x.type === "image_url"));
 	const isAgentCall = wire.messages.some((msg) => ["assistant", "tool"].includes(msg.role));
 	const modelSupportsVision = options?.resolvedModel?.capabilities?.supports?.vision !== false;
+	const headers = {
+		...copilotHeaders(state, {
+			vision: enableVision && modelSupportsVision,
+			modelRequestHeaders: options?.resolvedModel?.request_headers,
+			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: {
-			...copilotHeaders(state, {
-				vision: enableVision && modelSupportsVision,
-				modelRequestHeaders: options?.resolvedModel?.request_headers,
-				intent: isAgentCall ? "conversation-agent" : "conversation-panel"
-			}),
-			"X-Initiator": options?.initiator ?? (isAgentCall ? "agent" : "user")
-		},
+		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();
@@ -3964,7 +4053,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 {
@@ -3973,7 +4062,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,
@@ -3984,7 +4073,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
@@ -6839,7 +6928,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";
@@ -7058,14 +7147,18 @@ async function createAnthropicMessages(payload, options) {
 	const headers = {
 		...copilotHeaders(state, {
 			vision: enableVision,
-			intent: isAgentCall ? "conversation-agent" : "conversation-panel"
+			intent: isAgentCall ? "conversation-agent" : "conversation-panel",
+			modelRequestHeaders: resolvedModel?.request_headers
 		}),
 		"X-Initiator": options?.initiator ?? (isAgentCall ? "agent" : "user"),
 		"anthropic-version": "2023-06-01"
 	};
-	const betaHeaders = buildAnthropicBetaHeaders(filteredPayload.model, resolvedModel);
-	Object.assign(headers, betaHeaders);
-	if (isContextEditingEnabled(filteredPayload.model)) {
+	const proxyBeta = buildAnthropicBetaHeaders(filteredPayload.model, resolvedModel)["anthropic-beta"];
+	let mergedBeta = mergeBetaFeatures(getHeader(headers, "anthropic-beta"), proxyBeta);
+	if (options?.injectContext1mBeta) mergedBeta = appendContext1mBeta(mergedBeta);
+	if (options?.clientAnthropicBetaHeader) mergedBeta = mergeBetaFeatures(mergedBeta, options.clientAnthropicBetaHeader);
+	if (mergedBeta.length > 0) setHeader(headers, "anthropic-beta", mergedBeta);
+	if (!("context_management" in filteredPayload) && isContextEditingEnabled(filteredPayload.model)) {
 		const hasThinking = filteredPayload.thinking?.type === "enabled";
 		const cm = buildContextManagement(state.contextEditingMode, hasThinking);
 		if (cm) {
@@ -7091,7 +7184,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();
@@ -7115,12 +7208,71 @@ function stripServerToolsFromPayload(tools) {
 	return result.length > 0 ? result : void 0;
 }
 /**
+* Effective 1M context window. Two ways a request lands on this size:
+* (a) base model id + context-1m-2025-08-07 beta header (e.g. claude-opus-4.8),
+* (b) a distinct upstream "-1m-internal" model id (e.g. claude-opus-4.7-1m-internal).
+*/
+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);
+		const dottedBaseId = dashToDotClaudeId(baseId);
+		for (const candidateId of [`${baseId}-1m-internal`, `${dottedBaseId}-1m-internal`]) {
+			const internal = findModelById(candidateId);
+			if (internal?.vendor === "Anthropic") return {
+				model: internal,
+				baseModelId: candidateId,
+				oneMillionFallback: false,
+				effectiveContextWindowTokens: ONE_MILLION_CONTEXT_WINDOW_TOKENS
+			};
+		}
+		for (const candidateId of [baseId, dottedBaseId]) {
+			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
@@ -7359,18 +7511,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 = {
@@ -7384,6 +7560,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";
@@ -7763,22 +7941,44 @@ 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);
 		}
 	} else if (state.autoTruncate && !selectedModel) consola.debug(`[Anthropic] Model '${anthropicPayload.model}' not found, skipping auto-truncate`);
 	if (state.manualApprove) await awaitApproval();
+	const clientAnthropicBetaHeader = c.req.header("anthropic-beta");
 	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,
+			clientAnthropicBetaHeader
+		}));
 		ctx.queueWaitMs = queueWaitMs;
 		if (Symbol.asyncIterator in response) {
 			consola.debug("Streaming response from Copilot (direct Anthropic)");
@@ -7976,17 +8176,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({
@@ -8254,10 +8470,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 });

package/package.json

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