@hsupu/copilot-api 0.7.5 → 0.7.7

package/dist/main.js

@@ -3,7 +3,7 @@ import { defineCommand, runMain } from "citty";
 import consola from "consola";
 import fs from "node:fs/promises";
 import os from "node:os";
-import path, { join } from "node:path";
+import path, { dirname, join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import clipboard from "clipboardy";
@@ -45,7 +45,6 @@ async function ensureFile(filePath) {
 const state = {
 	accountType: "individual",
 	manualApprove: false,
-	rateLimitWait: false,
 	showToken: false,
 	autoCompact: false
 };
@@ -137,6 +136,16 @@ function formatRequestTooLargeError() {
 		}
 	};
 }
+/** Format Anthropic-compatible error for rate limit exceeded (429) */
+function formatRateLimitError(copilotMessage) {
+	return {
+		type: "error",
+		error: {
+			type: "rate_limit_error",
+			message: copilotMessage ?? "You have exceeded your rate limit. Please try again later."
+		}
+	};
+}
 function forwardError(c, error) {
 	consola.error("Error occurred:", error);
 	if (error instanceof HTTPError) {
@@ -161,6 +170,11 @@ function forwardError(c, error) {
 				return c.json(formattedError, 400);
 			}
 		}
+		if (error.status === 429 || copilotError.error?.code === "rate_limited") {
+			const formattedError = formatRateLimitError(copilotError.error?.message);
+			consola.debug("Returning formatted rate limit error:", formattedError);
+			return c.json(formattedError, 429);
+		}
 		return c.json({ error: {
 			message: error.responseText,
 			type: "error"
@@ -539,16 +553,77 @@ 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+\}/;
+const SUPPORTED_VERSIONS = {
+	v2a: {
+		min: "2.0.0",
+		max: "2.1.10"
+	},
+	v2b: {
+		min: "2.1.11",
+		max: "2.1.12"
+	}
+};
+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+)/
+};
+/**
+* Parse semver version string to comparable parts
+*/
+function parseVersion(version) {
+	return version.split(".").map((n) => Number.parseInt(n, 10) || 0);
+}
+/**
+* Compare two semver versions
+* Returns: -1 if a < b, 0 if a == b, 1 if a > b
+*/
+function compareVersions(a, b) {
+	const partsA = parseVersion(a);
+	const partsB = parseVersion(b);
+	const len = Math.max(partsA.length, partsB.length);
+	for (let i = 0; i < len; i++) {
+		const numA = partsA[i] || 0;
+		const numB = partsB[i] || 0;
+		if (numA < numB) return -1;
+		if (numA > numB) return 1;
+	}
+	return 0;
+}
+function getPatternTypeForVersion(version) {
+	if (compareVersions(version, SUPPORTED_VERSIONS.v2a.min) >= 0 && compareVersions(version, SUPPORTED_VERSIONS.v2a.max) <= 0) return "func";
+	if (compareVersions(version, SUPPORTED_VERSIONS.v2b.min) >= 0 && compareVersions(version, SUPPORTED_VERSIONS.v2b.max) <= 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}`;
+}
+/**
+* Get Claude Code version from package.json
+*/
+function getClaudeCodeVersion(cliPath) {
+	try {
+		const packageJsonPath = join(dirname(cliPath), "package.json");
+		if (!existsSync(packageJsonPath)) return null;
+		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+		if (typeof packageJson === "object" && packageJson !== null && "version" in packageJson && typeof packageJson.version === "string") return packageJson.version;
+		return null;
+	} catch {
+		return null;
+	}
+}
 /**
 * Search volta tools directory for Claude Code
 */
 function findInVoltaTools(voltaHome) {
 	const paths = [];
+	const packagesPath = join(voltaHome, "tools", "image", "packages", "@anthropic-ai", "claude-code", "lib", "node_modules", "@anthropic-ai", "claude-code", "cli.js");
+	if (existsSync(packagesPath)) paths.push(packagesPath);
 	const toolsDir = join(voltaHome, "tools", "image", "node");
-	if (!existsSync(toolsDir)) return paths;
-	try {
+	if (existsSync(toolsDir)) 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);
@@ -580,25 +655,61 @@ function findClaudeCodePath() {
 * 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;
+	const varMatch = content.match(PATTERNS.variable);
+	if (varMatch) return Number.parseInt(varMatch[1], 10);
+	const funcMatch = content.match(PATTERNS.funcPatched);
+	if (funcMatch) {
+		const limitMatch = funcMatch[0].match(/return (\d+)\}$/);
+		return limitMatch ? Number.parseInt(limitMatch[1], 10) : null;
+	}
+	return null;
+}
+/**
+* Check if Claude Code version is supported for patching
+*/
+function checkVersionSupport(cliPath) {
+	const version = getClaudeCodeVersion(cliPath);
+	if (!version) return {
+		supported: false,
+		version: null,
+		patternType: null,
+		error: "Could not detect Claude Code version"
+	};
+	const patternType = getPatternTypeForVersion(version);
+	if (!patternType) return {
+		supported: false,
+		version,
+		patternType: null,
+		error: `Version ${version} is not supported. Supported: ${getSupportedRangeString()}`
+	};
+	return {
+		supported: true,
+		version,
+		patternType
+	};
 }
 /**
 * Patch Claude Code to use a different context limit
 */
 function patchClaudeCode(cliPath, newLimit) {
 	const content = readFileSync(cliPath, "utf8");
+	const versionCheck = checkVersionSupport(cliPath);
+	if (!versionCheck.supported) {
+		consola.error(versionCheck.error);
+		return false;
+	}
+	consola.info(`Claude Code version: ${versionCheck.version}`);
 	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;
+	if (versionCheck.patternType === "variable") newContent = content.replace(PATTERNS.variable, `var BS9=${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;
 }
@@ -607,19 +718,28 @@ function patchClaudeCode(cliPath, newLimit) {
 */
 function restoreClaudeCode(cliPath) {
 	const content = readFileSync(cliPath, "utf8");
+	const versionCheck = checkVersionSupport(cliPath);
+	if (!versionCheck.supported) {
+		consola.error(versionCheck.error);
+		return false;
+	}
+	consola.info(`Claude Code version: ${versionCheck.version}`);
 	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}");
+	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}");
 	writeFileSync(cliPath, newContent);
 	return true;
 }
-function showStatus(currentLimit) {
+function showStatus(cliPath, currentLimit) {
+	const version = getClaudeCodeVersion(cliPath);
+	if (version) consola.info(`Claude Code version: ${version}`);
 	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");
+		consola.info("Look for the BS9 variable or 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)`);
 }
@@ -669,7 +789,7 @@ const patchClaude = defineCommand({
 		const content = readFileSync(cliPath, "utf8");
 		const currentLimit = getCurrentLimit(content);
 		if (args.status) {
-			showStatus(currentLimit);
+			showStatus(cliPath, currentLimit);
 			return;
 		}
 		if (args.restore) {
@@ -698,6 +818,300 @@ const patchClaude = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/lib/adaptive-rate-limiter.ts
+const DEFAULT_CONFIG$1 = {
+	baseRetryIntervalSeconds: 10,
+	maxRetryIntervalSeconds: 120,
+	requestIntervalSeconds: 10,
+	recoveryTimeoutMinutes: 10,
+	consecutiveSuccessesForRecovery: 5,
+	gradualRecoverySteps: [
+		5,
+		2,
+		1,
+		0
+	]
+};
+/**
+* Adaptive rate limiter that switches between normal, rate-limited, and recovering modes
+* based on API responses.
+*/
+var AdaptiveRateLimiter = class {
+	config;
+	mode = "normal";
+	queue = [];
+	processing = false;
+	rateLimitedAt = null;
+	consecutiveSuccesses = 0;
+	lastRequestTime = 0;
+	/** Current step in gradual recovery (index into gradualRecoverySteps) */
+	recoveryStepIndex = 0;
+	constructor(config = {}) {
+		this.config = {
+			...DEFAULT_CONFIG$1,
+			...config
+		};
+	}
+	/**
+	* Execute a request with adaptive rate limiting.
+	* Returns a promise that resolves when the request succeeds.
+	* The request will be retried automatically on 429 errors.
+	*/
+	async execute(fn) {
+		if (this.mode === "normal") return this.executeInNormalMode(fn);
+		if (this.mode === "recovering") return this.executeInRecoveringMode(fn);
+		return this.enqueue(fn);
+	}
+	/**
+	* Check if an error is a rate limit error (429) and extract Retry-After if available
+	*/
+	isRateLimitError(error) {
+		if (error && typeof error === "object") {
+			if ("status" in error && error.status === 429) return {
+				isRateLimit: true,
+				retryAfter: this.extractRetryAfter(error)
+			};
+			if ("responseText" in error && typeof error.responseText === "string") try {
+				const parsed = JSON.parse(error.responseText);
+				if (parsed && typeof parsed === "object" && "error" in parsed && parsed.error && typeof parsed.error === "object" && "code" in parsed.error && parsed.error.code === "rate_limited") return { isRateLimit: true };
+			} catch {}
+		}
+		return { isRateLimit: false };
+	}
+	/**
+	* Extract Retry-After value from error response
+	*/
+	extractRetryAfter(error) {
+		if (!error || typeof error !== "object") return void 0;
+		if ("responseText" in error && typeof error.responseText === "string") try {
+			const parsed = JSON.parse(error.responseText);
+			if (parsed && typeof parsed === "object" && "retry_after" in parsed && typeof parsed.retry_after === "number") return parsed.retry_after;
+			if (parsed && typeof parsed === "object" && "error" in parsed && parsed.error && typeof parsed.error === "object" && "retry_after" in parsed.error && typeof parsed.error.retry_after === "number") return parsed.error.retry_after;
+		} catch {}
+	}
+	/**
+	* Execute in normal mode - full speed
+	*/
+	async executeInNormalMode(fn) {
+		try {
+			return {
+				result: await fn(),
+				queueWaitMs: 0
+			};
+		} catch (error) {
+			const { isRateLimit, retryAfter } = this.isRateLimitError(error);
+			if (isRateLimit) {
+				this.enterRateLimitedMode();
+				return this.enqueue(fn, retryAfter);
+			}
+			throw error;
+		}
+	}
+	/**
+	* Execute in recovering mode - gradual speedup
+	*/
+	async executeInRecoveringMode(fn) {
+		const startTime = Date.now();
+		const currentInterval = this.config.gradualRecoverySteps[this.recoveryStepIndex] ?? 0;
+		if (currentInterval > 0) {
+			const elapsedMs = Date.now() - this.lastRequestTime;
+			const requiredMs = currentInterval * 1e3;
+			if (this.lastRequestTime > 0 && elapsedMs < requiredMs) {
+				const waitMs = requiredMs - elapsedMs;
+				await this.sleep(waitMs);
+			}
+		}
+		this.lastRequestTime = Date.now();
+		try {
+			const result = await fn();
+			this.recoveryStepIndex++;
+			if (this.recoveryStepIndex >= this.config.gradualRecoverySteps.length) this.completeRecovery();
+			else {
+				const nextInterval = this.config.gradualRecoverySteps[this.recoveryStepIndex] ?? 0;
+				consola.info(`[RateLimiter] Recovery step ${this.recoveryStepIndex}/${this.config.gradualRecoverySteps.length} (next interval: ${nextInterval}s)`);
+			}
+			const queueWaitMs = Date.now() - startTime;
+			return {
+				result,
+				queueWaitMs
+			};
+		} catch (error) {
+			const { isRateLimit, retryAfter } = this.isRateLimitError(error);
+			if (isRateLimit) {
+				consola.warn("[RateLimiter] Hit rate limit during recovery, returning to rate-limited mode");
+				this.enterRateLimitedMode();
+				return this.enqueue(fn, retryAfter);
+			}
+			throw error;
+		}
+	}
+	/**
+	* Enter rate-limited mode
+	*/
+	enterRateLimitedMode() {
+		if (this.mode === "rate-limited") return;
+		this.mode = "rate-limited";
+		this.rateLimitedAt = Date.now();
+		this.consecutiveSuccesses = 0;
+		consola.warn(`[RateLimiter] Entering rate-limited mode. Requests will be queued with exponential backoff (base: ${this.config.baseRetryIntervalSeconds}s).`);
+	}
+	/**
+	* Check if we should try to recover to normal mode
+	*/
+	shouldAttemptRecovery() {
+		if (this.consecutiveSuccesses >= this.config.consecutiveSuccessesForRecovery) {
+			consola.info(`[RateLimiter] ${this.consecutiveSuccesses} consecutive successes. Starting gradual recovery.`);
+			return true;
+		}
+		if (this.rateLimitedAt) {
+			const elapsed = Date.now() - this.rateLimitedAt;
+			const timeout = this.config.recoveryTimeoutMinutes * 60 * 1e3;
+			if (elapsed >= timeout) {
+				consola.info(`[RateLimiter] ${this.config.recoveryTimeoutMinutes} minutes elapsed. Starting gradual recovery.`);
+				return true;
+			}
+		}
+		return false;
+	}
+	/**
+	* Start gradual recovery mode
+	*/
+	startGradualRecovery() {
+		this.mode = "recovering";
+		this.recoveryStepIndex = 0;
+		this.rateLimitedAt = null;
+		this.consecutiveSuccesses = 0;
+		const firstInterval = this.config.gradualRecoverySteps[0] ?? 0;
+		consola.info(`[RateLimiter] Starting gradual recovery (${this.config.gradualRecoverySteps.length} steps, first interval: ${firstInterval}s)`);
+	}
+	/**
+	* Complete recovery to normal mode
+	*/
+	completeRecovery() {
+		this.mode = "normal";
+		this.recoveryStepIndex = 0;
+		consola.success("[RateLimiter] Recovery complete. Full speed enabled.");
+	}
+	/**
+	* Enqueue a request for later execution
+	*/
+	enqueue(fn, retryAfterSeconds) {
+		return new Promise((resolve, reject) => {
+			const request = {
+				execute: fn,
+				resolve,
+				reject,
+				retryCount: 0,
+				retryAfterSeconds,
+				enqueuedAt: Date.now()
+			};
+			this.queue.push(request);
+			if (this.queue.length > 1) {
+				const position = this.queue.length;
+				const estimatedWait = (position - 1) * this.config.requestIntervalSeconds;
+				consola.info(`[RateLimiter] Request queued (position ${position}, ~${estimatedWait}s wait)`);
+			}
+			this.processQueue();
+		});
+	}
+	/**
+	* Calculate retry interval with exponential backoff
+	*/
+	calculateRetryInterval(request) {
+		if (request.retryAfterSeconds !== void 0 && request.retryAfterSeconds > 0) return request.retryAfterSeconds;
+		const backoff = this.config.baseRetryIntervalSeconds * Math.pow(2, request.retryCount);
+		return Math.min(backoff, this.config.maxRetryIntervalSeconds);
+	}
+	/**
+	* Process the queue
+	*/
+	async processQueue() {
+		if (this.processing) return;
+		this.processing = true;
+		while (this.queue.length > 0) {
+			const request = this.queue[0];
+			if (this.shouldAttemptRecovery()) this.startGradualRecovery();
+			const elapsedMs = Date.now() - this.lastRequestTime;
+			const requiredMs = (request.retryCount > 0 ? this.calculateRetryInterval(request) : this.config.requestIntervalSeconds) * 1e3;
+			if (this.lastRequestTime > 0 && elapsedMs < requiredMs) {
+				const waitMs = requiredMs - elapsedMs;
+				const waitSec = Math.ceil(waitMs / 1e3);
+				consola.info(`[RateLimiter] Waiting ${waitSec}s before next request...`);
+				await this.sleep(waitMs);
+			}
+			this.lastRequestTime = Date.now();
+			try {
+				const result = await request.execute();
+				this.queue.shift();
+				this.consecutiveSuccesses++;
+				request.retryAfterSeconds = void 0;
+				const queueWaitMs = Date.now() - request.enqueuedAt;
+				request.resolve({
+					result,
+					queueWaitMs
+				});
+				if (this.mode === "rate-limited") consola.info(`[RateLimiter] Request succeeded (${this.consecutiveSuccesses}/${this.config.consecutiveSuccessesForRecovery} for recovery)`);
+			} catch (error) {
+				const { isRateLimit, retryAfter } = this.isRateLimitError(error);
+				if (isRateLimit) {
+					request.retryCount++;
+					request.retryAfterSeconds = retryAfter;
+					this.consecutiveSuccesses = 0;
+					this.rateLimitedAt = Date.now();
+					const nextInterval = this.calculateRetryInterval(request);
+					const source = retryAfter ? "server Retry-After" : "exponential backoff";
+					consola.warn(`[RateLimiter] Request failed with 429 (retry #${request.retryCount}). Retrying in ${nextInterval}s (${source})...`);
+				} else {
+					this.queue.shift();
+					request.reject(error);
+				}
+			}
+		}
+		this.processing = false;
+	}
+	sleep(ms) {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+	/**
+	* Get current status for debugging/monitoring
+	*/
+	getStatus() {
+		return {
+			mode: this.mode,
+			queueLength: this.queue.length,
+			consecutiveSuccesses: this.consecutiveSuccesses,
+			rateLimitedAt: this.rateLimitedAt
+		};
+	}
+};
+let rateLimiterInstance = null;
+/**
+* Initialize the adaptive rate limiter with configuration
+*/
+function initAdaptiveRateLimiter(config = {}) {
+	rateLimiterInstance = new AdaptiveRateLimiter(config);
+	const baseRetry = config.baseRetryIntervalSeconds ?? DEFAULT_CONFIG$1.baseRetryIntervalSeconds;
+	const maxRetry = config.maxRetryIntervalSeconds ?? DEFAULT_CONFIG$1.maxRetryIntervalSeconds;
+	const interval = config.requestIntervalSeconds ?? DEFAULT_CONFIG$1.requestIntervalSeconds;
+	const recovery = config.recoveryTimeoutMinutes ?? DEFAULT_CONFIG$1.recoveryTimeoutMinutes;
+	const successes = config.consecutiveSuccessesForRecovery ?? DEFAULT_CONFIG$1.consecutiveSuccessesForRecovery;
+	const steps = config.gradualRecoverySteps ?? DEFAULT_CONFIG$1.gradualRecoverySteps;
+	consola.info(`[RateLimiter] Initialized (backoff: ${baseRetry}s-${maxRetry}s, interval: ${interval}s, recovery: ${recovery}min or ${successes} successes, gradual: [${steps.join("s, ")}s])`);
+}
+/**
+* Execute a request with adaptive rate limiting.
+* If rate limiter is not initialized, executes immediately.
+* Returns the result along with queue wait time.
+*/
+async function executeWithAdaptiveRateLimit(fn) {
+	if (!rateLimiterInstance) return {
+		result: await fn(),
+		queueWaitMs: 0
+	};
+	return rateLimiterInstance.execute(fn);
+}
+
 //#endregion
 //#region src/lib/history.ts
 function generateId$1() {
@@ -1101,16 +1515,27 @@ function formatTokens(input, output) {
 /**
 * Console renderer that shows request lifecycle with apt-get style footer
 *
-* 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
+* Log format:
+* - Start: [....] HH:MM:SS METHOD /path model-name (debug only, dim)
+* - Streaming: [<-->] HH:MM:SS METHOD /path model-name streaming... (dim)
+* - Complete: [ OK ] HH:MM:SS METHOD /path model-name 200 1.2s 1.5K/500 (colored)
+* - Error: [FAIL] HH:MM:SS METHOD /path model-name 500 1.2s: error message (red)
+*
+* Color scheme for completed requests:
+* - Prefix: green (success) / red (error)
+* - Time: dim
+* - Method: cyan
+* - Path: white
+* - Model: magenta
+* - Status: green (success) / red (error)
+* - Duration: yellow
+* - Tokens: blue
 *
 * 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
+* - Start lines only shown in debug mode (--verbose)
+* - Streaming lines are dim (less important)
+* - /history API requests are always dim
+* - Sticky footer shows active request count
 * - Intercepts consola output to properly handle footer
 */
 var ConsoleRenderer = class {
@@ -1186,25 +1611,52 @@ var ConsoleRenderer = class {
 		}
 	}
 	/**
+	* Format a complete log line with colored parts
+	*/
+	formatLogLine(parts) {
+		const { prefix, time, method, path: path$1, model, status, duration, tokens, queueWait, extra, isError, isDim } = parts;
+		if (isDim) {
+			const modelPart = model ? ` ${model}` : "";
+			const extraPart = extra ? ` ${extra}` : "";
+			return pc.dim(`${prefix} ${time} ${method} ${path$1}${modelPart}${extraPart}`);
+		}
+		const coloredPrefix = isError ? pc.red(prefix) : pc.green(prefix);
+		const coloredTime = pc.dim(time);
+		const coloredMethod = pc.cyan(method);
+		const coloredPath = pc.white(path$1);
+		const coloredModel = model ? pc.magenta(` ${model}`) : "";
+		let result = `${coloredPrefix} ${coloredTime} ${coloredMethod} ${coloredPath}${coloredModel}`;
+		if (status !== void 0) {
+			const coloredStatus = isError ? pc.red(String(status)) : pc.green(String(status));
+			result += ` ${coloredStatus}`;
+		}
+		if (duration) result += ` ${pc.yellow(duration)}`;
+		if (queueWait) result += ` ${pc.dim(`(queued ${queueWait})`)}`;
+		if (tokens) result += ` ${pc.blue(tokens)}`;
+		if (extra) result += isError ? pc.red(extra) : extra;
+		return result;
+	}
+	/**
 	* Print a log line with proper footer handling
-	* 1. Clear footer if visible
-	* 2. Print log with newline
-	* 3. Re-render footer on new line (no newline after footer)
 	*/
-	printLog(message, isGray = false) {
+	printLog(message) {
 		this.clearFooterForLog();
-		if (isGray) process.stdout.write(pc.dim(message) + "\n");
-		else process.stdout.write(message + "\n");
+		process.stdout.write(message + "\n");
 		this.renderFooter();
 	}
 	onRequestStart(request) {
 		this.activeRequests.set(request.id, request);
-		if (this.showActive) {
-			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}`;
-			this.printLog(message, request.isHistoryAccess);
+		if (this.showActive && consola.level >= 5) {
+			const message = this.formatLogLine({
+				prefix: "[....]",
+				time: formatTime(),
+				method: request.method,
+				path: request.path,
+				model: request.model,
+				extra: request.queuePosition !== void 0 && request.queuePosition > 0 ? `[q#${request.queuePosition}]` : void 0,
+				isDim: true
+			});
+			this.printLog(message);
 		}
 	}
 	onRequestUpdate(id, update) {
@@ -1212,28 +1664,39 @@ var ConsoleRenderer = class {
 		if (!request) return;
 		Object.assign(request, update);
 		if (this.showActive && update.status === "streaming") {
-			const time = formatTime();
-			const modelInfo = request.model ? ` ${request.model}` : "";
-			const message = `[<-->] ${time} ${request.method} ${request.path}${modelInfo} streaming...`;
-			this.printLog(message, request.isHistoryAccess);
+			const message = this.formatLogLine({
+				prefix: "[<-->]",
+				time: formatTime(),
+				method: request.method,
+				path: request.path,
+				model: request.model,
+				extra: "streaming...",
+				isDim: true
+			});
+			this.printLog(message);
 		}
 	}
 	onRequestComplete(request) {
 		this.activeRequests.delete(request.id);
-		const time = formatTime();
 		const status = request.statusCode ?? 0;
-		const duration = formatDuration(request.durationMs ?? 0);
-		const tokens = request.model ? formatTokens(request.inputTokens, request.outputTokens) : "";
-		const modelInfo = request.model ? ` ${request.model}` : "";
 		const isError = request.status === "error" || status >= 400;
-		const prefix = isError ? "[FAIL]" : "[ OK ]";
-		const tokensPart = tokens ? ` ${tokens}` : "";
-		let content = `${prefix} ${time} ${request.method} ${request.path} ${status} ${duration}${tokensPart}${modelInfo}`;
-		if (isError) {
-			const errorInfo = request.error ? `: ${request.error}` : "";
-			content += errorInfo;
-		}
-		this.printLog(content, request.isHistoryAccess);
+		const tokens = request.model ? formatTokens(request.inputTokens, request.outputTokens) : void 0;
+		const queueWait = request.queueWaitMs && request.queueWaitMs > 100 ? formatDuration(request.queueWaitMs) : void 0;
+		const message = this.formatLogLine({
+			prefix: isError ? "[FAIL]" : "[ OK ]",
+			time: formatTime(),
+			method: request.method,
+			path: request.path,
+			model: request.model,
+			status,
+			duration: formatDuration(request.durationMs ?? 0),
+			queueWait,
+			tokens,
+			extra: isError && request.error ? `: ${request.error}` : void 0,
+			isError,
+			isDim: request.isHistoryAccess
+		});
+		this.printLog(message);
 	}
 	destroy() {
 		if (this.footerVisible && this.isTTY) {
@@ -1634,20 +2097,50 @@ const getTokenCount = async (payload, model) => {
 //#region src/lib/auto-compact.ts
 const DEFAULT_CONFIG = {
 	targetTokens: 12e4,
-	safetyMarginPercent: 2
+	safetyMarginPercent: 2,
+	maxRequestBodyBytes: 500 * 1024
 };
 /**
-* Check if payload needs compaction based on model limits.
+* Dynamic byte limit that adjusts based on 413 errors.
+* Starts at 500KB and can be adjusted when 413 errors are encountered.
+*/
+let dynamicByteLimitOverride = null;
+/**
+* Called when a 413 error is encountered with a specific payload size.
+* Adjusts the dynamic byte limit to 90% of the failing size.
+*/
+function onRequestTooLarge(failingBytes) {
+	const newLimit = Math.max(Math.floor(failingBytes * .9), 100 * 1024);
+	dynamicByteLimitOverride = newLimit;
+	consola.info(`[Auto-compact] Adjusted byte limit: ${Math.round(failingBytes / 1024)}KB failed, new limit: ${Math.round(newLimit / 1024)}KB`);
+}
+/**
+* Check if payload needs compaction based on model limits OR request body size.
 * Uses a safety margin to account for token counting differences.
 */
-async function checkNeedsCompaction(payload, model, safetyMarginPercent = 2) {
+async function checkNeedsCompaction(payload, model, config = {}) {
+	const cfg = {
+		...DEFAULT_CONFIG,
+		...config
+	};
 	const currentTokens = (await getTokenCount(payload, model)).input;
 	const rawLimit = model.capabilities?.limits?.max_prompt_tokens ?? 128e3;
-	const limit = Math.floor(rawLimit * (1 - safetyMarginPercent / 100));
+	const tokenLimit = Math.floor(rawLimit * (1 - cfg.safetyMarginPercent / 100));
+	const currentBytes = JSON.stringify(payload).length;
+	const byteLimit = dynamicByteLimitOverride ?? cfg.maxRequestBodyBytes;
+	const exceedsTokens = currentTokens > tokenLimit;
+	const exceedsBytes = currentBytes > byteLimit;
+	let reason;
+	if (exceedsTokens && exceedsBytes) reason = "both";
+	else if (exceedsTokens) reason = "tokens";
+	else if (exceedsBytes) reason = "bytes";
 	return {
-		needed: currentTokens > limit,
+		needed: exceedsTokens || exceedsBytes,
 		currentTokens,
-		limit
+		tokenLimit,
+		currentBytes,
+		byteLimit,
+		reason
 	};
 }
 /**
@@ -1754,7 +2247,7 @@ function createTruncationMarker(removedCount) {
 	};
 }
 /**
-* Perform auto-compaction on a payload that exceeds token limits.
+* Perform auto-compaction on a payload that exceeds token or size limits.
 * This uses simple truncation - no LLM calls required.
 * Uses iterative approach with decreasing target tokens until under limit.
 */
@@ -1765,21 +2258,29 @@ async function autoCompact(payload, model, config = {}) {
 	};
 	const originalTokens = (await getTokenCount(payload, model)).input;
 	const rawLimit = model.capabilities?.limits?.max_prompt_tokens ?? 128e3;
-	const limit = Math.floor(rawLimit * (1 - cfg.safetyMarginPercent / 100));
-	if (originalTokens <= limit) return {
+	const tokenLimit = Math.floor(rawLimit * (1 - cfg.safetyMarginPercent / 100));
+	const originalBytes = JSON.stringify(payload).length;
+	const byteLimit = dynamicByteLimitOverride ?? cfg.maxRequestBodyBytes;
+	if (originalTokens <= tokenLimit && originalBytes <= byteLimit) return {
 		payload,
 		wasCompacted: false,
 		originalTokens,
 		compactedTokens: originalTokens,
 		removedMessageCount: 0
 	};
-	consola.info(`Auto-compact: ${originalTokens} tokens exceeds limit of ${limit}, truncating...`);
+	const exceedsTokens = originalTokens > tokenLimit;
+	const exceedsBytes = originalBytes > byteLimit;
+	let reason;
+	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), truncating...`);
 	const { systemMessages, remainingMessages } = extractSystemMessages(payload.messages);
 	const systemTokens = estimateSystemTokens(systemMessages);
 	consola.debug(`Auto-compact: ${systemMessages.length} system messages (~${systemTokens} tokens)`);
 	const MAX_ITERATIONS = 5;
 	const MIN_TARGET = 2e4;
-	let currentTarget = Math.min(cfg.targetTokens, limit);
+	let currentTarget = Math.min(cfg.targetTokens, tokenLimit);
 	let lastResult = null;
 	for (let iteration = 0; iteration < MAX_ITERATIONS; iteration++) {
 		const result = await tryCompactWithTarget({
@@ -1789,16 +2290,21 @@ async function autoCompact(payload, model, config = {}) {
 			remainingMessages,
 			systemTokens,
 			targetTokens: currentTarget,
-			limit,
+			limit: tokenLimit,
 			originalTokens
 		});
 		if (!result.wasCompacted) return result;
 		lastResult = result;
-		if (result.compactedTokens <= limit) {
-			consola.info(`Auto-compact: ${originalTokens} → ${result.compactedTokens} tokens (removed ${result.removedMessageCount} messages)`);
+		const resultBytes = JSON.stringify(result.payload).length;
+		const underTokenLimit = result.compactedTokens <= tokenLimit;
+		const underByteLimit = resultBytes <= byteLimit;
+		if (underTokenLimit && underByteLimit) {
+			consola.info(`Auto-compact: ${originalTokens} → ${result.compactedTokens} tokens, ${Math.round(originalBytes / 1024)}KB → ${Math.round(resultBytes / 1024)}KB (removed ${result.removedMessageCount} messages)`);
 			return result;
 		}
-		consola.warn(`Auto-compact: Still over limit (${result.compactedTokens} > ${limit}), trying more aggressive truncation`);
+		const tokenStatus = underTokenLimit ? "OK" : `${result.compactedTokens} > ${tokenLimit}`;
+		const byteStatus = underByteLimit ? "OK" : `${Math.round(resultBytes / 1024)}KB > ${Math.round(byteLimit / 1024)}KB`;
+		consola.warn(`Auto-compact: Still over limit (tokens: ${tokenStatus}, size: ${byteStatus}), trying more aggressive truncation`);
 		currentTarget = Math.floor(currentTarget * .7);
 		if (currentTarget < MIN_TARGET) {
 			consola.error("Auto-compact: Cannot reduce further, target too low");
@@ -1874,66 +2380,6 @@ function createCompactionMarker(result) {
 	return `\n\n---\n[Auto-compacted: ${result.removedMessageCount} messages removed, ${result.originalTokens} → ${result.compactedTokens} tokens (${percentage}% reduction)]`;
 }
 
-//#endregion
-//#region src/lib/queue.ts
-var RequestQueue = class {
-	queue = [];
-	processing = false;
-	lastRequestTime = 0;
-	async enqueue(execute, rateLimitSeconds) {
-		return new Promise((resolve, reject) => {
-			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);
-				(waitTime > 10 ? consola.warn : consola.info)(`Rate limit: request queued (position ${position}, ~${waitTime}s wait)`);
-			}
-			this.processQueue(rateLimitSeconds);
-		});
-	}
-	async processQueue(rateLimitSeconds) {
-		if (this.processing) return;
-		this.processing = true;
-		while (this.queue.length > 0) {
-			const elapsedMs = Date.now() - this.lastRequestTime;
-			const requiredMs = rateLimitSeconds * 1e3;
-			if (this.lastRequestTime > 0 && elapsedMs < requiredMs) {
-				const waitMs = requiredMs - elapsedMs;
-				const waitSec = Math.ceil(waitMs / 1e3);
-				(waitSec > 10 ? consola.warn : consola.info)(`Rate limit: waiting ${waitSec}s before next request...`);
-				await new Promise((resolve) => setTimeout(resolve, waitMs));
-			}
-			const request = this.queue.shift();
-			if (!request) break;
-			this.lastRequestTime = Date.now();
-			try {
-				const result = await request.execute();
-				request.resolve(result);
-			} catch (error) {
-				request.reject(error);
-			}
-		}
-		this.processing = false;
-	}
-	get length() {
-		return this.queue.length;
-	}
-};
-const requestQueue = new RequestQueue();
-/**
-* Execute a request with rate limiting via queue.
-* Requests are queued and processed sequentially at the configured rate.
-*/
-async function executeWithRateLimit(state$1, execute) {
-	if (state$1.rateLimitSeconds === void 0) return execute();
-	return requestQueue.enqueue(execute, state$1.rateLimitSeconds);
-}
-
 //#endregion
 //#region src/services/copilot/create-chat-completions.ts
 const createChatCompletions = async (payload) => {
@@ -1984,11 +2430,12 @@ function recordErrorResponse(ctx, model, error) {
 	}, Date.now() - ctx.startTime);
 }
 /** Complete TUI tracking */
-function completeTracking(trackingId, inputTokens, outputTokens) {
+function completeTracking(trackingId, inputTokens, outputTokens, queueWaitMs) {
 	if (!trackingId) return;
 	requestTracker.updateRequest(trackingId, {
 		inputTokens,
-		outputTokens
+		outputTokens,
+		queueWaitMs
 	});
 	requestTracker.completeRequest(trackingId, 200, {
 		inputTokens,
@@ -2029,12 +2476,16 @@ async function buildFinalPayload(payload, model) {
 	}
 	try {
 		const check = await checkNeedsCompaction(payload, model);
-		consola.debug(`Auto-compact check: ${check.currentTokens} tokens, limit ${check.limit}, needed: ${check.needed}`);
+		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})` : ""}`);
 		if (!check.needed) return {
 			finalPayload: payload,
 			compactResult: null
 		};
-		consola.info(`Auto-compact triggered: ${check.currentTokens} tokens > ${check.limit} limit`);
+		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);
 		return {
 			finalPayload: compactResult.payload,
@@ -2050,11 +2501,13 @@ async function buildFinalPayload(payload, model) {
 }
 /**
 * Log helpful debugging information when a 413 error occurs.
+* Also adjusts the dynamic byte limit for future requests.
 */
 async function logPayloadSizeInfo(payload, model) {
 	const messageCount = payload.messages.length;
 	const bodySize = JSON.stringify(payload).length;
 	const bodySizeKB = Math.round(bodySize / 1024);
+	onRequestTooLarge(bodySize);
 	let imageCount = 0;
 	let largeMessages = 0;
 	let totalImageSize = 0;
@@ -2140,7 +2593,8 @@ async function handleCompletion$1(c) {
 async function executeRequest(opts) {
 	const { c, payload, selectedModel, ctx, trackingId } = opts;
 	try {
-		const response = await executeWithRateLimit(state, () => createChatCompletions(payload));
+		const { result: response, queueWaitMs } = await executeWithAdaptiveRateLimit(() => createChatCompletions(payload));
+		ctx.queueWaitMs = queueWaitMs;
 		if (isNonStreaming(response)) return handleNonStreamingResponse$1(c, response, ctx);
 		consola.debug("Streaming response");
 		updateTrackerStatus(trackingId, "streaming");
@@ -2199,7 +2653,8 @@ function handleNonStreamingResponse$1(c, originalResponse, ctx) {
 	}, Date.now() - ctx.startTime);
 	if (ctx.trackingId && usage) requestTracker.updateRequest(ctx.trackingId, {
 		inputTokens: usage.prompt_tokens,
-		outputTokens: usage.completion_tokens
+		outputTokens: usage.completion_tokens,
+		queueWaitMs: ctx.queueWaitMs
 	});
 	return c.json(response);
 }
@@ -2265,7 +2720,7 @@ async function handleStreamingResponse$1(opts) {
 			acc.content += marker;
 		}
 		recordStreamSuccess(acc, payload.model, ctx);
-		completeTracking(ctx.trackingId, acc.inputTokens, acc.outputTokens);
+		completeTracking(ctx.trackingId, acc.inputTokens, acc.outputTokens, ctx.queueWaitMs);
 	} catch (error) {
 		recordStreamError({
 			acc,
@@ -2364,7 +2819,7 @@ completionRoutes.post("/", async (c) => {
 	try {
 		return await handleCompletion$1(c);
 	} catch (error) {
-		return await forwardError(c, error);
+		return forwardError(c, error);
 	}
 });
 
@@ -2390,7 +2845,7 @@ embeddingRoutes.post("/", async (c) => {
 		const response = await createEmbeddings(payload);
 		return c.json(response);
 	} catch (error) {
-		return await forwardError(c, error);
+		return forwardError(c, error);
 	}
 });
 
@@ -4022,7 +4477,8 @@ async function handleCompletion(c) {
 	if (compactResult) ctx.compactResult = compactResult;
 	if (state.manualApprove) await awaitApproval();
 	try {
-		const response = await executeWithRateLimit(state, () => createChatCompletions(openAIPayload));
+		const { result: response, queueWaitMs } = await executeWithAdaptiveRateLimit(() => createChatCompletions(openAIPayload));
+		ctx.queueWaitMs = queueWaitMs;
 		if (isNonStreaming(response)) return handleNonStreamingResponse({
 			c,
 			response,
@@ -4080,7 +4536,8 @@ function handleNonStreamingResponse(opts) {
 	}, Date.now() - ctx.startTime);
 	if (ctx.trackingId) requestTracker.updateRequest(ctx.trackingId, {
 		inputTokens: anthropicResponse.usage.input_tokens,
-		outputTokens: anthropicResponse.usage.output_tokens
+		outputTokens: anthropicResponse.usage.output_tokens,
+		queueWaitMs: ctx.queueWaitMs
 	});
 	return c.json(anthropicResponse);
 }
@@ -4136,7 +4593,7 @@ async function handleStreamingResponse(opts) {
 			acc.content += marker;
 		}
 		recordStreamingResponse(acc, anthropicPayload.model, ctx);
-		completeTracking(ctx.trackingId, acc.inputTokens, acc.outputTokens);
+		completeTracking(ctx.trackingId, acc.inputTokens, acc.outputTokens, ctx.queueWaitMs);
 	} catch (error) {
 		consola.error("Stream error:", error);
 		recordStreamError({
@@ -4334,14 +4791,14 @@ messageRoutes.post("/", async (c) => {
 	try {
 		return await handleCompletion(c);
 	} catch (error) {
-		return await forwardError(c, error);
+		return forwardError(c, error);
 	}
 });
 messageRoutes.post("/count_tokens", async (c) => {
 	try {
 		return await handleCountTokens(c);
 	} catch (error) {
-		return await forwardError(c, error);
+		return forwardError(c, error);
 	}
 });
 
@@ -4380,18 +4837,18 @@ modelRoutes.get("/", async (c) => {
 			has_more: false
 		});
 	} catch (error) {
-		return await forwardError(c, error);
+		return forwardError(c, error);
 	}
 });
 
 //#endregion
 //#region src/routes/token/route.ts
 const tokenRoute = new Hono();
-tokenRoute.get("/", async (c) => {
+tokenRoute.get("/", (c) => {
 	try {
 		return c.json({ token: state.copilotToken });
 	} catch (error) {
-		return await forwardError(c, error);
+		return forwardError(c, error);
 	}
 });
 
@@ -4403,7 +4860,7 @@ usageRoute.get("/", async (c) => {
 		const usage = await getCopilotUsage();
 		return c.json(usage);
 	} catch (error) {
-		return await forwardError(c, error);
+		return forwardError(c, error);
 	}
 });
 
@@ -4455,10 +4912,15 @@ async function runServer(options) {
 	state.accountType = options.accountType;
 	if (options.accountType !== "individual") consola.info(`Using ${options.accountType} plan GitHub account`);
 	state.manualApprove = options.manual;
-	state.rateLimitSeconds = options.rateLimit;
-	state.rateLimitWait = options.rateLimitWait;
 	state.showToken = options.showToken;
 	state.autoCompact = options.autoCompact;
+	if (options.rateLimit) initAdaptiveRateLimiter({
+		baseRetryIntervalSeconds: options.retryInterval,
+		requestIntervalSeconds: options.requestInterval,
+		recoveryTimeoutMinutes: options.recoveryTimeout,
+		consecutiveSuccessesForRecovery: options.consecutiveSuccesses
+	});
+	else consola.info("Rate limiting disabled");
 	if (options.autoCompact) consola.info("Auto-compact enabled: will compress context when exceeding token limits");
 	initHistory(options.history, options.historyLimit);
 	if (options.history) {
@@ -4545,16 +5007,30 @@ const start = defineCommand({
 			default: false,
 			description: "Enable manual request approval"
 		},
-		"rate-limit": {
-			alias: "r",
-			type: "string",
-			description: "Rate limit in seconds between requests"
-		},
-		wait: {
-			alias: "w",
+		"no-rate-limit": {
 			type: "boolean",
 			default: false,
-			description: "Wait instead of error when rate limit is hit. Has no effect if rate limit is not set"
+			description: "Disable adaptive rate limiting"
+		},
+		"retry-interval": {
+			type: "string",
+			default: "10",
+			description: "Seconds to wait before retrying after rate limit error (default: 10)"
+		},
+		"request-interval": {
+			type: "string",
+			default: "10",
+			description: "Seconds between requests in rate-limited mode (default: 10)"
+		},
+		"recovery-timeout": {
+			type: "string",
+			default: "10",
+			description: "Minutes before attempting to recover from rate-limited mode (default: 10)"
+		},
+		"consecutive-successes": {
+			type: "string",
+			default: "5",
+			description: "Number of consecutive successes needed to recover from rate-limited mode (default: 5)"
 		},
 		"github-token": {
 			alias: "g",
@@ -4577,10 +5053,10 @@ const start = defineCommand({
 			default: false,
 			description: "Initialize proxy from environment variables"
 		},
-		history: {
+		"no-history": {
 			type: "boolean",
 			default: false,
-			description: "Enable request history recording and Web UI at /history"
+			description: "Disable request history recording and Web UI"
 		},
 		"history-limit": {
 			type: "string",
@@ -4594,21 +5070,22 @@ const start = defineCommand({
 		}
 	},
 	run({ args }) {
-		const rateLimitRaw = args["rate-limit"];
-		const rateLimit = rateLimitRaw === void 0 ? void 0 : Number.parseInt(rateLimitRaw, 10);
 		return runServer({
 			port: Number.parseInt(args.port, 10),
 			host: args.host,
 			verbose: args.verbose,
 			accountType: args["account-type"],
 			manual: args.manual,
-			rateLimit,
-			rateLimitWait: args.wait,
+			rateLimit: !args["no-rate-limit"],
+			retryInterval: Number.parseInt(args["retry-interval"], 10),
+			requestInterval: Number.parseInt(args["request-interval"], 10),
+			recoveryTimeout: Number.parseInt(args["recovery-timeout"], 10),
+			consecutiveSuccesses: Number.parseInt(args["consecutive-successes"], 10),
 			githubToken: args["github-token"],
 			claudeCode: args["claude-code"],
 			showToken: args["show-token"],
 			proxyEnv: args["proxy-env"],
-			history: args.history,
+			history: !args["no-history"],
 			historyLimit: Number.parseInt(args["history-limit"], 10),
 			autoCompact: args["auto-compact"]
 		});