@dianshuv/copilot-api 0.11.3 → 0.12.0

package/README.md

@@ -46,11 +46,9 @@ make down
 | Command | Description |
 |---------|-------------|
 | `start` | Start the API server (handles auth if needed) |
-| `auth` | Run GitHub authentication flow only |
+| `login` | Run GitHub authentication flow only |
 | `logout` | Remove stored GitHub token |
-| `check-usage` | Show Copilot usage and quota |
 | `debug` | Display diagnostic information |
-| `patch-claude` | Patch Claude Code's context window limit |
 
 ### Start Command Options
 
@@ -60,45 +58,25 @@ make down
 | `--host`, `-H` | Host/interface to bind to (`0.0.0.0` = all interfaces) | `127.0.0.1` |
 | `--verbose`, `-v` | Enable verbose logging | false |
 | `--account-type`, `-a` | Account type (individual, business, enterprise) | individual |
-| `--manual` | Manual request approval mode | false |
 | `--no-rate-limit` | Disable adaptive rate limiting | false |
-| `--retry-interval` | Seconds to wait before retrying after rate limit | 10 |
-| `--request-interval` | Seconds between requests in rate-limited mode | 10 |
-| `--recovery-timeout` | Minutes before attempting recovery | 10 |
-| `--consecutive-successes` | Successes needed to exit rate-limited mode | 5 |
-| `--github-token`, `-g` | Provide GitHub token directly | none |
-| `--claude-code`, `-c` | Generate Claude Code launch command | false |
-| `--show-token` | Show tokens on fetch/refresh | false |
-| `--show-all-models` | Show all upstream models including the hardcoded blacklist (see "Hidden Models" below) | false |
-| `--proxy-env` | Use proxy from environment | false |
-| `--no-history` | Disable request history UI at `/history` | false |
-| `--history-limit` | Max history entries in memory | 1000 |
-| `--no-auto-truncate` | Disable auto-truncate when exceeding token limits | false |
-| `--compress-tool-results` | Compress old tool results before truncating | false |
-| `--redirect-anthropic` | Force Anthropic through OpenAI translation | false |
-| `--strip-server-tools` | Strip server-side tools from Anthropic requests | false |
-| `--context-editing` | Context editing mode: off, clear-thinking, clear-tooluse, clear-both | off |
-| `--timezone-offset` | Timezone offset in hours from UTC for log timestamps (e.g., +8, -5, 0) | +8 |
+| `--github-token`, `-g` | Provide GitHub token directly (or `GH_TOKEN` env) | none |
 | `--posthog-key` | PostHog API key for token usage analytics (opt-in) | none |
 | `--api-key` | Proxy API key for inbound authentication (see [Authentication](#authentication)). Empty = disabled | none |
 
 ### Hidden Models
 
 By default the proxy hides 30 stale / duplicate / unused upstream model ids from
-its **listing surfaces** (`/v1/models`, the startup banner, and the
-`--claude-code` interactive prompts). Pass `--show-all-models` to see the full
-upstream catalogue.
+its **listing surfaces** (`/v1/models` and the startup banner).
 
 **Important**: this is a *display* filter only. The remaining POST endpoints
 (`/v1/chat/completions`, `/v1/messages`, `/v1/responses`) do **not** reject
 hidden ids — an explicit `POST` with a hidden id is still forwarded to
-upstream verbatim, even without `--show-all-models`. (The embedding and
-Gemini ids in the list have no callable endpoint in this proxy at all;
-they're hidden purely to denoise the `/v1/models` listing — the upstream
-`/models` catalogue still returns them.)
+upstream verbatim. (The embedding and Gemini ids in the list have no callable
+endpoint in this proxy at all; they're hidden purely to denoise the
+`/v1/models` listing — the upstream `/models` catalogue still returns them.)
 
-To change the blacklist, edit `src/lib/hidden-models.ts` and re-publish (this
-fork uses `/publish`).
+To see the full catalogue or change the blacklist, edit
+`src/lib/hidden-models.ts` and re-publish (this fork uses `/publish`).
 
 Currently hidden (grouped):
 
@@ -111,15 +89,6 @@ Currently hidden (grouped):
 - **Older / variant Claude** — `claude-opus-4.5`, `claude-opus-4.6`, `claude-opus-4.7-high`, `claude-opus-4.7-xhigh`, `claude-sonnet-4.5`
 - **Special-purpose** — `mai-code-1-flash-internal`, `trajectory-compaction`
 
-### Patch-Claude Command Options
-
-| Option | Description | Default |
-|--------|-------------|---------|
-| `--limit`, `-l` | Context window limit in tokens | 128000 |
-| `--restore`, `-r` | Restore original 200k limit | false |
-| `--path`, `-p` | Path to Claude Code cli.js | auto-detect |
-| `--status`, `-s` | Show current patch status | false |
-
 ## API Endpoints
 
 ### OpenAI Compatible
@@ -155,7 +124,6 @@ When enabled (default), auto-truncate automatically compacts conversation histor
 
 - **Token-based truncation**: Uses the model's `max_context_window_tokens` from the Copilot API to determine when truncation is needed. A 2% safety margin is applied.
 - **No preset byte limit**: There is no hardcoded request body size limit. If the Copilot API returns a 413 (Request Entity Too Large), the proxy dynamically learns the byte limit and applies it to subsequent requests.
-- **Smart compression**: With `--compress-tool-results`, old tool results are compressed before removing messages, preserving more conversation context.
 - **Orphan filtering**: After truncation, orphaned tool results (without matching tool calls) are automatically removed.
 
 ## Authentication
@@ -244,9 +212,7 @@ Per client:
 - **Claude Code** (`.claude/settings.json`, see [below](#using-with-claude-code)):
   change `ANTHROPIC_AUTH_TOKEN` from `"dummy"` to your real key. Claude Code
   talks to the proxy's `/v1/messages` (Anthropic) surface; the auth gate accepts
-  the token from either header. `--claude-code` keeps emitting the `"dummy"`
-  placeholder on purpose (so the secret never lands in your clipboard / shell
-  history) and prints a reminder to replace it when auth is on.
+  the token from either header.
 - **Raw OpenAI SDK** → `Authorization: Bearer <key>`; **raw Anthropic SDK** →
   `x-api-key: <key>`.
 
@@ -308,12 +274,6 @@ Create `.claude/settings.json` in your project:
 }
 ```
 
-Or use the interactive setup:
-
-```sh
-bun run start --claude-code
-```
-
 ## Upstream Project
 
 For the original project documentation, features, and updates, see: [ericc-ch/copilot-api](https://github.com/ericc-ch/copilot-api)

package/dist/main.mjs

@@ -3,16 +3,12 @@ import { defineCommand, runMain } from "citty";
 import consola from "consola";
 import fs from "node:fs/promises";
 import os from "node:os";
-import path, { dirname, join } from "node:path";
+import path from "node:path";
 import { getProxyForUrl } from "proxy-from-env";
 import { Agent, ProxyAgent, setGlobalDispatcher } from "undici";
 import { createHash, randomUUID, timingSafeEqual } from "node:crypto";
-import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
-import clipboard from "clipboardy";
 import { serve } from "srvx";
 import { PostHog } from "posthog-node";
-import { execSync } from "node:child_process";
-import process$1 from "node:process";
 import pc from "picocolors";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
@@ -782,45 +778,6 @@ async function logUser() {
 	consola.info(`Logged in as ${user.login}`);
 }
 
-//#endregion
-//#region src/auth.ts
-async function runAuth(options) {
-	if (options.verbose) {
-		consola.level = 5;
-		consola.info("Verbose logging enabled");
-	}
-	state.showToken = options.showToken;
-	initProxyFromEnv();
-	await ensurePaths();
-	await setupGitHubToken({ force: true });
-	consola.success("GitHub token written to", PATHS.GITHUB_TOKEN_PATH);
-}
-const auth = defineCommand({
-	meta: {
-		name: "auth",
-		description: "Run GitHub auth flow without running the server"
-	},
-	args: {
-		verbose: {
-			alias: "v",
-			type: "boolean",
-			default: false,
-			description: "Enable verbose logging"
-		},
-		"show-token": {
-			type: "boolean",
-			default: false,
-			description: "Show GitHub token on auth"
-		}
-	},
-	run({ args }) {
-		return runAuth({
-			verbose: args.verbose,
-			showToken: args["show-token"]
-		});
-	}
-});
-
 //#endregion
 //#region src/services/github/get-copilot-usage.ts
 const getCopilotUsage = async () => {
@@ -829,43 +786,6 @@ const getCopilotUsage = async () => {
 	return await response.json();
 };
 
-//#endregion
-//#region src/check-usage.ts
-const checkUsage = defineCommand({
-	meta: {
-		name: "check-usage",
-		description: "Show current GitHub Copilot usage/quota information"
-	},
-	async run() {
-		initProxyFromEnv();
-		await ensurePaths();
-		await setupGitHubToken();
-		try {
-			const usage = await getCopilotUsage();
-			const premium = usage.quota_snapshots.premium_interactions;
-			const premiumTotal = premium.entitlement;
-			const premiumUsed = premiumTotal - premium.remaining;
-			const premiumPercentUsed = premiumTotal > 0 ? premiumUsed / premiumTotal * 100 : 0;
-			const premiumPercentRemaining = premium.percent_remaining;
-			function summarizeQuota(name, snap) {
-				if (!snap) return `${name}: N/A`;
-				const total = snap.entitlement;
-				const used = total - snap.remaining;
-				const percentUsed = total > 0 ? used / total * 100 : 0;
-				const percentRemaining = snap.percent_remaining;
-				return `${name}: ${used}/${total} used (${percentUsed.toFixed(1)}% used, ${percentRemaining.toFixed(1)}% remaining)`;
-			}
-			const premiumLine = `Premium: ${premiumUsed}/${premiumTotal} used (${premiumPercentUsed.toFixed(1)}% used, ${premiumPercentRemaining.toFixed(1)}% remaining)`;
-			const chatLine = summarizeQuota("Chat", usage.quota_snapshots.chat);
-			const completionsLine = summarizeQuota("Completions", usage.quota_snapshots.completions);
-			consola.box(`Copilot Usage (plan: ${usage.copilot_plan})\nQuota resets: ${usage.quota_reset_date}\n\nQuotas:\n  ${premiumLine}\n  ${chatLine}\n  ${completionsLine}`);
-		} catch (err) {
-			consola.error("Failed to fetch Copilot usage:", err);
-			process.exit(1);
-		}
-	}
-});
-
 //#endregion
 //#region src/debug.ts
 async function getPackageVersion() {
@@ -1008,6 +928,45 @@ const debug = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/login.ts
+async function runLogin(options) {
+	if (options.verbose) {
+		consola.level = 5;
+		consola.info("Verbose logging enabled");
+	}
+	state.showToken = options.showToken;
+	initProxyFromEnv();
+	await ensurePaths();
+	await setupGitHubToken({ force: true });
+	consola.success("GitHub token written to", PATHS.GITHUB_TOKEN_PATH);
+}
+const login = defineCommand({
+	meta: {
+		name: "login",
+		description: "Run GitHub auth flow without running the server"
+	},
+	args: {
+		verbose: {
+			alias: "v",
+			type: "boolean",
+			default: false,
+			description: "Enable verbose logging"
+		},
+		"show-token": {
+			type: "boolean",
+			default: false,
+			description: "Show GitHub token on auth"
+		}
+	},
+	run({ args }) {
+		return runLogin({
+			verbose: args.verbose,
+			showToken: args["show-token"]
+		});
+	}
+});
+
 //#endregion
 //#region src/logout.ts
 async function runLogout() {
@@ -1032,323 +991,9 @@ const logout = defineCommand({
 	}
 });
 
-//#endregion
-//#region src/patch-claude-code.ts
-const SUPPORTED_VERSIONS = {
-	v2a: {
-		min: "2.0.0",
-		max: "2.1.10"
-	},
-	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 ([A-Za-z_$]\w*)=(\d+)(?=,\w+=20000,)/
-};
-/**
-* 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) 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}+`;
-}
-/**
-* 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)) 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 all Claude Code CLI paths by checking common locations
-*/
-function findAllClaudeCodePaths() {
-	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 [...new Set(possiblePaths.filter((p) => existsSync(p)))];
-}
-/**
-* Get installation info for a CLI path
-*/
-function getInstallationInfo(cliPath) {
-	return {
-		path: cliPath,
-		version: getClaudeCodeVersion(cliPath),
-		limit: getCurrentLimit(readFileSync(cliPath, "utf8"))
-	};
-}
-function getCurrentLimitInfo(content) {
-	const varMatch = content.match(PATTERNS.variable);
-	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 ? { 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) {
-	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 "failed";
-	}
-	consola.info(`Claude Code version: ${versionCheck.version}`);
-	const limitInfo = getCurrentLimitInfo(content);
-	if (limitInfo?.limit === newLimit) return "already_patched";
-	let newContent;
-	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 "success";
-}
-/**
-* Restore Claude Code to original 200k limit
-*/
-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}`);
-	const limitInfo = getCurrentLimitInfo(content);
-	if (limitInfo?.limit === 2e5) {
-		consola.info("Already at original 200000 limit");
-		return true;
-	}
-	let newContent;
-	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;
-}
-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 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)`);
-}
-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"
-		}
-	},
-	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) => {
-					const info = getInstallationInfo(path);
-					let status = "unknown";
-					if (info.limit === 2e5) status = "original";
-					else if (info.limit) status = `patched: ${info.limit}`;
-					return {
-						label: `v${info.version ?? "?"} (${status}) - ${path}`,
-						value: path
-					};
-				});
-				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 currentLimit = getCurrentLimit(readFileSync(cliPath, "utf8"));
-		if (args.status) {
-			showStatus(cliPath, 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);
-		}
-		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 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");
-			process.exit(1);
-		}
-	}
-});
-
 //#endregion
 //#region package.json
-var version = "0.11.3";
+var version = "0.12.0";
 
 //#endregion
 //#region src/lib/adaptive-rate-limiter.ts
@@ -1872,37 +1517,6 @@ function buildStartupAuthLines(params) {
 	return [source === "none" ? `Inbound auth: 认证关闭 (no proxy API key configured)` : `Inbound auth: 认证开启 (source: ${source})`, `Binding to: ${bindAddress}`];
 }
 /**
-* The env var Claude Code reads for its inbound credential, and the placeholder
-* value the `--claude-code` setup always embeds for it. Exported so the
-* generated env script (src/start.ts) and the auth hint below reference the SAME
-* literals — changing the placeholder or the var name in one place can't silently
-* desync the other (the hint would otherwise keep naming a string the generated
-* command no longer contains).
-*/
-const CLAUDE_CODE_AUTH_TOKEN_ENV = "ANTHROPIC_AUTH_TOKEN";
-const CLAUDE_CODE_AUTH_TOKEN_PLACEHOLDER = "dummy";
-/**
-* Build the auth-aware hint lines for the `--claude-code` setup (Issue 05).
-*
-* The generated env script ALWAYS sets `ANTHROPIC_AUTH_TOKEN="dummy"` — a real
-* key is deliberately never embedded, so the secret can't land in the clipboard
-* or shell history. When inbound auth is ON, that placeholder won't authenticate
-* against this proxy, so the operator must replace it. This builder returns the
-* visible hint that tells them which variable to change:
-*  - auth OFF (`source === "none"`) → no hint (today's behavior, unchanged).
-*  - auth ON  (`flag` / `env`)      → a one-line hint naming
-*    `ANTHROPIC_AUTH_TOKEN` as the field to set to the proxy API key value.
-*
-* Like {@link buildStartupAuthLines}, the key value is **never** an input here —
-* the builder only knows the `source` tag — so it is structurally impossible for
-* the secret to leak into the hint. Pure (tag in → strings out) so the copy is
-* pinned by unit tests.
-*/
-function buildClaudeCodeAuthHint(source) {
-	if (source === "none") return [];
-	return [`Inbound auth is ON: replace ${CLAUDE_CODE_AUTH_TOKEN_ENV}="${CLAUDE_CODE_AUTH_TOKEN_PLACEHOLDER}" with your proxy API key value before using Claude Code.`];
-}
-/**
 * Configure the proxy API key on global state from a raw configured value.
 *
 * The value is trimmed; a trimmed-empty value (or `undefined`) is treated as
@@ -2841,58 +2455,6 @@ async function shutdownPostHog() {
 	}
 }
 
-//#endregion
-//#region src/lib/shell.ts
-function getShell() {
-	const { platform, ppid, env } = process$1;
-	if (platform === "win32") {
-		try {
-			if (execSync(`wmic process get ParentProcessId,Name | findstr "${ppid}"`, { stdio: "pipe" }).toString().toLowerCase().includes("powershell.exe")) return "powershell";
-		} catch {
-			return "cmd";
-		}
-		return "cmd";
-	} else {
-		const shellPath = env.SHELL;
-		if (shellPath) {
-			if (shellPath.endsWith("zsh")) return "zsh";
-			if (shellPath.endsWith("fish")) return "fish";
-			if (shellPath.endsWith("bash")) return "bash";
-		}
-		return "sh";
-	}
-}
-/**
-* Generates a copy-pasteable script to set multiple environment variables
-* and run a subsequent command.
-* @param {EnvVars} envVars - An object of environment variables to set.
-* @param {string} commandToRun - The command to run after setting the variables.
-* @returns {string} The formatted script string.
-*/
-function generateEnvScript(envVars, commandToRun = "") {
-	const shell = getShell();
-	const filteredEnvVars = Object.entries(envVars).filter(([, value]) => value !== void 0);
-	let commandBlock;
-	switch (shell) {
-		case "powershell":
-			commandBlock = filteredEnvVars.map(([key, value]) => `$env:${key} = "${value.replaceAll("\"", "`\"")}"`).join("; ");
-			break;
-		case "cmd":
-			commandBlock = filteredEnvVars.map(([key, value]) => `set ${key}=${value}`).join(" & ");
-			break;
-		case "fish":
-			commandBlock = filteredEnvVars.map(([key, value]) => `set -gx ${key} "${value.replaceAll("\"", String.raw`\"`)}"`).join("; ");
-			break;
-		default: {
-			const assignments = filteredEnvVars.map(([key, value]) => `${key}="${value.replaceAll("\"", String.raw`\"`)}"`).join(" ");
-			commandBlock = filteredEnvVars.length > 0 ? `export ${assignments}` : "";
-			break;
-		}
-	}
-	if (commandBlock && commandToRun) return `${commandBlock}${shell === "cmd" ? " & " : " && "}${commandToRun}`;
-	return commandBlock || commandToRun;
-}
-
 //#endregion
 //#region src/lib/shutdown.ts
 const DRAIN_POLL_INTERVAL_MS = 500;
@@ -7392,6 +6954,81 @@ function supportsDirectAnthropicApi(modelId) {
 	return resolveAnthropicModelForDirectPath(modelId) !== void 0;
 }
 
+//#endregion
+//#region src/lib/stream-keepalive.ts
+/** SSE comment line used as a keepalive heartbeat. */
+const SSE_PING = ": ping\n\n";
+/**
+* Grace period before opening a keepalive stream. Normal upstream responses
+* resolve sub-second (response headers arrive immediately, the body is not
+* buffered); only a request queued behind the rate limiter takes >=10s. 3s
+* cleanly separates the two — a request still pending after 3s is queued.
+*/
+const RATE_LIMIT_GRACE_MS = 3e3;
+/**
+* Interval between keepalive pings once the stream is open. Frequent enough to
+* prove liveness and defeat idle-connection drops, far below Claude Code's
+* default 10-minute request timeout.
+*/
+const KEEPALIVE_PING_INTERVAL_MS = 5e3;
+/**
+* Capture a promise's outcome as a value. The returned promise never rejects,
+* so it can be raced against a timer and awaited again later without producing
+* an unhandled rejection or a second pending chain on the original promise.
+*/
+function settle(promise) {
+	return promise.then((value) => ({
+		kind: "done",
+		value
+	}), (error) => ({
+		kind: "error",
+		error
+	}));
+}
+/**
+* Race an already-settled promise against a grace timer. Resolves with the
+* settled outcome if it arrives within `graceMs`, otherwise `{ kind: "timeout" }`.
+* The underlying work keeps running — await the SAME `settled` promise afterward
+* to obtain its eventual result.
+*/
+async function raceWithGrace(settled, graceMs) {
+	let timer;
+	const timeout = new Promise((resolve) => {
+		timer = setTimeout(() => resolve({ kind: "timeout" }), graceMs);
+	});
+	const result = await Promise.race([settled, timeout]);
+	if (timer !== void 0) clearTimeout(timer);
+	return result;
+}
+/**
+* Drive an open SSE stream while the upstream request is still queued: emit a
+* ping immediately, then every `pingIntervalMs`, until `settled` resolves —
+* then hand off to `onResponse` (success) or `onError` (failure). Pings stop on
+* client abort, on resolution, and never write to an aborted stream.
+*/
+async function runStreamWithKeepalive(opts) {
+	const { stream, settled, pingIntervalMs, onResponse, onError } = opts;
+	let pinging = true;
+	const sendPing = () => {
+		if (pinging && !stream.aborted) stream.write(SSE_PING);
+	};
+	sendPing();
+	const interval = setInterval(sendPing, pingIntervalMs);
+	stream.onAbort(() => {
+		pinging = false;
+		clearInterval(interval);
+	});
+	let result;
+	try {
+		result = await settled;
+	} finally {
+		pinging = false;
+		clearInterval(interval);
+	}
+	if (result.kind === "done") await onResponse(result.value);
+	else if (result.kind === "error") await onError(result.error);
+}
+
 //#endregion
 //#region src/routes/messages/message-utils.ts
 function convertAnthropicMessages(messages) {
@@ -8599,27 +8236,66 @@ async function handleDirectAnthropicCompletion(c, anthropicPayload, ctx, initiat
 	} else if (state.autoTruncate && !selectedModel) consola.debug(`[Anthropic] Model '${anthropicPayload.model}' not found, skipping auto-truncate`);
 	if (state.manualApprove) await awaitApproval();
 	const clientAnthropicBetaHeader = c.req.header("anthropic-beta");
+	const isStreaming = anthropicPayload.stream === true;
 	try {
-		const { result: response, queueWaitMs } = await executeWithAdaptiveRateLimit(() => createAnthropicMessages(effectivePayload, {
+		const settled = settle(executeWithAdaptiveRateLimit(() => createAnthropicMessages(effectivePayload, {
 			initiator: initiatorOverride,
 			injectContext1mBeta: needsContext1mBeta,
 			errorModelIdOverride: needsContext1mBeta ? originalModelId : void 0,
 			clientAnthropicBetaHeader
-		}));
-		ctx.queueWaitMs = queueWaitMs;
-		if (Symbol.asyncIterator in response) {
-			consola.debug("Streaming response from Copilot (direct Anthropic)");
-			updateTrackerStatus(ctx.trackingId, "streaming");
-			return streamSSE(c, async (stream) => {
-				await handleDirectAnthropicStreamingResponse({
-					stream,
-					response,
-					anthropicPayload: effectivePayload,
-					ctx
+		})));
+		const raced = isStreaming ? await raceWithGrace(settled, RATE_LIMIT_GRACE_MS) : await settled;
+		if (raced.kind === "error") throw raced.error;
+		if (raced.kind === "done") {
+			const { result: response, queueWaitMs } = raced.value;
+			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: effectivePayload,
+						ctx
+					});
 				});
-			});
+			}
+			return handleDirectAnthropicNonStreamingResponse(c, recoverLeakedToolCallsInResponse(response, toolNameSet(effectivePayload.tools)), ctx, truncateResult, effectivePayload);
 		}
-		return handleDirectAnthropicNonStreamingResponse(c, recoverLeakedToolCallsInResponse(response, toolNameSet(effectivePayload.tools)), ctx, truncateResult, effectivePayload);
+		consola.debug("[RateLimiter] Request queued past grace; opening keepalive stream (direct Anthropic)");
+		updateTrackerStatus(ctx.trackingId, "streaming");
+		return streamSSE(c, async (stream) => {
+			await runStreamWithKeepalive({
+				stream,
+				settled,
+				pingIntervalMs: KEEPALIVE_PING_INTERVAL_MS,
+				onResponse: async ({ result: response, queueWaitMs }) => {
+					ctx.queueWaitMs = queueWaitMs;
+					await handleDirectAnthropicStreamingResponse({
+						stream,
+						response,
+						anthropicPayload: effectivePayload,
+						ctx
+					});
+				},
+				onError: async (error) => {
+					recordStreamError({
+						acc: createAnthropicStreamAccumulator(),
+						fallbackModel: anthropicPayload.model,
+						ctx,
+						error,
+						endpoint: "messages"
+					});
+					failTracking(ctx.trackingId, error);
+					const errorEvent = translateErrorToAnthropicErrorEvent(error);
+					await stream.writeSSE({
+						event: errorEvent.type,
+						data: JSON.stringify(errorEvent)
+					});
+				}
+			});
+		});
 	} catch (error) {
 		if (error instanceof HTTPError && error.status === 413) logPayloadSizeInfoAnthropic(effectivePayload, selectedModel);
 		recordErrorResponse(ctx, anthropicPayload.model, error, "messages", anthropicPayload.stream ?? false);
@@ -8864,30 +8540,71 @@ async function handleTranslatedCompletion(c, anthropicPayload, ctx, initiatorOve
 	if (autoTruncateConfig.tokenLimitCacheKeyOverride !== void 0) errorModelIdOverride = autoTruncateConfig.tokenLimitCacheKeyOverride;
 	else if (needsContext1mBeta && selectedModel) errorModelIdOverride = selectedModel.id;
 	else if (hasOneMillionSuffix) errorModelIdOverride = originalModelId;
+	const isStreaming = anthropicPayload.stream === true;
 	try {
-		const { result: response, queueWaitMs } = await executeWithAdaptiveRateLimit(() => createChatCompletions(openAIPayload, {
+		const settled = settle(executeWithAdaptiveRateLimit(() => createChatCompletions(openAIPayload, {
 			initiator: initiatorOverride,
 			resolvedModel: selectedModel,
 			anthropicBeta,
 			errorModelIdOverride
-		}));
-		ctx.queueWaitMs = queueWaitMs;
-		if (isNonStreaming(response)) return handleNonStreamingResponse({
-			c,
-			response,
-			toolNameMapping,
-			ctx,
-			anthropicPayload
-		});
-		consola.debug("Streaming response from Copilot");
+		})));
+		const raced = isStreaming ? await raceWithGrace(settled, RATE_LIMIT_GRACE_MS) : await settled;
+		if (raced.kind === "error") throw raced.error;
+		if (raced.kind === "done") {
+			const { result: response, queueWaitMs } = raced.value;
+			ctx.queueWaitMs = queueWaitMs;
+			if (isNonStreaming(response)) return handleNonStreamingResponse({
+				c,
+				response,
+				toolNameMapping,
+				ctx,
+				anthropicPayload
+			});
+			consola.debug("Streaming response from Copilot");
+			updateTrackerStatus(ctx.trackingId, "streaming");
+			return streamSSE(c, async (stream) => {
+				await handleStreamingResponse({
+					stream,
+					response,
+					toolNameMapping,
+					anthropicPayload,
+					ctx
+				});
+			});
+		}
+		consola.debug("[RateLimiter] Request queued past grace; opening keepalive stream (translated)");
 		updateTrackerStatus(ctx.trackingId, "streaming");
 		return streamSSE(c, async (stream) => {
-			await handleStreamingResponse({
+			await runStreamWithKeepalive({
 				stream,
-				response,
-				toolNameMapping,
-				anthropicPayload,
-				ctx
+				settled,
+				pingIntervalMs: KEEPALIVE_PING_INTERVAL_MS,
+				onResponse: async ({ result: response, queueWaitMs }) => {
+					ctx.queueWaitMs = queueWaitMs;
+					if (isNonStreaming(response)) return;
+					await handleStreamingResponse({
+						stream,
+						response,
+						toolNameMapping,
+						anthropicPayload,
+						ctx
+					});
+				},
+				onError: async (error) => {
+					recordStreamError({
+						acc: createAnthropicStreamAccumulator(),
+						fallbackModel: anthropicPayload.model,
+						ctx,
+						error,
+						endpoint: "messages"
+					});
+					failTracking(ctx.trackingId, error);
+					const errorEvent = translateErrorToAnthropicErrorEvent(error);
+					await stream.writeSSE({
+						event: errorEvent.type,
+						data: JSON.stringify(errorEvent)
+					});
+				}
 			});
 		});
 	} catch (error) {
@@ -9770,7 +9487,6 @@ function formatModelInfo(model) {
 async function runServer(options) {
 	consola.info(`copilot-api v${version}`);
 	configureProxyApiKey(options.apiKey);
-	if (options.proxyEnv) initProxyFromEnv();
 	if (options.verbose) {
 		consola.level = 5;
 		consola.info("Verbose logging enabled");
@@ -9784,34 +9500,11 @@ async function runServer(options) {
 		process.exit(1);
 	}
 	if (options.accountType !== "individual") consola.info(`Using ${options.accountType} plan GitHub account`);
-	state.manualApprove = options.manual;
-	state.showToken = options.showToken;
-	state.showAllModels = options.showAllModels;
-	if (options.showAllModels) consola.warn("--show-all-models: hidden model blacklist is BYPASSED for this run");
-	state.autoTruncate = options.autoTruncate;
-	state.compressToolResults = options.compressToolResults;
-	state.redirectAnthropic = options.redirectAnthropic;
-	state.stripServerTools = options.stripServerTools;
-	state.contextEditingMode = options.contextEditing;
-	state.timezoneOffset = options.timezoneOffset;
-	if (options.rateLimit) initAdaptiveRateLimiter({
-		baseRetryIntervalSeconds: options.retryInterval,
-		requestIntervalSeconds: options.requestInterval,
-		recoveryTimeoutMinutes: options.recoveryTimeout,
-		consecutiveSuccessesForRecovery: options.consecutiveSuccesses
-	});
+	if (options.rateLimit) initAdaptiveRateLimiter();
 	else consola.info("Rate limiting disabled");
-	if (!options.autoTruncate) consola.info("Auto-truncate disabled");
-	if (options.compressToolResults) consola.info("Tool result compression enabled");
-	if (options.redirectAnthropic) consola.info("Anthropic API redirect enabled (using OpenAI translation)");
-	if (options.stripServerTools) consola.info("Server-side tools will be stripped from requests");
-	if (options.contextEditing !== "off") consola.info(`Context editing mode: ${options.contextEditing}`);
-	initHistory(options.history, options.historyLimit);
-	if (options.history) {
-		const limitText = options.historyLimit === 0 ? "unlimited" : `max ${options.historyLimit}`;
-		consola.info(`History recording enabled (${limitText} entries)`);
-		startMemoryPressureMonitor();
-	}
+	initHistory(true, 1e3);
+	consola.info("History recording enabled (max 1000 entries)");
+	startMemoryPressureMonitor();
 	if (options.posthogKey) {
 		initPostHog(options.posthogKey);
 		if (isPostHogEnabled()) consola.info("PostHog analytics enabled");
@@ -9838,42 +9531,10 @@ async function runServer(options) {
 		process.exit(1);
 	}
 	const visibleModels = allModels.filter((m) => !isHiddenModel(m.id, state.showAllModels));
-	if (visibleModels.length === 0) consola.warn("All upstream models are filtered by the hardcoded blacklist. /v1/models will return an empty list, but explicit POSTs with a hidden id still pass through to upstream. Restart with --show-all-models to see the full catalogue.");
+	if (visibleModels.length === 0) consola.warn("All upstream models are filtered by the hardcoded blacklist. /v1/models will return an empty list, but explicit POSTs with a hidden id still pass through to upstream. Edit src/lib/hidden-models.ts to change the blacklist.");
 	else consola.info(`Available models:\n${visibleModels.map((m) => formatModelInfo(m)).join("\n")}`);
 	const serverUrl = `http://${resolveClientHost(options.host, void 0)}:${options.port}`;
-	if (options.claudeCode) {
-		if (visibleModels.length === 0) {
-			consola.error("--claude-code interactive setup needs at least one visible model. Restart with --show-all-models or update src/lib/hidden-models.ts.");
-			process.exit(1);
-		}
-		const selectedModel = await consola.prompt("Select a model to use with Claude Code", {
-			type: "select",
-			options: visibleModels.map((model) => model.id)
-		});
-		const selectedSmallModel = await consola.prompt("Select a small model to use with Claude Code", {
-			type: "select",
-			options: visibleModels.map((model) => model.id)
-		});
-		const command = generateEnvScript({
-			ANTHROPIC_BASE_URL: serverUrl,
-			[CLAUDE_CODE_AUTH_TOKEN_ENV]: CLAUDE_CODE_AUTH_TOKEN_PLACEHOLDER,
-			ANTHROPIC_MODEL: selectedModel,
-			ANTHROPIC_DEFAULT_SONNET_MODEL: selectedModel,
-			ANTHROPIC_SMALL_FAST_MODEL: selectedSmallModel,
-			ANTHROPIC_DEFAULT_HAIKU_MODEL: selectedSmallModel,
-			DISABLE_NON_ESSENTIAL_MODEL_CALLS: "1",
-			CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1"
-		}, "claude");
-		try {
-			clipboard.writeSync(command);
-			consola.success("Copied Claude Code command to clipboard!");
-		} catch {
-			consola.warn("Failed to copy to clipboard. Here is the Claude Code command:");
-			consola.log(command);
-		}
-		for (const line of buildClaudeCodeAuthHint(options.apiKeySource)) consola.warn(line);
-	}
-	consola.box(`🌐 Usage Viewer: https://ericc-ch.github.io/copilot-api?endpoint=${serverUrl}/usage${options.history ? `\n📜 History UI: ${serverUrl}/history` : ""}`);
+	consola.box(`🌐 Usage Viewer: https://ericc-ch.github.io/copilot-api?endpoint=${serverUrl}/usage\n📜 History UI: ${serverUrl}/history`);
 	for (const line of buildStartupAuthLines({
 		source: options.apiKeySource,
 		bindAddress: resolveBindAddress(options.host, void 0)
@@ -9894,23 +9555,6 @@ async function runServer(options) {
 		} }
 	}));
 }
-function parseTimezoneOffset(value) {
-	if (typeof value !== "string") return 8;
-	const n = Number(value);
-	if (!Number.isFinite(n)) return 8;
-	return n;
-}
-const validContextEditingModes = [
-	"off",
-	"clear-thinking",
-	"clear-tooluse",
-	"clear-both"
-];
-function parseContextEditing(value) {
-	if (validContextEditingModes.includes(value)) return value;
-	consola.warn(`Invalid context editing mode: "${value}", using "off". Valid: ${validContextEditingModes.join(", ")}`);
-	return "off";
-}
 const start = defineCommand({
 	meta: {
 		name: "start",
@@ -9940,101 +9584,15 @@ const start = defineCommand({
 			default: "individual",
 			description: "Account type to use (individual, business, enterprise)"
 		},
-		manual: {
-			type: "boolean",
-			default: false,
-			description: "Enable manual request approval"
-		},
 		"no-rate-limit": {
 			type: "boolean",
 			default: false,
 			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",
 			type: "string",
-			description: "Provide GitHub token directly (must be generated using the `auth` subcommand). Falls back to the GH_TOKEN env var if the flag is omitted — prefer the env for automation since argv is visible via /proc/<pid>/cmdline."
-		},
-		"claude-code": {
-			alias: "c",
-			type: "boolean",
-			default: false,
-			description: "Generate a command to launch Claude Code with Copilot API config"
-		},
-		"show-token": {
-			type: "boolean",
-			default: false,
-			description: "Show GitHub and Copilot tokens on fetch and refresh"
-		},
-		"show-all-models": {
-			type: "boolean",
-			default: false,
-			description: "Show ALL upstream models, including the hardcoded blacklist (default: false, blacklist filtered from listings)"
-		},
-		"proxy-env": {
-			type: "boolean",
-			default: false,
-			description: "Initialize proxy from environment variables"
-		},
-		"no-history": {
-			type: "boolean",
-			default: false,
-			description: "Disable request history recording and Web UI"
-		},
-		"history-limit": {
-			type: "string",
-			default: "1000",
-			description: "Maximum number of history entries to keep in memory (0 = unlimited)"
-		},
-		"no-auto-truncate": {
-			type: "boolean",
-			default: false,
-			description: "Disable automatic conversation history truncation when exceeding limits"
-		},
-		"compress-tool-results": {
-			type: "boolean",
-			default: false,
-			description: "Compress old tool_result content before truncating messages (may lose context details)"
-		},
-		"redirect-anthropic": {
-			type: "boolean",
-			default: false,
-			description: "Redirect Anthropic models through OpenAI translation (instead of direct API)"
-		},
-		"strip-server-tools": {
-			type: "boolean",
-			default: false,
-			description: "Strip Anthropic server-side tools (web_search, etc.) from requests"
-		},
-		"context-editing": {
-			type: "string",
-			default: "off",
-			description: "Context editing mode: off, clear-thinking, clear-tooluse, clear-both"
-		},
-		"timezone-offset": {
-			type: "string",
-			default: "+8",
-			description: "Timezone offset in hours from UTC for log timestamps (e.g., +8, -5, 0)"
+			description: "Provide GitHub token directly (must be generated using the `login` subcommand). Falls back to the GH_TOKEN env var if the flag is omitted — prefer the env for automation since argv is visible via /proc/<pid>/cmdline."
 		},
 		"posthog-key": {
 			type: "string",
@@ -10055,25 +9613,8 @@ const start = defineCommand({
 			host: resolveBindHost(args.host, process.env.HOST),
 			verbose: args.verbose,
 			accountType: args["account-type"],
-			manual: args.manual,
 			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"] || process.env.GH_TOKEN,
-			claudeCode: args["claude-code"],
-			showToken: args["show-token"],
-			showAllModels: args["show-all-models"],
-			proxyEnv: args["proxy-env"],
-			history: !args["no-history"],
-			historyLimit: Number.parseInt(args["history-limit"], 10),
-			autoTruncate: !args["no-auto-truncate"],
-			compressToolResults: args["compress-tool-results"],
-			redirectAnthropic: args["redirect-anthropic"],
-			stripServerTools: args["strip-server-tools"],
-			contextEditing: parseContextEditing(args["context-editing"]),
-			timezoneOffset: parseTimezoneOffset(args["timezone-offset"]),
 			posthogKey: args["posthog-key"],
 			apiKey: resolvedApiKey.key,
 			apiKeySource: resolvedApiKey.source
@@ -10090,12 +9631,10 @@ await runMain(defineCommand({
 		description: "A wrapper around GitHub Copilot API to make it OpenAI compatible, making it usable for other tools."
 	},
 	subCommands: {
-		auth,
+		login,
 		logout,
 		start,
-		"check-usage": checkUsage,
-		debug,
-		"patch-claude": patchClaude
+		debug
 	}
 }));
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dianshuv/copilot-api",
-  "version": "0.11.3",
+  "version": "0.12.0",
   "description": "Turn GitHub Copilot into OpenAI/Anthropic API compatible server. Usable with Claude Code!",
   "author": "dianshuv",
   "type": "module",
@@ -36,7 +36,6 @@
   "dependencies": {
     "@anthropic-ai/tokenizer": "^0.0.4",
     "citty": "^0.2.0",
-    "clipboardy": "^5.1.0",
     "consola": "^3.4.2",
     "fetch-event-stream": "^0.1.6",
     "gpt-tokenizer": "^3.4.0",