@hsupu/copilot-api 0.7.9 → 0.7.11

package/dist/main.js

@@ -17,6 +17,7 @@ import pc from "picocolors";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { streamSSE } from "hono/streaming";
+import { countTokens } from "@anthropic-ai/tokenizer";
 import { events } from "fetch-event-stream";
 
 //#region src/lib/paths.ts
@@ -46,7 +47,9 @@ const state = {
 	accountType: "individual",
 	manualApprove: false,
 	showToken: false,
-	autoCompact: true
+	verbose: false,
+	autoTruncate: true,
+	directAnthropicApi: true
 };
 
 //#endregion
@@ -480,9 +483,23 @@ async function checkTokenExists() {
 		return false;
 	}
 }
-async function getDebugInfo() {
+async function getAccountInfo() {
+	try {
+		await ensurePaths();
+		await setupGitHubToken();
+		if (!state.githubToken) return null;
+		const [user, copilot] = await Promise.all([getGitHubUser(), getCopilotUsage()]);
+		return {
+			user,
+			copilot
+		};
+	} catch {
+		return null;
+	}
+}
+async function getDebugInfo(includeAccount) {
 	const [version$1, tokenExists] = await Promise.all([getPackageVersion(), checkTokenExists()]);
-	return {
+	const info = {
 		version: version$1,
 		runtime: getRuntimeInfo(),
 		paths: {
@@ -491,9 +508,14 @@ async function getDebugInfo() {
 		},
 		tokenExists
 	};
+	if (includeAccount && tokenExists) {
+		const account = await getAccountInfo();
+		if (account) info.account = account;
+	}
+	return info;
 }
 function printDebugInfoPlain(info) {
-	consola.info(`copilot-api debug
+	let output = `copilot-api debug
 
 Version: ${info.version}
 Runtime: ${info.runtime.name} ${info.runtime.version} (${info.runtime.platform} ${info.runtime.arch})
@@ -502,19 +524,24 @@ Paths:
 - APP_DIR: ${info.paths.APP_DIR}
 - GITHUB_TOKEN_PATH: ${info.paths.GITHUB_TOKEN_PATH}
 
-Token exists: ${info.tokenExists ? "Yes" : "No"}`);
+Token exists: ${info.tokenExists ? "Yes" : "No"}`;
+	if (info.account) output += `
+
+Account Info:
+${JSON.stringify(info.account, null, 2)}`;
+	consola.info(output);
 }
 function printDebugInfoJson(info) {
 	console.log(JSON.stringify(info, null, 2));
 }
 async function runDebug(options) {
-	const debugInfo = await getDebugInfo();
-	if (options.json) printDebugInfoJson(debugInfo);
-	else printDebugInfoPlain(debugInfo);
+	const debugInfo$1 = await getDebugInfo(true);
+	if (options.json) printDebugInfoJson(debugInfo$1);
+	else printDebugInfoPlain(debugInfo$1);
 }
-const debug = defineCommand({
+const debugInfo = defineCommand({
 	meta: {
-		name: "debug",
+		name: "info",
 		description: "Print debug information about the application"
 	},
 	args: { json: {
@@ -526,6 +553,48 @@ const debug = defineCommand({
 		return runDebug({ json: args.json });
 	}
 });
+const debugModels = defineCommand({
+	meta: {
+		name: "models",
+		description: "Fetch and display raw model data from Copilot API"
+	},
+	args: {
+		"account-type": {
+			type: "string",
+			alias: "a",
+			default: "individual",
+			description: "The type of GitHub account (individual, business, enterprise)"
+		},
+		"github-token": {
+			type: "string",
+			alias: "g",
+			description: "GitHub token to use (skips interactive auth)"
+		}
+	},
+	async run({ args }) {
+		state.accountType = args["account-type"];
+		await ensurePaths();
+		if (args["github-token"]) {
+			state.githubToken = args["github-token"];
+			consola.info("Using provided GitHub token");
+		} else await setupGitHubToken();
+		const { token } = await getCopilotToken();
+		state.copilotToken = token;
+		consola.info("Fetching models from Copilot API...");
+		const models = await getModels();
+		console.log(JSON.stringify(models, null, 2));
+	}
+});
+const debug = defineCommand({
+	meta: {
+		name: "debug",
+		description: "Debug commands for troubleshooting"
+	},
+	subCommands: {
+		info: debugInfo,
+		models: debugModels
+	}
+});
 
 //#endregion
 //#region src/logout.ts
@@ -558,15 +627,12 @@ const SUPPORTED_VERSIONS = {
 		min: "2.0.0",
 		max: "2.1.10"
 	},
-	v2b: {
-		min: "2.1.11",
-		max: "2.1.12"
-	}
+	v2b: { min: "2.1.11" }
 };
 const PATTERNS = {
 	funcOriginal: /function HR\(A\)\{if\(A\.includes\("\[1m\]"\)\)return 1e6;return 200000\}/,
 	funcPatched: /function HR\(A\)\{if\(A\.includes\("\[1m\]"\)\)return 1e6;return \d+\}/,
-	variable: /var BS9=(\d+)/
+	variable: /var ([A-Za-z_$]\w*)=(\d+)(?=,\w+=20000,)/
 };
 /**
 * Parse semver version string to comparable parts
@@ -592,14 +658,14 @@ function compareVersions(a, b) {
 }
 function getPatternTypeForVersion(version$1) {
 	if (compareVersions(version$1, SUPPORTED_VERSIONS.v2a.min) >= 0 && compareVersions(version$1, SUPPORTED_VERSIONS.v2a.max) <= 0) return "func";
-	if (compareVersions(version$1, SUPPORTED_VERSIONS.v2b.min) >= 0 && compareVersions(version$1, SUPPORTED_VERSIONS.v2b.max) <= 0) return "variable";
+	if (compareVersions(version$1, SUPPORTED_VERSIONS.v2b.min) >= 0) return "variable";
 	return null;
 }
 /**
 * Get supported version range string for error messages
 */
 function getSupportedRangeString() {
-	return `${SUPPORTED_VERSIONS.v2a.min}-${SUPPORTED_VERSIONS.v2a.max}, ${SUPPORTED_VERSIONS.v2b.min}-${SUPPORTED_VERSIONS.v2b.max}`;
+	return `${SUPPORTED_VERSIONS.v2a.min}-${SUPPORTED_VERSIONS.v2a.max}, ${SUPPORTED_VERSIONS.v2b.min}+`;
 }
 /**
 * Get Claude Code version from package.json
@@ -632,9 +698,9 @@ function findInVoltaTools(voltaHome) {
 	return paths;
 }
 /**
-* Find Claude Code CLI path by checking common locations
+* Find all Claude Code CLI paths by checking common locations
 */
-function findClaudeCodePath() {
+function findAllClaudeCodePaths() {
 	const possiblePaths = [];
 	const home = process.env.HOME || "";
 	const voltaHome = process.env.VOLTA_HOME || join(home, ".volta");
@@ -649,22 +715,41 @@ function findClaudeCodePath() {
 	for (const base of globalPaths) possiblePaths.push(join(base, "@anthropic-ai", "claude-code", "cli.js"));
 	const bunGlobal = join(home, ".bun", "install", "global");
 	if (existsSync(bunGlobal)) possiblePaths.push(join(bunGlobal, "node_modules", "@anthropic-ai", "claude-code", "cli.js"));
-	return possiblePaths.find((p) => existsSync(p)) ?? null;
+	return [...new Set(possiblePaths.filter((p) => existsSync(p)))];
 }
 /**
-* Get current context limit from Claude Code
+* Get installation info for a CLI path
 */
-function getCurrentLimit(content) {
+function getInstallationInfo(cliPath) {
+	const version$1 = getClaudeCodeVersion(cliPath);
+	const content = readFileSync(cliPath, "utf8");
+	const limit = getCurrentLimit(content);
+	return {
+		path: cliPath,
+		version: version$1,
+		limit
+	};
+}
+function getCurrentLimitInfo(content) {
 	const varMatch = content.match(PATTERNS.variable);
-	if (varMatch) return Number.parseInt(varMatch[1], 10);
+	if (varMatch) return {
+		limit: Number.parseInt(varMatch[2], 10),
+		varName: varMatch[1]
+	};
 	const funcMatch = content.match(PATTERNS.funcPatched);
 	if (funcMatch) {
 		const limitMatch = funcMatch[0].match(/return (\d+)\}$/);
-		return limitMatch ? Number.parseInt(limitMatch[1], 10) : null;
+		return limitMatch ? { limit: Number.parseInt(limitMatch[1], 10) } : null;
 	}
 	return null;
 }
 /**
+* Get current context limit from Claude Code (legacy wrapper)
+*/
+function getCurrentLimit(content) {
+	return getCurrentLimitInfo(content)?.limit ?? null;
+}
+/**
 * Check if Claude Code version is supported for patching
 */
 function checkVersionSupport(cliPath) {
@@ -696,22 +781,25 @@ function patchClaudeCode(cliPath, newLimit) {
 	const versionCheck = checkVersionSupport(cliPath);
 	if (!versionCheck.supported) {
 		consola.error(versionCheck.error);
-		return false;
+		return "failed";
 	}
 	consola.info(`Claude Code version: ${versionCheck.version}`);
-	if (getCurrentLimit(content) === newLimit) {
-		consola.info(`Already patched with limit ${newLimit}`);
-		return true;
-	}
+	const limitInfo = getCurrentLimitInfo(content);
+	if (limitInfo?.limit === newLimit) return "already_patched";
 	let newContent;
-	if (versionCheck.patternType === "variable") newContent = content.replace(PATTERNS.variable, `var BS9=${newLimit}`);
-	else {
+	if (versionCheck.patternType === "variable") {
+		if (!limitInfo?.varName) {
+			consola.error("Could not detect variable name for patching");
+			return "failed";
+		}
+		newContent = content.replace(PATTERNS.variable, `var ${limitInfo.varName}=${newLimit}`);
+	} else {
 		const replacement = `function HR(A){if(A.includes("[1m]"))return 1e6;return ${newLimit}}`;
 		const pattern = PATTERNS.funcOriginal.test(content) ? PATTERNS.funcOriginal : PATTERNS.funcPatched;
 		newContent = content.replace(pattern, replacement);
 	}
 	writeFileSync(cliPath, newContent);
-	return true;
+	return "success";
 }
 /**
 * Restore Claude Code to original 200k limit
@@ -724,13 +812,19 @@ function restoreClaudeCode(cliPath) {
 		return false;
 	}
 	consola.info(`Claude Code version: ${versionCheck.version}`);
-	if (getCurrentLimit(content) === 2e5) {
+	const limitInfo = getCurrentLimitInfo(content);
+	if (limitInfo?.limit === 2e5) {
 		consola.info("Already at original 200000 limit");
 		return true;
 	}
 	let newContent;
-	if (versionCheck.patternType === "variable") newContent = content.replace(PATTERNS.variable, "var BS9=200000");
-	else newContent = content.replace(PATTERNS.funcPatched, "function HR(A){if(A.includes(\"[1m]\"))return 1e6;return 200000}");
+	if (versionCheck.patternType === "variable") {
+		if (!limitInfo?.varName) {
+			consola.error("Could not detect variable name for restoring");
+			return false;
+		}
+		newContent = content.replace(PATTERNS.variable, `var ${limitInfo.varName}=200000`);
+	} else newContent = content.replace(PATTERNS.funcPatched, "function HR(A){if(A.includes(\"[1m]\"))return 1e6;return 200000}");
 	writeFileSync(cliPath, newContent);
 	return true;
 }
@@ -739,7 +833,7 @@ function showStatus(cliPath, currentLimit) {
 	if (version$1) consola.info(`Claude Code version: ${version$1}`);
 	if (currentLimit === null) {
 		consola.warn("Could not detect current limit - CLI may have been updated");
-		consola.info("Look for the BS9 variable or HR function pattern in cli.js");
+		consola.info("Look for a variable like 'var XXX=200000' followed by ',YYY=20000,' in cli.js");
 	} else if (currentLimit === 2e5) consola.info("Status: Original (200k context window)");
 	else consola.info(`Status: Patched (${currentLimit} context window)`);
 }
@@ -773,17 +867,42 @@ const patchClaude = defineCommand({
 			description: "Show current patch status without modifying"
 		}
 	},
-	run({ args }) {
-		const cliPath = args.path || findClaudeCodePath();
-		if (!cliPath) {
-			consola.error("Could not find Claude Code installation");
-			consola.info("Searched in: volta, npm global, bun global");
-			consola.info("Use --path to specify the path to cli.js manually");
-			process.exit(1);
-		}
-		if (!existsSync(cliPath)) {
-			consola.error(`File not found: ${cliPath}`);
-			process.exit(1);
+	async run({ args }) {
+		let cliPath;
+		if (args.path) {
+			cliPath = args.path;
+			if (!existsSync(cliPath)) {
+				consola.error(`File not found: ${cliPath}`);
+				process.exit(1);
+			}
+		} else {
+			const installations = findAllClaudeCodePaths();
+			if (installations.length === 0) {
+				consola.error("Could not find Claude Code installation");
+				consola.info("Searched in: volta, npm global, bun global");
+				consola.info("Use --path to specify the path to cli.js manually");
+				process.exit(1);
+			}
+			if (installations.length === 1) cliPath = installations[0];
+			else {
+				consola.info(`Found ${installations.length} Claude Code installations:`);
+				const options = installations.map((path$1) => {
+					const info = getInstallationInfo(path$1);
+					let status = "unknown";
+					if (info.limit === 2e5) status = "original";
+					else if (info.limit) status = `patched: ${info.limit}`;
+					return {
+						label: `v${info.version ?? "?"} (${status}) - ${path$1}`,
+						value: path$1
+					};
+				});
+				const selected = await consola.prompt("Select installation to patch:", {
+					type: "select",
+					options
+				});
+				if (typeof selected === "symbol") process.exit(0);
+				cliPath = selected;
+			}
 		}
 		consola.info(`Claude Code path: ${cliPath}`);
 		const content = readFileSync(cliPath, "utf8");
@@ -806,13 +925,14 @@ const patchClaude = defineCommand({
 			consola.error("Invalid limit value. Must be a number >= 1000");
 			process.exit(1);
 		}
-		if (patchClaudeCode(cliPath, limit)) {
-			consola.success(`Patched context window: 200000 → ${limit}`);
+		const result = patchClaudeCode(cliPath, limit);
+		if (result === "success") {
+			consola.success(`Patched context window: ${currentLimit ?? 2e5} → ${limit}`);
 			consola.info("Note: You may need to re-run this after Claude Code updates");
-		} else {
+		} else if (result === "already_patched") consola.success(`Already patched with limit ${limit}`);
+		else {
 			consola.error("Failed to patch - pattern not found");
 			consola.info("Claude Code may have been updated to a new version");
-			consola.info("Check the cli.js for the HR function pattern");
 			process.exit(1);
 		}
 	}
@@ -821,7 +941,7 @@ const patchClaude = defineCommand({
 //#endregion
 //#region package.json
 var name = "@hsupu/copilot-api";
-var version = "0.7.9";
+var version = "0.7.11";
 var description = "Turn GitHub Copilot into OpenAI/Anthropic API compatible server. Usable with Claude Code!";
 var keywords = [
 	"proxy",
@@ -854,6 +974,7 @@ var scripts = {
 var simple_git_hooks = { "pre-commit": "bun x lint-staged" };
 var lint_staged = { "*": "bun run lint --fix" };
 var dependencies = {
+	"@anthropic-ai/tokenizer": "^0.0.4",
 	"citty": "^0.1.6",
 	"clipboardy": "^5.0.0",
 	"consola": "^3.4.2",
@@ -2155,9 +2276,61 @@ const numTokensForTools = (tools, encoder, constants) => {
 	return funcTokenCount;
 };
 /**
-* Calculate the token count of messages, supporting multiple GPT encoders
+* Check if a model is an Anthropic model
+*/
+function isAnthropicModel(model) {
+	return model.vendor === "Anthropic";
+}
+/**
+* Convert a message to plain text for Anthropic tokenizer
+*/
+function messageToText(message) {
+	const parts = [];
+	parts.push(`${message.role}:`);
+	if (typeof message.content === "string") parts.push(message.content);
+	else if (Array.isArray(message.content)) {
+		for (const part of message.content) if ("text" in part && part.text) parts.push(part.text);
+		else if (part.type === "image_url") parts.push("[image]");
+	}
+	if (message.tool_calls) for (const tc of message.tool_calls) parts.push(JSON.stringify(tc));
+	if ("tool_call_id" in message && message.tool_call_id) parts.push(`tool_call_id:${message.tool_call_id}`);
+	return parts.join("\n");
+}
+/**
+* Convert tools to text for Anthropic tokenizer
+*/
+function toolsToText(tools) {
+	return tools.map((tool) => JSON.stringify(tool)).join("\n");
+}
+/**
+* Calculate token count using Anthropic's official tokenizer
+*/
+function getAnthropicTokenCount(payload) {
+	const inputMessages = payload.messages.filter((msg) => msg.role !== "assistant");
+	const outputMessages = payload.messages.filter((msg) => msg.role === "assistant");
+	const inputText = inputMessages.map((msg) => messageToText(msg)).join("\n\n");
+	const outputText = outputMessages.map((msg) => messageToText(msg)).join("\n\n");
+	let inputTokens = countTokens(inputText);
+	let outputTokens = countTokens(outputText);
+	if (payload.tools && payload.tools.length > 0) {
+		const toolsText = toolsToText(payload.tools);
+		inputTokens += countTokens(toolsText);
+	}
+	inputTokens += inputMessages.length * 3;
+	outputTokens += outputMessages.length * 3;
+	inputTokens += 3;
+	return {
+		input: inputTokens,
+		output: outputTokens
+	};
+}
+/**
+* Calculate the token count of messages.
+* Uses Anthropic's official tokenizer for Anthropic models,
+* and GPT tokenizers for other models.
 */
 const getTokenCount = async (payload, model) => {
+	if (isAnthropicModel(model)) return getAnthropicTokenCount(payload);
 	const tokenizer = getTokenizerFromModel(model);
 	const encoder = await getEncodeChatFunction(tokenizer);
 	const simplifiedMessages = payload.messages;
@@ -2174,10 +2347,10 @@ const getTokenCount = async (payload, model) => {
 };
 
 //#endregion
-//#region src/lib/auto-compact.ts
+//#region src/lib/auto-truncate.ts
 const DEFAULT_CONFIG = {
 	safetyMarginPercent: 2,
-	maxRequestBodyBytes: 500 * 1024
+	maxRequestBodyBytes: 510 * 1024
 };
 /** Dynamic byte limit that adjusts based on 413 errors */
 let dynamicByteLimit = null;
@@ -2187,7 +2360,7 @@ let dynamicByteLimit = null;
 function onRequestTooLarge(failingBytes) {
 	const newLimit = Math.max(Math.floor(failingBytes * .9), 100 * 1024);
 	dynamicByteLimit = newLimit;
-	consola.info(`[Auto-compact] Adjusted byte limit: ${Math.round(failingBytes / 1024)}KB failed → ${Math.round(newLimit / 1024)}KB`);
+	consola.info(`[AutoTruncate] Adjusted byte limit: ${Math.round(failingBytes / 1024)}KB failed → ${Math.round(newLimit / 1024)}KB`);
 }
 function calculateLimits(model, config) {
 	const rawTokenLimit = model.capabilities?.limits?.max_prompt_tokens ?? 128e3;
@@ -2243,14 +2416,14 @@ function filterOrphanedToolResults(messages) {
 		}
 		return true;
 	});
-	if (removedCount > 0) consola.debug(`Auto-compact: Filtered ${removedCount} orphaned tool_result`);
+	if (removedCount > 0) consola.debug(`[AutoTruncate] Filtered ${removedCount} orphaned tool_result`);
 	return filtered;
 }
 /** Ensure messages start with a user message */
 function ensureStartsWithUser(messages) {
 	let startIndex = 0;
 	while (startIndex < messages.length && messages[startIndex].role !== "user") startIndex++;
-	if (startIndex > 0) consola.debug(`Auto-compact: Skipped ${startIndex} leading non-user messages`);
+	if (startIndex > 0) consola.debug(`[AutoTruncate] Skipped ${startIndex} leading non-user messages`);
 	return messages.slice(startIndex);
 }
 /**
@@ -2316,10 +2489,10 @@ function createTruncationMarker(removedCount) {
 	};
 }
 /**
-* Perform auto-compaction on a payload that exceeds limits.
+* Perform auto-truncation on a payload that exceeds limits.
 * Uses binary search to find the optimal truncation point.
 */
-async function autoCompact(payload, model, config = {}) {
+async function autoTruncate(payload, model, config = {}) {
 	const cfg = {
 		...DEFAULT_CONFIG,
 		...config
@@ -2340,13 +2513,13 @@ async function autoCompact(payload, model, config = {}) {
 	if (exceedsTokens && exceedsBytes) reason = "tokens and size";
 	else if (exceedsBytes) reason = "size";
 	else reason = "tokens";
-	consola.info(`Auto-compact: Exceeds ${reason} limit (${originalTokens} tokens, ${Math.round(originalBytes / 1024)}KB)`);
+	consola.info(`[AutoTruncate] Exceeds ${reason} limit (${originalTokens} tokens, ${Math.round(originalBytes / 1024)}KB)`);
 	const { systemMessages, conversationMessages } = extractSystemMessages(payload.messages);
 	const messagesJson = JSON.stringify(payload.messages);
 	const payloadOverhead = originalBytes - messagesJson.length;
 	const systemBytes = systemMessages.reduce((sum, m) => sum + getMessageBytes(m) + 1, 0);
 	const systemTokens = systemMessages.reduce((sum, m) => sum + estimateMessageTokens(m), 0);
-	consola.debug(`Auto-compact: overhead=${Math.round(payloadOverhead / 1024)}KB, system=${systemMessages.length} msgs (${Math.round(systemBytes / 1024)}KB)`);
+	consola.debug(`[AutoTruncate] overhead=${Math.round(payloadOverhead / 1024)}KB, system=${systemMessages.length} msgs (${Math.round(systemBytes / 1024)}KB)`);
 	const preserveIndex = findOptimalPreserveIndex({
 		messages: conversationMessages,
 		systemBytes,
@@ -2356,7 +2529,7 @@ async function autoCompact(payload, model, config = {}) {
 		byteLimit
 	});
 	if (preserveIndex === 0) {
-		consola.warn("Auto-compact: Cannot truncate, system messages too large");
+		consola.warn("[AutoTruncate] Cannot truncate, system messages too large");
 		return {
 			payload,
 			wasCompacted: false,
@@ -2366,7 +2539,7 @@ async function autoCompact(payload, model, config = {}) {
 		};
 	}
 	if (preserveIndex >= conversationMessages.length) {
-		consola.warn("Auto-compact: Would need to remove all messages");
+		consola.warn("[AutoTruncate] Would need to remove all messages");
 		return {
 			payload,
 			wasCompacted: false,
@@ -2380,7 +2553,7 @@ async function autoCompact(payload, model, config = {}) {
 	preserved = ensureStartsWithUser(preserved);
 	preserved = filterOrphanedToolResults(preserved);
 	if (preserved.length === 0) {
-		consola.warn("Auto-compact: All messages filtered out after cleanup");
+		consola.warn("[AutoTruncate] All messages filtered out after cleanup");
 		return {
 			payload,
 			wasCompacted: false,
@@ -2401,8 +2574,8 @@ async function autoCompact(payload, model, config = {}) {
 	};
 	const newBytes = JSON.stringify(newPayload).length;
 	const newTokenCount = await getTokenCount(newPayload, model);
-	consola.info(`Auto-compact: ${originalTokens} → ${newTokenCount.input} tokens, ${Math.round(originalBytes / 1024)}KB → ${Math.round(newBytes / 1024)}KB (removed ${removedCount} messages)`);
-	if (newBytes > byteLimit) consola.warn(`Auto-compact: Result still over byte limit (${Math.round(newBytes / 1024)}KB > ${Math.round(byteLimit / 1024)}KB)`);
+	consola.info(`[AutoTruncate] ${originalTokens} → ${newTokenCount.input} tokens, ${Math.round(originalBytes / 1024)}KB → ${Math.round(newBytes / 1024)}KB (removed ${removedCount} messages)`);
+	if (newBytes > byteLimit) consola.warn(`[AutoTruncate] Result still over byte limit (${Math.round(newBytes / 1024)}KB > ${Math.round(byteLimit / 1024)}KB)`);
 	return {
 		payload: newPayload,
 		wasCompacted: true,
@@ -2412,13 +2585,13 @@ async function autoCompact(payload, model, config = {}) {
 	};
 }
 /**
-* Create a marker to prepend to responses indicating auto-compaction occurred.
+* Create a marker to prepend to responses indicating auto-truncation occurred.
 */
-function createCompactionMarker(result) {
+function createTruncationResponseMarker(result) {
 	if (!result.wasCompacted) return "";
 	const reduction = result.originalTokens - result.compactedTokens;
 	const percentage = Math.round(reduction / result.originalTokens * 100);
-	return `\n\n---\n[Auto-compacted: ${result.removedMessageCount} messages removed, ${result.originalTokens} → ${result.compactedTokens} tokens (${percentage}% reduction)]`;
+	return `\n\n---\n[Auto-truncated: ${result.removedMessageCount} messages removed, ${result.originalTokens} → ${result.compactedTokens} tokens (${percentage}% reduction)]`;
 }
 
 //#endregion
@@ -2506,37 +2679,37 @@ function recordStreamError(opts) {
 function isNonStreaming(response) {
 	return Object.hasOwn(response, "choices");
 }
-/** Build final payload with auto-compact if needed */
+/** Build final payload with auto-truncate if needed */
 async function buildFinalPayload(payload, model) {
-	if (!state.autoCompact || !model) {
-		if (state.autoCompact && !model) consola.warn(`Auto-compact: Model '${payload.model}' not found in cached models, skipping`);
+	if (!state.autoTruncate || !model) {
+		if (state.autoTruncate && !model) consola.warn(`Auto-truncate: Model '${payload.model}' not found in cached models, skipping`);
 		return {
 			finalPayload: payload,
-			compactResult: null
+			truncateResult: null
 		};
 	}
 	try {
 		const check = await checkNeedsCompaction(payload, model);
-		consola.debug(`Auto-compact check: ${check.currentTokens} tokens (limit ${check.tokenLimit}), ${Math.round(check.currentBytes / 1024)}KB (limit ${Math.round(check.byteLimit / 1024)}KB), needed: ${check.needed}${check.reason ? ` (${check.reason})` : ""}`);
+		consola.debug(`Auto-truncate check: ${check.currentTokens} tokens (limit ${check.tokenLimit}), ${Math.round(check.currentBytes / 1024)}KB (limit ${Math.round(check.byteLimit / 1024)}KB), needed: ${check.needed}${check.reason ? ` (${check.reason})` : ""}`);
 		if (!check.needed) return {
 			finalPayload: payload,
-			compactResult: null
+			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-compact triggered: exceeds ${reasonText} limit`);
-		const compactResult = await autoCompact(payload, model);
+		consola.info(`Auto-truncate triggered: exceeds ${reasonText} limit`);
+		const truncateResult = await autoTruncate(payload, model);
 		return {
-			finalPayload: compactResult.payload,
-			compactResult
+			finalPayload: truncateResult.payload,
+			truncateResult
 		};
 	} catch (error) {
-		consola.warn("Auto-compact failed, proceeding with original payload:", error instanceof Error ? error.message : error);
+		consola.warn("Auto-truncate failed, proceeding with original payload:", error instanceof Error ? error.message : error);
 		return {
 			finalPayload: payload,
-			compactResult: null
+			truncateResult: null
 		};
 	}
 }
@@ -2580,7 +2753,7 @@ async function logPayloadSizeInfo(payload, model) {
 	if (largeMessages > 0) consola.info(`  Large messages (>50KB): ${largeMessages}`);
 	consola.info("");
 	consola.info("  Suggestions:");
-	if (!state.autoCompact) consola.info("    • Enable --auto-compact to automatically truncate history");
+	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");
@@ -2612,8 +2785,8 @@ async function handleCompletion$1(c) {
 	};
 	const selectedModel = state.models?.data.find((model) => model.id === originalPayload.model);
 	await logTokenCount(originalPayload, selectedModel);
-	const { finalPayload, compactResult } = await buildFinalPayload(originalPayload, selectedModel);
-	if (compactResult) ctx.compactResult = compactResult;
+	const { finalPayload, truncateResult } = await buildFinalPayload(originalPayload, selectedModel);
+	if (truncateResult) ctx.truncateResult = truncateResult;
 	const payload = isNullish(finalPayload.max_tokens) ? {
 		...finalPayload,
 		max_tokens: selectedModel?.capabilities?.limits?.max_output_tokens
@@ -2666,8 +2839,8 @@ async function logTokenCount(payload, selectedModel) {
 function handleNonStreamingResponse$1(c, originalResponse, ctx) {
 	consola.debug("Non-streaming response:", JSON.stringify(originalResponse));
 	let response = originalResponse;
-	if (ctx.compactResult?.wasCompacted && response.choices[0]?.message.content) {
-		const marker = createCompactionMarker(ctx.compactResult);
+	if (state.verbose && ctx.truncateResult?.wasCompacted && response.choices[0]?.message.content) {
+		const marker = createTruncationResponseMarker(ctx.truncateResult);
 		response = {
 			...response,
 			choices: response.choices.map((choice$1, i) => i === 0 ? {
@@ -2735,8 +2908,8 @@ async function handleStreamingResponse$1(opts) {
 	const { stream, response, payload, ctx } = opts;
 	const acc = createStreamAccumulator();
 	try {
-		if (ctx.compactResult?.wasCompacted) {
-			const marker = createCompactionMarker(ctx.compactResult);
+		if (state.verbose && ctx.truncateResult?.wasCompacted) {
+			const marker = createTruncationResponseMarker(ctx.truncateResult);
 			const markerChunk = {
 				id: `compact-marker-${Date.now()}`,
 				object: "chat.completion.chunk",
@@ -4109,16 +4282,33 @@ function translateAnthropicMessagesToOpenAI(anthropicMessages, system, toolNameM
 	const otherMessages = anthropicMessages.flatMap((message) => message.role === "user" ? handleUserMessage(message) : handleAssistantMessage(message, toolNameMapping));
 	return [...systemMessages, ...otherMessages];
 }
+const RESERVED_KEYWORDS = ["x-anthropic-billing-header", "x-anthropic-billing"];
+/**
+* Filter out reserved keywords from system prompt text.
+* Copilot API rejects requests containing these keywords.
+* Removes the entire line containing the keyword to keep the prompt clean.
+*/
+function filterReservedKeywords(text) {
+	let filtered = text;
+	for (const keyword of RESERVED_KEYWORDS) if (text.includes(keyword)) {
+		consola.debug(`[Reserved Keyword] Removing line containing "${keyword}"`);
+		filtered = filtered.split("\n").filter((line) => !line.includes(keyword)).join("\n");
+	}
+	return filtered;
+}
 function handleSystemPrompt(system) {
 	if (!system) return [];
 	if (typeof system === "string") return [{
 		role: "system",
-		content: system
-	}];
-	else return [{
-		role: "system",
-		content: system.map((block) => block.text).join("\n\n")
+		content: filterReservedKeywords(system)
 	}];
+	else {
+		const systemText = system.map((block) => block.text).join("\n\n");
+		return [{
+			role: "system",
+			content: filterReservedKeywords(systemText)
+		}];
+	}
 }
 function handleUserMessage(message) {
 	const newMessages = [];
@@ -4317,7 +4507,10 @@ function getAnthropicToolUseBlocks(toolCalls, toolNameMapping) {
 //#endregion
 //#region src/routes/messages/count-tokens-handler.ts
 /**
-* Handles token counting for Anthropic messages
+* Handles token counting for Anthropic messages.
+*
+* For Anthropic models (vendor === "Anthropic"), uses the official Anthropic tokenizer.
+* For other models, uses GPT tokenizers with appropriate buffers.
 */
 async function handleCountTokens(c) {
 	try {
@@ -4329,6 +4522,7 @@ async function handleCountTokens(c) {
 			consola.warn("Model not found, returning default token count");
 			return c.json({ input_tokens: 1 });
 		}
+		const isAnthropicModel$1 = selectedModel.vendor === "Anthropic";
 		const tokenCount = await getTokenCount(openAIPayload, selectedModel);
 		if (anthropicPayload.tools && anthropicPayload.tools.length > 0) {
 			let mcpToolExist = false;
@@ -4339,9 +4533,8 @@ async function handleCountTokens(c) {
 			}
 		}
 		let finalTokenCount = tokenCount.input + tokenCount.output;
-		if (anthropicPayload.model.startsWith("claude")) finalTokenCount = Math.round(finalTokenCount * 1.15);
-		else if (anthropicPayload.model.startsWith("grok")) finalTokenCount = Math.round(finalTokenCount * 1.03);
-		consola.debug("Token count:", finalTokenCount);
+		if (!isAnthropicModel$1) finalTokenCount = anthropicPayload.model.startsWith("grok") ? Math.round(finalTokenCount * 1.03) : Math.round(finalTokenCount * 1.05);
+		consola.debug(`Token count: ${finalTokenCount} (${isAnthropicModel$1 ? "Anthropic tokenizer" : "GPT tokenizer"})`);
 		return c.json({ input_tokens: finalTokenCount });
 	} catch (error) {
 		consola.error("Error counting tokens:", error);
@@ -4349,6 +4542,101 @@ async function handleCountTokens(c) {
 	}
 }
 
+//#endregion
+//#region src/services/copilot/create-anthropic-messages.ts
+/**
+* Fields that are supported by Copilot's Anthropic API endpoint.
+* Any other fields in the incoming request will be stripped.
+*/
+const COPILOT_SUPPORTED_FIELDS = new Set([
+	"model",
+	"messages",
+	"max_tokens",
+	"system",
+	"metadata",
+	"stop_sequences",
+	"stream",
+	"temperature",
+	"top_p",
+	"top_k",
+	"tools",
+	"tool_choice",
+	"thinking",
+	"service_tier"
+]);
+/**
+* Filter payload to only include fields supported by Copilot's Anthropic API.
+* This prevents errors like "Extra inputs are not permitted" for unsupported
+* fields like `output_config`.
+*/
+function filterPayloadForCopilot(payload) {
+	const filtered = {};
+	const unsupportedFields = [];
+	for (const [key, value] of Object.entries(payload)) if (COPILOT_SUPPORTED_FIELDS.has(key)) filtered[key] = value;
+	else unsupportedFields.push(key);
+	if (unsupportedFields.length > 0) consola.debug(`[DirectAnthropic] Filtered unsupported fields: ${unsupportedFields.join(", ")}`);
+	return filtered;
+}
+/**
+* Adjust max_tokens if thinking is enabled.
+* According to Anthropic docs, max_tokens must be greater than thinking.budget_tokens.
+* max_tokens = thinking_budget + response_tokens
+*/
+function adjustMaxTokensForThinking(payload) {
+	const thinking = payload.thinking;
+	if (!thinking) return payload;
+	const budgetTokens = thinking.budget_tokens;
+	if (!budgetTokens) return payload;
+	if (payload.max_tokens <= budgetTokens) {
+		const newMaxTokens = budgetTokens + Math.min(16384, budgetTokens);
+		consola.debug(`[DirectAnthropic] Adjusted max_tokens: ${payload.max_tokens} → ${newMaxTokens} (thinking.budget_tokens=${budgetTokens})`);
+		return {
+			...payload,
+			max_tokens: newMaxTokens
+		};
+	}
+	return payload;
+}
+/**
+* Create messages using Anthropic-style API directly.
+* This bypasses the OpenAI translation layer for Anthropic models.
+*/
+async function createAnthropicMessages(payload) {
+	if (!state.copilotToken) throw new Error("Copilot token not found");
+	let filteredPayload = filterPayloadForCopilot(payload);
+	filteredPayload = adjustMaxTokensForThinking(filteredPayload);
+	const enableVision = filteredPayload.messages.some((msg) => {
+		if (typeof msg.content === "string") return false;
+		return msg.content.some((block) => block.type === "image");
+	});
+	const isAgentCall = filteredPayload.messages.some((msg) => msg.role === "assistant");
+	const headers = {
+		...copilotHeaders(state, enableVision),
+		"X-Initiator": isAgentCall ? "agent" : "user",
+		"anthropic-version": "2023-06-01"
+	};
+	consola.debug("Sending direct Anthropic request to Copilot /v1/messages");
+	const response = await fetch(`${copilotBaseUrl(state)}/v1/messages`, {
+		method: "POST",
+		headers,
+		body: JSON.stringify(filteredPayload)
+	});
+	if (!response.ok) {
+		consola.error("Failed to create Anthropic messages", response);
+		throw await HTTPError.fromResponse("Failed to create Anthropic messages", response);
+	}
+	if (payload.stream) return events(response);
+	return await response.json();
+}
+/**
+* Check if a model supports direct Anthropic API.
+* Returns true if direct Anthropic API is enabled and the model is from Anthropic vendor.
+*/
+function supportsDirectAnthropicApi(modelId) {
+	if (!state.directAnthropicApi) return false;
+	return (state.models?.data.find((m) => m.id === modelId))?.vendor === "Anthropic";
+}
+
 //#endregion
 //#region src/routes/messages/stream-translation.ts
 function isToolBlockOpen(state$1) {
@@ -4511,11 +4799,128 @@ async function handleCompletion(c) {
 		trackingId,
 		startTime
 	};
+	if (supportsDirectAnthropicApi(anthropicPayload.model)) return handleDirectAnthropicCompletion(c, anthropicPayload, ctx);
+	return handleTranslatedCompletion(c, anthropicPayload, ctx);
+}
+/**
+* Handle completion using direct Anthropic API (no translation needed)
+*/
+async function handleDirectAnthropicCompletion(c, anthropicPayload, ctx) {
+	consola.debug("Using direct Anthropic API path for model:", anthropicPayload.model);
+	if (state.manualApprove) await awaitApproval();
+	try {
+		const { result: response, queueWaitMs } = await executeWithAdaptiveRateLimit(() => createAnthropicMessages(anthropicPayload));
+		ctx.queueWaitMs = queueWaitMs;
+		if (Symbol.asyncIterator in response) {
+			consola.debug("Streaming response from Copilot (direct Anthropic)");
+			updateTrackerStatus(ctx.trackingId, "streaming");
+			return streamSSE(c, async (stream) => {
+				await handleDirectAnthropicStreamingResponse({
+					stream,
+					response,
+					anthropicPayload,
+					ctx
+				});
+			});
+		}
+		return handleDirectAnthropicNonStreamingResponse(c, response, ctx);
+	} catch (error) {
+		recordErrorResponse(ctx, anthropicPayload.model, error);
+		throw error;
+	}
+}
+/**
+* Handle non-streaming direct Anthropic response
+*/
+function handleDirectAnthropicNonStreamingResponse(c, response, ctx) {
+	consola.debug("Non-streaming response from Copilot (direct Anthropic):", JSON.stringify(response).slice(-400));
+	recordResponse(ctx.historyId, {
+		success: true,
+		model: response.model,
+		usage: response.usage,
+		stop_reason: response.stop_reason ?? void 0,
+		content: {
+			role: "assistant",
+			content: response.content.map((block) => {
+				switch (block.type) {
+					case "text": return {
+						type: "text",
+						text: block.text
+					};
+					case "tool_use": return {
+						type: "tool_use",
+						id: block.id,
+						name: block.name,
+						input: JSON.stringify(block.input)
+					};
+					case "thinking": return {
+						type: "thinking",
+						thinking: block.thinking
+					};
+					default: return { type: block.type };
+				}
+			})
+		},
+		toolCalls: extractToolCallsFromAnthropicContent(response.content)
+	}, Date.now() - ctx.startTime);
+	if (ctx.trackingId) requestTracker.updateRequest(ctx.trackingId, {
+		inputTokens: response.usage.input_tokens,
+		outputTokens: response.usage.output_tokens,
+		queueWaitMs: ctx.queueWaitMs
+	});
+	return c.json(response);
+}
+/**
+* Handle streaming direct Anthropic response (passthrough SSE events)
+*/
+async function handleDirectAnthropicStreamingResponse(opts) {
+	const { stream, response, anthropicPayload, ctx } = opts;
+	const acc = createAnthropicStreamAccumulator();
+	try {
+		for await (const rawEvent of response) {
+			consola.debug("Direct Anthropic raw stream event:", JSON.stringify(rawEvent));
+			if (rawEvent.data === "[DONE]") break;
+			if (!rawEvent.data) continue;
+			let event;
+			try {
+				event = JSON.parse(rawEvent.data);
+			} catch (parseError) {
+				consola.error("Failed to parse Anthropic stream event:", parseError, rawEvent.data);
+				continue;
+			}
+			processAnthropicEvent(event, acc);
+			await stream.writeSSE({
+				event: rawEvent.event || event.type,
+				data: rawEvent.data
+			});
+		}
+		recordStreamingResponse(acc, anthropicPayload.model, ctx);
+		completeTracking(ctx.trackingId, acc.inputTokens, acc.outputTokens, ctx.queueWaitMs);
+	} catch (error) {
+		consola.error("Direct Anthropic stream error:", error);
+		recordStreamError({
+			acc,
+			fallbackModel: anthropicPayload.model,
+			ctx,
+			error
+		});
+		failTracking(ctx.trackingId, error);
+		const errorEvent = translateErrorToAnthropicErrorEvent();
+		await stream.writeSSE({
+			event: errorEvent.type,
+			data: JSON.stringify(errorEvent)
+		});
+	}
+}
+/**
+* Handle completion using OpenAI translation path (legacy)
+*/
+async function handleTranslatedCompletion(c, anthropicPayload, ctx) {
 	const { payload: translatedPayload, toolNameMapping } = translateToOpenAI(anthropicPayload);
 	consola.debug("Translated OpenAI request payload:", JSON.stringify(translatedPayload));
 	const selectedModel = state.models?.data.find((model) => model.id === translatedPayload.model);
-	const { finalPayload: openAIPayload, compactResult } = await buildFinalPayload(translatedPayload, selectedModel);
-	if (compactResult) ctx.compactResult = compactResult;
+	const { finalPayload: openAIPayload, truncateResult } = await buildFinalPayload(translatedPayload, selectedModel);
+	if (truncateResult) ctx.truncateResult = truncateResult;
 	if (state.manualApprove) await awaitApproval();
 	try {
 		const { result: response, queueWaitMs } = await executeWithAdaptiveRateLimit(() => createChatCompletions(openAIPayload));
@@ -4527,7 +4932,7 @@ async function handleCompletion(c) {
 			ctx
 		});
 		consola.debug("Streaming response from Copilot");
-		updateTrackerStatus(trackingId, "streaming");
+		updateTrackerStatus(ctx.trackingId, "streaming");
 		return streamSSE(c, async (stream) => {
 			await handleStreamingResponse({
 				stream,
@@ -4548,8 +4953,8 @@ function handleNonStreamingResponse(opts) {
 	consola.debug("Non-streaming response from Copilot:", JSON.stringify(response).slice(-400));
 	let anthropicResponse = translateToAnthropic(response, toolNameMapping);
 	consola.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
-	if (ctx.compactResult?.wasCompacted) {
-		const marker = createCompactionMarker(ctx.compactResult);
+	if (state.verbose && ctx.truncateResult?.wasCompacted) {
+		const marker = createTruncationResponseMarker(ctx.truncateResult);
 		anthropicResponse = prependMarkerToAnthropicResponse(anthropicResponse, marker);
 	}
 	recordResponse(ctx.historyId, {
@@ -4621,9 +5026,9 @@ async function handleStreamingResponse(opts) {
 	};
 	const acc = createAnthropicStreamAccumulator();
 	try {
-		if (ctx.compactResult?.wasCompacted) {
-			const marker = createCompactionMarker(ctx.compactResult);
-			await sendCompactionMarkerEvent(stream, streamState, marker);
+		if (ctx.truncateResult?.wasCompacted) {
+			const marker = createTruncationResponseMarker(ctx.truncateResult);
+			await sendTruncationMarkerEvent(stream, streamState, marker);
 			acc.content += marker;
 		}
 		await processStreamChunks({
@@ -4651,7 +5056,7 @@ async function handleStreamingResponse(opts) {
 		});
 	}
 }
-async function sendCompactionMarkerEvent(stream, streamState, marker) {
+async function sendTruncationMarkerEvent(stream, streamState, marker) {
 	const blockStartEvent = {
 		type: "content_block_start",
 		index: streamState.contentBlockIndex,
@@ -4824,6 +5229,15 @@ function extractToolCallsFromContent(content) {
 	});
 	return tools.length > 0 ? tools : void 0;
 }
+function extractToolCallsFromAnthropicContent(content) {
+	const tools = [];
+	for (const block of content) if (block.type === "tool_use") tools.push({
+		id: block.id,
+		name: block.name,
+		input: JSON.stringify(block.input)
+	});
+	return tools.length > 0 ? tools : void 0;
+}
 
 //#endregion
 //#region src/routes/messages/route.ts
@@ -4950,12 +5364,14 @@ async function runServer(options) {
 	if (options.verbose) {
 		consola.level = 5;
 		consola.info("Verbose logging enabled");
+		state.verbose = true;
 	}
 	state.accountType = options.accountType;
 	if (options.accountType !== "individual") consola.info(`Using ${options.accountType} plan GitHub account`);
 	state.manualApprove = options.manual;
 	state.showToken = options.showToken;
-	state.autoCompact = options.autoCompact;
+	state.autoTruncate = options.autoTruncate;
+	state.directAnthropicApi = options.directAnthropicApi;
 	if (options.rateLimit) initAdaptiveRateLimiter({
 		baseRetryIntervalSeconds: options.retryInterval,
 		requestIntervalSeconds: options.requestInterval,
@@ -4963,7 +5379,8 @@ async function runServer(options) {
 		consecutiveSuccessesForRecovery: options.consecutiveSuccesses
 	});
 	else consola.info("Rate limiting disabled");
-	if (!options.autoCompact) consola.info("Auto-compact disabled");
+	if (!options.autoTruncate) consola.info("Auto-truncate disabled");
+	if (!options.directAnthropicApi) consola.info("Direct Anthropic API disabled (using OpenAI translation)");
 	initHistory(options.history, options.historyLimit);
 	if (options.history) {
 		const limitText = options.historyLimit === 0 ? "unlimited" : `max ${options.historyLimit}`;
@@ -5105,10 +5522,15 @@ const start = defineCommand({
 			default: "1000",
 			description: "Maximum number of history entries to keep in memory (0 = unlimited)"
 		},
-		"no-auto-compact": {
+		"no-auto-truncate": {
+			type: "boolean",
+			default: false,
+			description: "Disable automatic conversation history truncation when exceeding limits"
+		},
+		"no-direct-anthropic": {
 			type: "boolean",
 			default: false,
-			description: "Disable automatic conversation history compression when exceeding limits"
+			description: "Disable direct Anthropic API for Anthropic models (use OpenAI translation instead)"
 		}
 	},
 	run({ args }) {
@@ -5129,7 +5551,8 @@ const start = defineCommand({
 			proxyEnv: args["proxy-env"],
 			history: !args["no-history"],
 			historyLimit: Number.parseInt(args["history-limit"], 10),
-			autoCompact: !args["no-auto-compact"]
+			autoTruncate: !args["no-auto-truncate"],
+			directAnthropicApi: !args["no-direct-anthropic"]
 		});
 	}
 });