@hsupu/copilot-api 0.7.4 → 0.7.5

package/dist/main.js

@@ -3,8 +3,9 @@ import { defineCommand, runMain } from "citty";
 import consola from "consola";
 import fs from "node:fs/promises";
 import os from "node:os";
-import path from "node:path";
+import path, { join } from "node:path";
 import { randomUUID } from "node:crypto";
+import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import clipboard from "clipboardy";
 import { serve } from "srvx";
 import invariant from "tiny-invariant";
@@ -136,7 +137,7 @@ function formatRequestTooLargeError() {
 		}
 	};
 }
-async function forwardError(c, error) {
+function forwardError(c, error) {
 	consola.error("Error occurred:", error);
 	if (error instanceof HTTPError) {
 		if (error.status === 413) {
@@ -290,6 +291,24 @@ async function pollAccessToken(deviceCode) {
 //#region src/lib/token.ts
 const readGithubToken = () => fs.readFile(PATHS.GITHUB_TOKEN_PATH, "utf8");
 const writeGithubToken = (token) => fs.writeFile(PATHS.GITHUB_TOKEN_PATH, token);
+/**
+* Refresh the Copilot token with exponential backoff retry.
+* Returns the new token on success, or null if all retries fail.
+*/
+async function refreshCopilotTokenWithRetry(maxRetries = 3) {
+	let lastError = null;
+	for (let attempt = 0; attempt < maxRetries; attempt++) try {
+		const { token } = await getCopilotToken();
+		return token;
+	} catch (error) {
+		lastError = error;
+		const delay = Math.min(1e3 * 2 ** attempt, 3e4);
+		consola.warn(`Token refresh attempt ${attempt + 1}/${maxRetries} failed, retrying in ${delay}ms`);
+		await new Promise((resolve) => setTimeout(resolve, delay));
+	}
+	consola.error("All token refresh attempts failed:", lastError);
+	return null;
+}
 const setupCopilotToken = async () => {
 	const { token, refresh_in } = await getCopilotToken();
 	state.copilotToken = token;
@@ -298,14 +317,12 @@ const setupCopilotToken = async () => {
 	const refreshInterval = (refresh_in - 60) * 1e3;
 	setInterval(async () => {
 		consola.debug("Refreshing Copilot token");
-		try {
-			const { token: token$1 } = await getCopilotToken();
-			state.copilotToken = token$1;
+		const newToken = await refreshCopilotTokenWithRetry();
+		if (newToken) {
+			state.copilotToken = newToken;
 			consola.debug("Copilot token refreshed");
-			if (state.showToken) consola.info("Refreshed Copilot token:", token$1);
-		} catch (error) {
-			consola.error("Failed to refresh Copilot token (will retry on next interval):", error);
-		}
+			if (state.showToken) consola.info("Refreshed Copilot token:", newToken);
+		} else consola.error("Failed to refresh Copilot token after retries, using existing token");
 	}, refreshInterval);
 };
 async function setupGitHubToken(options) {
@@ -520,6 +537,167 @@ const logout = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/patch-claude.ts
+const ORIGINAL_PATTERN = /function HR\(A\)\{if\(A\.includes\("\[1m\]"\)\)return 1e6;return 200000\}/;
+const PATCHED_PATTERN = /function HR\(A\)\{if\(A\.includes\("\[1m\]"\)\)return 1e6;return \d+\}/;
+/**
+* Search volta tools directory for Claude Code
+*/
+function findInVoltaTools(voltaHome) {
+	const paths = [];
+	const toolsDir = join(voltaHome, "tools", "image", "node");
+	if (!existsSync(toolsDir)) return paths;
+	try {
+		for (const version of readdirSync(toolsDir)) {
+			const claudePath = join(toolsDir, version, "lib", "node_modules", "@anthropic-ai", "claude-code", "cli.js");
+			if (existsSync(claudePath)) paths.push(claudePath);
+		}
+	} catch {}
+	return paths;
+}
+/**
+* Find Claude Code CLI path by checking common locations
+*/
+function findClaudeCodePath() {
+	const possiblePaths = [];
+	const home = process.env.HOME || "";
+	const voltaHome = process.env.VOLTA_HOME || join(home, ".volta");
+	if (existsSync(voltaHome)) possiblePaths.push(...findInVoltaTools(voltaHome));
+	const npmPrefix = process.env.npm_config_prefix;
+	if (npmPrefix) possiblePaths.push(join(npmPrefix, "lib", "node_modules", "@anthropic-ai", "claude-code", "cli.js"));
+	const globalPaths = [
+		join(home, ".npm-global", "lib", "node_modules"),
+		"/usr/local/lib/node_modules",
+		"/usr/lib/node_modules"
+	];
+	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;
+}
+/**
+* Get current context limit from Claude Code
+*/
+function getCurrentLimit(content) {
+	const match = content.match(PATCHED_PATTERN);
+	if (!match) return null;
+	const limitMatch = match[0].match(/return (\d+)\}$/);
+	return limitMatch ? Number.parseInt(limitMatch[1], 10) : null;
+}
+/**
+* Patch Claude Code to use a different context limit
+*/
+function patchClaudeCode(cliPath, newLimit) {
+	const content = readFileSync(cliPath, "utf8");
+	if (getCurrentLimit(content) === newLimit) {
+		consola.info(`Already patched with limit ${newLimit}`);
+		return true;
+	}
+	const replacement = `function HR(A){if(A.includes("[1m]"))return 1e6;return ${newLimit}}`;
+	let newContent;
+	if (ORIGINAL_PATTERN.test(content)) newContent = content.replace(ORIGINAL_PATTERN, replacement);
+	else if (PATCHED_PATTERN.test(content)) newContent = content.replace(PATCHED_PATTERN, replacement);
+	else return false;
+	writeFileSync(cliPath, newContent);
+	return true;
+}
+/**
+* Restore Claude Code to original 200k limit
+*/
+function restoreClaudeCode(cliPath) {
+	const content = readFileSync(cliPath, "utf8");
+	if (getCurrentLimit(content) === 2e5) {
+		consola.info("Already at original 200000 limit");
+		return true;
+	}
+	if (!PATCHED_PATTERN.test(content)) return false;
+	const newContent = content.replace(PATCHED_PATTERN, "function HR(A){if(A.includes(\"[1m]\"))return 1e6;return 200000}");
+	writeFileSync(cliPath, newContent);
+	return true;
+}
+function showStatus(currentLimit) {
+	if (currentLimit === null) {
+		consola.warn("Could not detect current limit - CLI may have been updated");
+		consola.info("Look for the HR function pattern in cli.js");
+	} else if (currentLimit === 2e5) consola.info("Status: Original (200k context window)");
+	else consola.info(`Status: Patched (${currentLimit} context window)`);
+}
+const patchClaude = defineCommand({
+	meta: {
+		name: "patch-claude",
+		description: "Patch Claude Code's context window limit to match Copilot's limits"
+	},
+	args: {
+		limit: {
+			alias: "l",
+			type: "string",
+			default: "128000",
+			description: "Context window limit in tokens (default: 128000 for Copilot)"
+		},
+		restore: {
+			alias: "r",
+			type: "boolean",
+			default: false,
+			description: "Restore original 200k limit"
+		},
+		path: {
+			alias: "p",
+			type: "string",
+			description: "Path to Claude Code cli.js (auto-detected if not specified)"
+		},
+		status: {
+			alias: "s",
+			type: "boolean",
+			default: false,
+			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);
+		}
+		consola.info(`Claude Code path: ${cliPath}`);
+		const content = readFileSync(cliPath, "utf8");
+		const currentLimit = getCurrentLimit(content);
+		if (args.status) {
+			showStatus(currentLimit);
+			return;
+		}
+		if (args.restore) {
+			if (restoreClaudeCode(cliPath)) consola.success("Restored to original 200k limit");
+			else {
+				consola.error("Failed to restore - pattern not found");
+				consola.info("Claude Code may have been updated to a new version");
+				process.exit(1);
+			}
+			return;
+		}
+		const limit = Number.parseInt(args.limit, 10);
+		if (Number.isNaN(limit) || limit < 1e3) {
+			consola.error("Invalid limit value. Must be a number >= 1000");
+			process.exit(1);
+		}
+		if (patchClaudeCode(cliPath, limit)) {
+			consola.success(`Patched context window: 200000 → ${limit}`);
+			consola.info("Note: You may need to re-run this after Claude Code updates");
+		} 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);
+		}
+	}
+});
+
 //#endregion
 //#region src/lib/history.ts
 function generateId$1() {
@@ -771,44 +949,74 @@ function exportHistory(format = "json") {
 
 //#endregion
 //#region src/lib/proxy.ts
+/**
+* Custom dispatcher that routes requests through proxies based on environment variables.
+* Extends Agent to properly inherit the Dispatcher interface.
+*/
+var ProxyDispatcher = class extends Agent {
+	proxies = /* @__PURE__ */ new Map();
+	dispatch(options, handler) {
+		try {
+			const origin = this.getOriginUrl(options.origin);
+			const proxyUrl = this.getProxyUrl(origin);
+			if (!proxyUrl) {
+				consola.debug(`HTTP proxy bypass: ${origin.hostname}`);
+				return super.dispatch(options, handler);
+			}
+			const agent = this.getOrCreateProxyAgent(proxyUrl);
+			consola.debug(`HTTP proxy route: ${origin.hostname} via ${this.formatProxyLabel(proxyUrl)}`);
+			return agent.dispatch(options, handler);
+		} catch {
+			return super.dispatch(options, handler);
+		}
+	}
+	getOriginUrl(origin) {
+		return typeof origin === "string" ? new URL(origin) : origin;
+	}
+	getProxyUrl(origin) {
+		const raw = getProxyForUrl(origin.toString());
+		return raw && raw.length > 0 ? raw : void 0;
+	}
+	getOrCreateProxyAgent(proxyUrl) {
+		let agent = this.proxies.get(proxyUrl);
+		if (!agent) {
+			agent = new ProxyAgent(proxyUrl);
+			this.proxies.set(proxyUrl, agent);
+		}
+		return agent;
+	}
+	formatProxyLabel(proxyUrl) {
+		try {
+			const u = new URL(proxyUrl);
+			return `${u.protocol}//${u.host}`;
+		} catch {
+			return proxyUrl;
+		}
+	}
+	async close() {
+		await super.close();
+		await Promise.all([...this.proxies.values()].map((p) => p.close()));
+		this.proxies.clear();
+	}
+	destroy(errOrCallback, callback) {
+		for (const agent of this.proxies.values()) if (typeof errOrCallback === "function") agent.destroy(errOrCallback);
+		else if (callback) agent.destroy(errOrCallback ?? null, callback);
+		else agent.destroy(errOrCallback ?? null).catch(() => {});
+		this.proxies.clear();
+		if (typeof errOrCallback === "function") {
+			super.destroy(errOrCallback);
+			return;
+		} else if (callback) {
+			super.destroy(errOrCallback ?? null, callback);
+			return;
+		} else return super.destroy(errOrCallback ?? null);
+	}
+};
 function initProxyFromEnv() {
 	if (typeof Bun !== "undefined") return;
 	try {
-		const direct = new Agent();
-		const proxies = /* @__PURE__ */ new Map();
-		setGlobalDispatcher({
-			dispatch(options, handler) {
-				try {
-					const origin = typeof options.origin === "string" ? new URL(options.origin) : options.origin;
-					const raw = getProxyForUrl(origin.toString());
-					const proxyUrl = raw && raw.length > 0 ? raw : void 0;
-					if (!proxyUrl) {
-						consola.debug(`HTTP proxy bypass: ${origin.hostname}`);
-						return direct.dispatch(options, handler);
-					}
-					let agent = proxies.get(proxyUrl);
-					if (!agent) {
-						agent = new ProxyAgent(proxyUrl);
-						proxies.set(proxyUrl, agent);
-					}
-					let label = proxyUrl;
-					try {
-						const u = new URL(proxyUrl);
-						label = `${u.protocol}//${u.host}`;
-					} catch {}
-					consola.debug(`HTTP proxy route: ${origin.hostname} via ${label}`);
-					return agent.dispatch(options, handler);
-				} catch {
-					return direct.dispatch(options, handler);
-				}
-			},
-			close() {
-				return direct.close();
-			},
-			destroy() {
-				return direct.destroy();
-			}
-		});
+		const dispatcher = new ProxyDispatcher();
+		setGlobalDispatcher(dispatcher);
 		consola.debug("HTTP proxy configured from environment (per-URL)");
 	} catch (err) {
 		consola.debug("Proxy setup skipped:", err);
@@ -893,24 +1101,56 @@ function formatTokens(input, output) {
 /**
 * Console renderer that shows request lifecycle with apt-get style footer
 *
-* Log format:
-* - Start: [....] METHOD /path model-name
-* - Streaming: [<-->] METHOD /path model-name streaming...
-* - Complete: [ OK ] METHOD /path 200 1.2s 1.5K/500 model-name
+* Log format (status prefix first, then timestamp):
+* - Start: [....] HH:MM:SS METHOD /path model-name
+* - Streaming: [<-->] HH:MM:SS METHOD /path model-name streaming...
+* - Complete: [ OK ] HH:MM:SS METHOD /path 200 1.2s 1.5K/500 model-name
+* - Error: [FAIL] HH:MM:SS METHOD /path 500 1.2s model-name: error message
 *
 * Features:
 * - /history API requests are displayed in gray (dim)
 * - Sticky footer shows active request count, updated in-place on the last line
 * - Footer disappears when all requests complete
+* - Intercepts consola output to properly handle footer
 */
 var ConsoleRenderer = class {
 	activeRequests = /* @__PURE__ */ new Map();
 	showActive;
 	footerVisible = false;
 	isTTY;
+	originalReporters = [];
 	constructor(options) {
 		this.showActive = options?.showActive ?? true;
 		this.isTTY = process.stdout.isTTY;
+		this.installConsolaReporter();
+	}
+	/**
+	* Install a custom consola reporter that coordinates with footer
+	*/
+	installConsolaReporter() {
+		this.originalReporters = [...consola.options.reporters];
+		consola.setReporters([{ log: (logObj) => {
+			this.clearFooterForLog();
+			const message = logObj.args.map((arg) => typeof arg === "string" ? arg : JSON.stringify(arg)).join(" ");
+			const prefix = this.getLogPrefix(logObj.type);
+			if (prefix) process.stdout.write(`${prefix} ${message}\n`);
+			else process.stdout.write(`${message}\n`);
+			this.renderFooter();
+		} }]);
+	}
+	/**
+	* Get log prefix based on log type
+	*/
+	getLogPrefix(type) {
+		switch (type) {
+			case "error":
+			case "fatal": return pc.red("✖");
+			case "warn": return pc.yellow("⚠");
+			case "info": return pc.cyan("ℹ");
+			case "success": return pc.green("✔");
+			case "debug": return pc.gray("●");
+			default: return "";
+		}
 	}
 	/**
 	* Get footer text based on active request count
@@ -953,8 +1193,8 @@ var ConsoleRenderer = class {
 	*/
 	printLog(message, isGray = false) {
 		this.clearFooterForLog();
-		if (isGray) consola.log(pc.dim(message));
-		else consola.log(message);
+		if (isGray) process.stdout.write(pc.dim(message) + "\n");
+		else process.stdout.write(message + "\n");
 		this.renderFooter();
 	}
 	onRequestStart(request) {
@@ -963,7 +1203,7 @@ var ConsoleRenderer = class {
 			const time = formatTime();
 			const modelInfo = request.model ? ` ${request.model}` : "";
 			const queueInfo = request.queuePosition !== void 0 && request.queuePosition > 0 ? ` [q#${request.queuePosition}]` : "";
-			const message = `${time} [....] ${request.method} ${request.path}${modelInfo}${queueInfo}`;
+			const message = `[....] ${time} ${request.method} ${request.path}${modelInfo}${queueInfo}`;
 			this.printLog(message, request.isHistoryAccess);
 		}
 	}
@@ -974,7 +1214,7 @@ var ConsoleRenderer = class {
 		if (this.showActive && update.status === "streaming") {
 			const time = formatTime();
 			const modelInfo = request.model ? ` ${request.model}` : "";
-			const message = `${time} [<-->] ${request.method} ${request.path}${modelInfo} streaming...`;
+			const message = `[<-->] ${time} ${request.method} ${request.path}${modelInfo} streaming...`;
 			this.printLog(message, request.isHistoryAccess);
 		}
 	}
@@ -988,7 +1228,7 @@ var ConsoleRenderer = class {
 		const isError = request.status === "error" || status >= 400;
 		const prefix = isError ? "[FAIL]" : "[ OK ]";
 		const tokensPart = tokens ? ` ${tokens}` : "";
-		let content = `${time} ${prefix} ${request.method} ${request.path} ${status} ${duration}${tokensPart}${modelInfo}`;
+		let content = `${prefix} ${time} ${request.method} ${request.path} ${status} ${duration}${tokensPart}${modelInfo}`;
 		if (isError) {
 			const errorInfo = request.error ? `: ${request.error}` : "";
 			content += errorInfo;
@@ -1001,6 +1241,7 @@ var ConsoleRenderer = class {
 			this.footerVisible = false;
 		}
 		this.activeRequests.clear();
+		if (this.originalReporters.length > 0) consola.setReporters(this.originalReporters);
 	}
 };
 
@@ -1392,14 +1633,14 @@ const getTokenCount = async (payload, model) => {
 //#endregion
 //#region src/lib/auto-compact.ts
 const DEFAULT_CONFIG = {
-	targetTokens: 1e5,
-	safetyMarginPercent: 10
+	targetTokens: 12e4,
+	safetyMarginPercent: 2
 };
 /**
 * Check if payload needs compaction based on model limits.
 * Uses a safety margin to account for token counting differences.
 */
-async function checkNeedsCompaction(payload, model, safetyMarginPercent = 10) {
+async function checkNeedsCompaction(payload, model, safetyMarginPercent = 2) {
 	const currentTokens = (await getTokenCount(payload, model)).input;
 	const rawLimit = model.capabilities?.limits?.max_prompt_tokens ?? 128e3;
 	const limit = Math.floor(rawLimit * (1 - safetyMarginPercent / 100));
@@ -1442,6 +1683,13 @@ function extractSystemMessages(messages) {
 	};
 }
 /**
+* Extract tool_use ids from assistant messages with tool_calls.
+*/
+function getToolUseIds(message) {
+	if (message.role === "assistant" && message.tool_calls) return message.tool_calls.map((tc) => tc.id);
+	return [];
+}
+/**
 * Find messages to keep from the end to stay under target tokens.
 * Returns the starting index of messages to preserve.
 */
@@ -1456,6 +1704,41 @@ function findPreserveIndex(messages, targetTokens, systemTokens) {
 	return 0;
 }
 /**
+* Filter out orphaned tool_result messages that don't have a matching tool_use
+* in the preserved message list. This prevents API errors when truncation
+* separates tool_use/tool_result pairs.
+*/
+function filterOrphanedToolResults(messages) {
+	const availableToolUseIds = /* @__PURE__ */ new Set();
+	for (const msg of messages) for (const id of getToolUseIds(msg)) availableToolUseIds.add(id);
+	const filteredMessages = [];
+	let removedCount = 0;
+	for (const msg of messages) {
+		if (msg.role === "tool" && msg.tool_call_id && !availableToolUseIds.has(msg.tool_call_id)) {
+			removedCount++;
+			continue;
+		}
+		filteredMessages.push(msg);
+	}
+	if (removedCount > 0) consola.info(`Auto-compact: Removed ${removedCount} orphaned tool_result message(s) without matching tool_use`);
+	return filteredMessages;
+}
+/**
+* Ensure the message list starts with a user message.
+* If it starts with assistant or tool messages, skip them until we find a user message.
+* This is required because OpenAI API expects conversations to start with user messages
+* (after system messages).
+*/
+function ensureStartsWithUser(messages) {
+	let startIndex = 0;
+	while (startIndex < messages.length) {
+		if (messages[startIndex].role === "user") break;
+		startIndex++;
+	}
+	if (startIndex > 0) consola.info(`Auto-compact: Skipped ${startIndex} leading non-user message(s) to ensure valid sequence`);
+	return messages.slice(startIndex);
+}
+/**
 * Calculate estimated tokens for system messages.
 */
 function estimateSystemTokens(systemMessages) {
@@ -1473,6 +1756,7 @@ function createTruncationMarker(removedCount) {
 /**
 * Perform auto-compaction on a payload that exceeds token limits.
 * This uses simple truncation - no LLM calls required.
+* Uses iterative approach with decreasing target tokens until under limit.
 */
 async function autoCompact(payload, model, config = {}) {
 	const cfg = {
@@ -1493,8 +1777,49 @@ async function autoCompact(payload, model, config = {}) {
 	const { systemMessages, remainingMessages } = extractSystemMessages(payload.messages);
 	const systemTokens = estimateSystemTokens(systemMessages);
 	consola.debug(`Auto-compact: ${systemMessages.length} system messages (~${systemTokens} tokens)`);
-	const effectiveTarget = Math.min(cfg.targetTokens, limit);
-	const preserveIndex = findPreserveIndex(remainingMessages, effectiveTarget, systemTokens);
+	const MAX_ITERATIONS = 5;
+	const MIN_TARGET = 2e4;
+	let currentTarget = Math.min(cfg.targetTokens, limit);
+	let lastResult = null;
+	for (let iteration = 0; iteration < MAX_ITERATIONS; iteration++) {
+		const result = await tryCompactWithTarget({
+			payload,
+			model,
+			systemMessages,
+			remainingMessages,
+			systemTokens,
+			targetTokens: currentTarget,
+			limit,
+			originalTokens
+		});
+		if (!result.wasCompacted) return result;
+		lastResult = result;
+		if (result.compactedTokens <= limit) {
+			consola.info(`Auto-compact: ${originalTokens} → ${result.compactedTokens} tokens (removed ${result.removedMessageCount} messages)`);
+			return result;
+		}
+		consola.warn(`Auto-compact: Still over limit (${result.compactedTokens} > ${limit}), trying more aggressive truncation`);
+		currentTarget = Math.floor(currentTarget * .7);
+		if (currentTarget < MIN_TARGET) {
+			consola.error("Auto-compact: Cannot reduce further, target too low");
+			return result;
+		}
+	}
+	consola.error(`Auto-compact: Exhausted ${MAX_ITERATIONS} iterations, returning best effort`);
+	return lastResult ?? {
+		payload,
+		wasCompacted: false,
+		originalTokens,
+		compactedTokens: originalTokens,
+		removedMessageCount: 0
+	};
+}
+/**
+* Helper to attempt compaction with a specific target token count.
+*/
+async function tryCompactWithTarget(opts) {
+	const { payload, model, systemMessages, remainingMessages, systemTokens, targetTokens, originalTokens } = opts;
+	const preserveIndex = findPreserveIndex(remainingMessages, targetTokens, systemTokens);
 	if (preserveIndex === 0) {
 		consola.warn("Auto-compact: Cannot truncate further without losing all conversation history");
 		return {
@@ -1506,8 +1831,21 @@ async function autoCompact(payload, model, config = {}) {
 		};
 	}
 	const removedMessages = remainingMessages.slice(0, preserveIndex);
-	const preservedMessages = remainingMessages.slice(preserveIndex);
-	consola.info(`Auto-compact: Removing ${removedMessages.length} messages, keeping ${preservedMessages.length}`);
+	let preservedMessages = remainingMessages.slice(preserveIndex);
+	preservedMessages = filterOrphanedToolResults(preservedMessages);
+	preservedMessages = ensureStartsWithUser(preservedMessages);
+	preservedMessages = filterOrphanedToolResults(preservedMessages);
+	if (preservedMessages.length === 0) {
+		consola.warn("Auto-compact: All messages were filtered out after cleanup, cannot compact");
+		return {
+			payload,
+			wasCompacted: false,
+			originalTokens,
+			compactedTokens: originalTokens,
+			removedMessageCount: 0
+		};
+	}
+	consola.debug(`Auto-compact: Removing ${removedMessages.length} messages, keeping ${preservedMessages.length}`);
 	const truncationMarker = createTruncationMarker(removedMessages.length);
 	const newPayload = {
 		...payload,
@@ -1518,25 +1856,6 @@ async function autoCompact(payload, model, config = {}) {
 		]
 	};
 	const newTokenCount = await getTokenCount(newPayload, model);
-	consola.info(`Auto-compact: Reduced from ${originalTokens} to ${newTokenCount.input} tokens`);
-	if (newTokenCount.input > limit) {
-		consola.warn(`Auto-compact: Still over limit (${newTokenCount.input} > ${limit}), trying more aggressive truncation`);
-		const aggressiveTarget = Math.floor(effectiveTarget * .7);
-		if (aggressiveTarget < 2e4) {
-			consola.error("Auto-compact: Cannot reduce further, target too low");
-			return {
-				payload: newPayload,
-				wasCompacted: true,
-				originalTokens,
-				compactedTokens: newTokenCount.input,
-				removedMessageCount: removedMessages.length
-			};
-		}
-		return autoCompact(payload, model, {
-			...cfg,
-			targetTokens: aggressiveTarget
-		});
-	}
 	return {
 		payload: newPayload,
 		wasCompacted: true,
@@ -1563,11 +1882,12 @@ var RequestQueue = class {
 	lastRequestTime = 0;
 	async enqueue(execute, rateLimitSeconds) {
 		return new Promise((resolve, reject) => {
-			this.queue.push({
+			const request = {
 				execute,
 				resolve,
 				reject
-			});
+			};
+			this.queue.push(request);
 			if (this.queue.length > 1) {
 				const position = this.queue.length;
 				const waitTime = Math.ceil((position - 1) * rateLimitSeconds);
@@ -1638,16 +1958,149 @@ const createChatCompletions = async (payload) => {
 };
 
 //#endregion
-//#region src/routes/chat-completions/handler.ts
-function getModelMaxOutputTokens(model) {
-	return model?.capabilities?.limits?.max_output_tokens;
+//#region src/routes/shared.ts
+/** Helper to update tracker model */
+function updateTrackerModel(trackingId, model) {
+	if (!trackingId) return;
+	const request = requestTracker.getRequest(trackingId);
+	if (request) request.model = model;
+}
+/** Helper to update tracker status */
+function updateTrackerStatus(trackingId, status) {
+	if (!trackingId) return;
+	requestTracker.updateRequest(trackingId, { status });
 }
+/** Record error response to history */
+function recordErrorResponse(ctx, model, error) {
+	recordResponse(ctx.historyId, {
+		success: false,
+		model,
+		usage: {
+			input_tokens: 0,
+			output_tokens: 0
+		},
+		error: error instanceof Error ? error.message : "Unknown error",
+		content: null
+	}, Date.now() - ctx.startTime);
+}
+/** Complete TUI tracking */
+function completeTracking(trackingId, inputTokens, outputTokens) {
+	if (!trackingId) return;
+	requestTracker.updateRequest(trackingId, {
+		inputTokens,
+		outputTokens
+	});
+	requestTracker.completeRequest(trackingId, 200, {
+		inputTokens,
+		outputTokens
+	});
+}
+/** Fail TUI tracking */
+function failTracking(trackingId, error) {
+	if (!trackingId) return;
+	requestTracker.failRequest(trackingId, error instanceof Error ? error.message : "Stream error");
+}
+/** Record streaming error to history (works with any accumulator type) */
+function recordStreamError(opts) {
+	const { acc, fallbackModel, ctx, error } = opts;
+	recordResponse(ctx.historyId, {
+		success: false,
+		model: acc.model || fallbackModel,
+		usage: {
+			input_tokens: 0,
+			output_tokens: 0
+		},
+		error: error instanceof Error ? error.message : "Stream error",
+		content: null
+	}, Date.now() - ctx.startTime);
+}
+/** Type guard for non-streaming responses */
+function isNonStreaming(response) {
+	return Object.hasOwn(response, "choices");
+}
+/** Build final payload with auto-compact 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`);
+		return {
+			finalPayload: payload,
+			compactResult: null
+		};
+	}
+	try {
+		const check = await checkNeedsCompaction(payload, model);
+		consola.debug(`Auto-compact check: ${check.currentTokens} tokens, limit ${check.limit}, needed: ${check.needed}`);
+		if (!check.needed) return {
+			finalPayload: payload,
+			compactResult: null
+		};
+		consola.info(`Auto-compact triggered: ${check.currentTokens} tokens > ${check.limit} limit`);
+		const compactResult = await autoCompact(payload, model);
+		return {
+			finalPayload: compactResult.payload,
+			compactResult
+		};
+	} catch (error) {
+		consola.warn("Auto-compact failed, proceeding with original payload:", error instanceof Error ? error.message : error);
+		return {
+			finalPayload: payload,
+			compactResult: null
+		};
+	}
+}
+/**
+* Log helpful debugging information when a 413 error occurs.
+*/
+async function logPayloadSizeInfo(payload, model) {
+	const messageCount = payload.messages.length;
+	const bodySize = JSON.stringify(payload).length;
+	const bodySizeKB = Math.round(bodySize / 1024);
+	let imageCount = 0;
+	let largeMessages = 0;
+	let totalImageSize = 0;
+	for (const msg of payload.messages) {
+		if (Array.isArray(msg.content)) {
+			for (const part of msg.content) if (part.type === "image_url") {
+				imageCount++;
+				if (part.image_url.url.startsWith("data:")) totalImageSize += part.image_url.url.length;
+			}
+		}
+		if ((typeof msg.content === "string" ? msg.content.length : JSON.stringify(msg.content).length) > 5e4) largeMessages++;
+	}
+	consola.info("");
+	consola.info("╭─────────────────────────────────────────────────────────╮");
+	consola.info("│           413 Request Entity Too Large                  │");
+	consola.info("╰─────────────────────────────────────────────────────────╯");
+	consola.info("");
+	consola.info(`  Request body size: ${bodySizeKB} KB (${bodySize.toLocaleString()} bytes)`);
+	consola.info(`  Message count: ${messageCount}`);
+	if (model) try {
+		const tokenCount = await getTokenCount(payload, model);
+		const limit = model.capabilities?.limits?.max_prompt_tokens ?? 128e3;
+		consola.info(`  Estimated tokens: ${tokenCount.input.toLocaleString()} / ${limit.toLocaleString()}`);
+	} catch {}
+	if (imageCount > 0) {
+		const imageSizeKB = Math.round(totalImageSize / 1024);
+		consola.info(`  Images: ${imageCount} (${imageSizeKB} KB base64 data)`);
+	}
+	if (largeMessages > 0) consola.info(`  Large messages (>50KB): ${largeMessages}`);
+	consola.info("");
+	consola.info("  Suggestions:");
+	if (!state.autoCompact) consola.info("    • Enable --auto-compact to automatically truncate history");
+	if (imageCount > 0) consola.info("    • Remove or resize large images in the conversation");
+	consola.info("    • Start a new conversation with /clear or /reset");
+	consola.info("    • Reduce conversation history by deleting old messages");
+	consola.info("");
+}
+
+//#endregion
+//#region src/routes/chat-completions/handler.ts
 async function handleCompletion$1(c) {
 	const originalPayload = await c.req.json();
 	consola.debug("Request payload:", JSON.stringify(originalPayload).slice(-400));
 	const trackingId = c.get("trackingId");
 	const startTime = (trackingId ? requestTracker.getRequest(trackingId) : void 0)?.startTime ?? Date.now();
-	updateTrackerModel$1(trackingId, originalPayload.model);
+	updateTrackerModel(trackingId, originalPayload.model);
 	const ctx = {
 		historyId: recordRequest("openai", {
 			model: originalPayload.model,
@@ -1665,19 +2118,32 @@ 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$1(originalPayload, selectedModel);
+	const { finalPayload, compactResult } = await buildFinalPayload(originalPayload, selectedModel);
 	if (compactResult) ctx.compactResult = compactResult;
 	const payload = isNullish(finalPayload.max_tokens) ? {
 		...finalPayload,
-		max_tokens: getModelMaxOutputTokens(selectedModel)
+		max_tokens: selectedModel?.capabilities?.limits?.max_output_tokens
 	} : finalPayload;
 	if (isNullish(originalPayload.max_tokens)) consola.debug("Set max_tokens to:", JSON.stringify(payload.max_tokens));
 	if (state.manualApprove) await awaitApproval();
+	return executeRequest({
+		c,
+		payload,
+		selectedModel,
+		ctx,
+		trackingId
+	});
+}
+/**
+* Execute the API call with enhanced error handling for 413 errors.
+*/
+async function executeRequest(opts) {
+	const { c, payload, selectedModel, ctx, trackingId } = opts;
 	try {
 		const response = await executeWithRateLimit(state, () => createChatCompletions(payload));
-		if (isNonStreaming$1(response)) return handleNonStreamingResponse$1(c, response, ctx);
+		if (isNonStreaming(response)) return handleNonStreamingResponse$1(c, response, ctx);
 		consola.debug("Streaming response");
-		updateTrackerStatus$1(trackingId, "streaming");
+		updateTrackerStatus(trackingId, "streaming");
 		return streamSSE(c, async (stream) => {
 			await handleStreamingResponse$1({
 				stream,
@@ -1687,39 +2153,11 @@ async function handleCompletion$1(c) {
 			});
 		});
 	} catch (error) {
-		recordErrorResponse$1(ctx, payload.model, error);
+		if (error instanceof HTTPError && error.status === 413) await logPayloadSizeInfo(payload, selectedModel);
+		recordErrorResponse(ctx, payload.model, error);
 		throw error;
 	}
 }
-async function buildFinalPayload$1(payload, model) {
-	if (!state.autoCompact || !model) {
-		if (state.autoCompact && !model) consola.warn(`Auto-compact: Model '${payload.model}' not found in cached models, skipping`);
-		return {
-			finalPayload: payload,
-			compactResult: null
-		};
-	}
-	try {
-		const check = await checkNeedsCompaction(payload, model);
-		consola.debug(`Auto-compact check: ${check.currentTokens} tokens, limit ${check.limit}, needed: ${check.needed}`);
-		if (!check.needed) return {
-			finalPayload: payload,
-			compactResult: null
-		};
-		consola.info(`Auto-compact triggered: ${check.currentTokens} tokens > ${check.limit} limit`);
-		const compactResult = await autoCompact(payload, model);
-		return {
-			finalPayload: compactResult.payload,
-			compactResult
-		};
-	} catch (error) {
-		consola.warn("Auto-compact failed, proceeding with original payload:", error);
-		return {
-			finalPayload: payload,
-			compactResult: null
-		};
-	}
-}
 async function logTokenCount(payload, selectedModel) {
 	try {
 		if (selectedModel) {
@@ -1730,27 +2168,6 @@ async function logTokenCount(payload, selectedModel) {
 		consola.debug("Failed to calculate token count:", error);
 	}
 }
-function updateTrackerModel$1(trackingId, model) {
-	if (!trackingId) return;
-	const request = requestTracker.getRequest(trackingId);
-	if (request) request.model = model;
-}
-function updateTrackerStatus$1(trackingId, status) {
-	if (!trackingId) return;
-	requestTracker.updateRequest(trackingId, { status });
-}
-function recordErrorResponse$1(ctx, model, error) {
-	recordResponse(ctx.historyId, {
-		success: false,
-		model,
-		usage: {
-			input_tokens: 0,
-			output_tokens: 0
-		},
-		error: error instanceof Error ? error.message : "Unknown error",
-		content: null
-	}, Date.now() - ctx.startTime);
-}
 function handleNonStreamingResponse$1(c, originalResponse, ctx) {
 	consola.debug("Non-streaming response:", JSON.stringify(originalResponse));
 	let response = originalResponse;
@@ -1848,7 +2265,7 @@ async function handleStreamingResponse$1(opts) {
 			acc.content += marker;
 		}
 		recordStreamSuccess(acc, payload.model, ctx);
-		completeTracking$1(ctx.trackingId, acc.inputTokens, acc.outputTokens);
+		completeTracking(ctx.trackingId, acc.inputTokens, acc.outputTokens);
 	} catch (error) {
 		recordStreamError({
 			acc,
@@ -1856,7 +2273,7 @@ async function handleStreamingResponse$1(opts) {
 			ctx,
 			error
 		});
-		failTracking$1(ctx.trackingId, error);
+		failTracking(ctx.trackingId, error);
 		throw error;
 	}
 }
@@ -1864,42 +2281,31 @@ function parseStreamChunk(chunk, acc) {
 	if (!chunk.data || chunk.data === "[DONE]") return;
 	try {
 		const parsed = JSON.parse(chunk.data);
-		accumulateModel(parsed, acc);
-		accumulateUsage(parsed, acc);
-		accumulateChoice(parsed.choices[0], acc);
-	} catch {}
-}
-function accumulateModel(parsed, acc) {
-	if (parsed.model && !acc.model) acc.model = parsed.model;
-}
-function accumulateUsage(parsed, acc) {
-	if (parsed.usage) {
-		acc.inputTokens = parsed.usage.prompt_tokens;
-		acc.outputTokens = parsed.usage.completion_tokens;
-	}
-}
-function accumulateChoice(choice, acc) {
-	if (!choice) return;
-	if (choice.delta.content) acc.content += choice.delta.content;
-	if (choice.delta.tool_calls) accumulateToolCalls(choice.delta.tool_calls, acc);
-	if (choice.finish_reason) acc.finishReason = choice.finish_reason;
-}
-function accumulateToolCalls(toolCalls, acc) {
-	if (!toolCalls) return;
-	for (const tc of toolCalls) {
-		const idx = tc.index;
-		if (!acc.toolCallMap.has(idx)) acc.toolCallMap.set(idx, {
-			id: tc.id ?? "",
-			name: tc.function?.name ?? "",
-			arguments: ""
-		});
-		const item = acc.toolCallMap.get(idx);
-		if (item) {
-			if (tc.id) item.id = tc.id;
-			if (tc.function?.name) item.name = tc.function.name;
-			if (tc.function?.arguments) item.arguments += tc.function.arguments;
+		if (parsed.model && !acc.model) acc.model = parsed.model;
+		if (parsed.usage) {
+			acc.inputTokens = parsed.usage.prompt_tokens;
+			acc.outputTokens = parsed.usage.completion_tokens;
 		}
-	}
+		const choice = parsed.choices[0];
+		if (choice) {
+			if (choice.delta.content) acc.content += choice.delta.content;
+			if (choice.delta.tool_calls) for (const tc of choice.delta.tool_calls) {
+				const idx = tc.index;
+				if (!acc.toolCallMap.has(idx)) acc.toolCallMap.set(idx, {
+					id: tc.id ?? "",
+					name: tc.function?.name ?? "",
+					arguments: ""
+				});
+				const item = acc.toolCallMap.get(idx);
+				if (item) {
+					if (tc.id) item.id = tc.id;
+					if (tc.function?.name) item.name = tc.function.name;
+					if (tc.function?.arguments) item.arguments += tc.function.arguments;
+				}
+			}
+			if (choice.finish_reason) acc.finishReason = choice.finish_reason;
+		}
+	} catch {}
 }
 function recordStreamSuccess(acc, fallbackModel, ctx) {
 	for (const tc of acc.toolCallMap.values()) if (tc.id && tc.name) acc.toolCalls.push(tc);
@@ -1931,35 +2337,6 @@ function recordStreamSuccess(acc, fallbackModel, ctx) {
 		})) : void 0
 	}, Date.now() - ctx.startTime);
 }
-function recordStreamError(opts) {
-	const { acc, fallbackModel, ctx, error } = opts;
-	recordResponse(ctx.historyId, {
-		success: false,
-		model: acc.model || fallbackModel,
-		usage: {
-			input_tokens: 0,
-			output_tokens: 0
-		},
-		error: error instanceof Error ? error.message : "Stream error",
-		content: null
-	}, Date.now() - ctx.startTime);
-}
-function completeTracking$1(trackingId, inputTokens, outputTokens) {
-	if (!trackingId) return;
-	requestTracker.updateRequest(trackingId, {
-		inputTokens,
-		outputTokens
-	});
-	requestTracker.completeRequest(trackingId, 200, {
-		inputTokens,
-		outputTokens
-	});
-}
-function failTracking$1(trackingId, error) {
-	if (!trackingId) return;
-	requestTracker.failRequest(trackingId, error instanceof Error ? error.message : "Stream error");
-}
-const isNonStreaming$1 = (response) => Object.hasOwn(response, "choices");
 function convertOpenAIMessages(messages) {
 	return messages.map((msg) => {
 		const result = {
@@ -3160,6 +3537,15 @@ function mapOpenAIStopReasonToAnthropic(finishReason) {
 //#endregion
 //#region src/routes/messages/non-stream-translation.ts
 const OPENAI_TOOL_NAME_LIMIT = 64;
+/**
+* Ensure all tool_use blocks have corresponding tool_result responses.
+* This handles edge cases where conversation history may be incomplete:
+* - Session interruptions where tool execution was cut off
+* - Previous request failures
+* - Client sending truncated history
+*
+* Adding placeholder responses prevents API errors and maintains protocol compliance.
+*/
 function fixMessageSequence(messages) {
 	const fixedMessages = [];
 	for (let i = 0; i < messages.length; i++) {
@@ -3318,7 +3704,7 @@ function getTruncatedToolName(originalName, toolNameMapping) {
 	for (let i = 0; i < originalName.length; i++) {
 		const char = originalName.codePointAt(i) ?? 0;
 		hash = (hash << 5) - hash + char;
-		hash = hash & hash;
+		hash = Math.trunc(hash);
 	}
 	const hashSuffix = Math.abs(hash).toString(36).slice(0, 8);
 	const truncatedName = originalName.slice(0, OPENAI_TOOL_NAME_LIMIT - 9) + "_" + hashSuffix;
@@ -3655,60 +4041,11 @@ async function handleCompletion(c) {
 			});
 		});
 	} catch (error) {
+		if (error instanceof HTTPError && error.status === 413) await logPayloadSizeInfo(openAIPayload, selectedModel);
 		recordErrorResponse(ctx, anthropicPayload.model, error);
 		throw error;
 	}
 }
-function updateTrackerModel(trackingId, model) {
-	if (!trackingId) return;
-	const request = requestTracker.getRequest(trackingId);
-	if (request) request.model = model;
-}
-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`);
-		return {
-			finalPayload: payload,
-			compactResult: null
-		};
-	}
-	try {
-		const check = await checkNeedsCompaction(payload, model);
-		consola.debug(`Auto-compact check: ${check.currentTokens} tokens, limit ${check.limit}, needed: ${check.needed}`);
-		if (!check.needed) return {
-			finalPayload: payload,
-			compactResult: null
-		};
-		consola.info(`Auto-compact triggered: ${check.currentTokens} tokens > ${check.limit} limit`);
-		const compactResult = await autoCompact(payload, model);
-		return {
-			finalPayload: compactResult.payload,
-			compactResult
-		};
-	} catch (error) {
-		consola.warn("Auto-compact failed, proceeding with original payload:", error);
-		return {
-			finalPayload: payload,
-			compactResult: null
-		};
-	}
-}
-function updateTrackerStatus(trackingId, status) {
-	if (!trackingId) return;
-	requestTracker.updateRequest(trackingId, { status });
-}
-function recordErrorResponse(ctx, model, error) {
-	recordResponse(ctx.historyId, {
-		success: false,
-		model,
-		usage: {
-			input_tokens: 0,
-			output_tokens: 0
-		},
-		error: error instanceof Error ? error.message : "Unknown error",
-		content: null
-	}, Date.now() - ctx.startTime);
-}
 function handleNonStreamingResponse(opts) {
 	const { c, response, toolNameMapping, ctx } = opts;
 	consola.debug("Non-streaming response from Copilot:", JSON.stringify(response).slice(-400));
@@ -3802,7 +4139,7 @@ async function handleStreamingResponse(opts) {
 		completeTracking(ctx.trackingId, acc.inputTokens, acc.outputTokens);
 	} catch (error) {
 		consola.error("Stream error:", error);
-		recordStreamingError({
+		recordStreamError({
 			acc,
 			fallbackModel: anthropicPayload.model,
 			ctx,
@@ -3942,34 +4279,6 @@ function recordStreamingResponse(acc, fallbackModel, ctx) {
 		toolCalls: acc.toolCalls.length > 0 ? acc.toolCalls : void 0
 	}, Date.now() - ctx.startTime);
 }
-function recordStreamingError(opts) {
-	const { acc, fallbackModel, ctx, error } = opts;
-	recordResponse(ctx.historyId, {
-		success: false,
-		model: acc.model || fallbackModel,
-		usage: {
-			input_tokens: 0,
-			output_tokens: 0
-		},
-		error: error instanceof Error ? error.message : "Stream error",
-		content: null
-	}, Date.now() - ctx.startTime);
-}
-function completeTracking(trackingId, inputTokens, outputTokens) {
-	if (!trackingId) return;
-	requestTracker.updateRequest(trackingId, {
-		inputTokens,
-		outputTokens
-	});
-	requestTracker.completeRequest(trackingId, 200, {
-		inputTokens,
-		outputTokens
-	});
-}
-function failTracking(trackingId, error) {
-	if (!trackingId) return;
-	requestTracker.failRequest(trackingId, error instanceof Error ? error.message : "Stream error");
-}
 function convertAnthropicMessages(messages) {
 	return messages.map((msg) => {
 		if (typeof msg.content === "string") return {
@@ -4017,7 +4326,6 @@ function extractToolCallsFromContent(content) {
 	});
 	return tools.length > 0 ? tools : void 0;
 }
-const isNonStreaming = (response) => Object.hasOwn(response, "choices");
 
 //#endregion
 //#region src/routes/messages/route.ts
@@ -4320,7 +4628,8 @@ const main = defineCommand({
 		logout,
 		start,
 		"check-usage": checkUsage,
-		debug
+		debug,
+		"patch-claude": patchClaude
 	}
 });
 await runMain(main);