ghc-proxy 0.1.1

package/dist/main.js

@@ -0,0 +1,1816 @@
+#!/usr/bin/env node
+import process from "node:process";
+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 { events } from "fetch-event-stream";
+import { randomUUID } from "node:crypto";
+import clipboard from "clipboardy";
+import { serve } from "srvx";
+import invariant from "tiny-invariant";
+import { getProxyForUrl } from "proxy-from-env";
+import { Agent, ProxyAgent, setGlobalDispatcher } from "undici";
+import { execSync } from "node:child_process";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { colorize } from "consola/utils";
+import { streamSSE } from "hono/streaming";
+import { z } from "zod";
+
+//#region src/lib/paths.ts
+const APP_DIR = path.join(os.homedir(), ".local", "share", "ghc-proxy");
+const CONFIG_PATH = path.join(APP_DIR, "config.json");
+const PATHS = {
+	APP_DIR,
+	CONFIG_PATH
+};
+async function ensurePaths() {
+	await fs.mkdir(PATHS.APP_DIR, { recursive: true });
+}
+
+//#endregion
+//#region src/lib/config.ts
+let cachedConfig = {};
+async function readConfig() {
+	try {
+		const content = await fs.readFile(PATHS.CONFIG_PATH, "utf8");
+		if (!content.trim()) {
+			cachedConfig = {};
+			return {};
+		}
+		const parsed = JSON.parse(content);
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+			consola.warn("config.json is not a valid object. Using defaults.");
+			cachedConfig = {};
+			return {};
+		}
+		cachedConfig = parsed;
+		return cachedConfig;
+	} catch (error) {
+		if (error.code === "ENOENT") {
+			cachedConfig = {};
+			return {};
+		}
+		consola.warn(`Failed to parse config.json: ${error.message}. Using defaults.`);
+		cachedConfig = {};
+		return {};
+	}
+}
+function getCachedConfig() {
+	return cachedConfig;
+}
+async function writeConfigField(field, value) {
+	try {
+		let existing = {};
+		try {
+			const content = await fs.readFile(PATHS.CONFIG_PATH, "utf8");
+			if (content.trim()) existing = JSON.parse(content);
+		} catch (error) {
+			if (error.code !== "ENOENT") consola.warn(`Could not read existing config.json: ${error.message}. Starting fresh.`);
+		}
+		const merged = {
+			...existing,
+			[field]: value
+		};
+		await fs.writeFile(PATHS.CONFIG_PATH, JSON.stringify(merged, null, 2), "utf8");
+		await fs.chmod(PATHS.CONFIG_PATH, 384);
+		cachedConfig = merged;
+	} catch (error) {
+		consola.error(`Failed to write config.json: ${error.message}`);
+		throw error;
+	}
+}
+
+//#endregion
+//#region src/lib/state.ts
+const state = {
+	auth: {},
+	config: {
+		accountType: "individual",
+		manualApprove: false,
+		rateLimitWait: false,
+		showToken: false
+	},
+	cache: {},
+	rateLimit: {}
+};
+
+//#endregion
+//#region src/lib/api-config.ts
+function standardHeaders() {
+	return {
+		"content-type": "application/json",
+		"accept": "application/json"
+	};
+}
+const COPILOT_VERSION = "0.26.7";
+const EDITOR_PLUGIN_VERSION = `copilot-chat/${COPILOT_VERSION}`;
+const USER_AGENT = `GitHubCopilotChat/${COPILOT_VERSION}`;
+const API_VERSION = "2025-04-01";
+function copilotBaseUrl(config) {
+	return config.accountType === "individual" ? "https://api.githubcopilot.com" : `https://api.${config.accountType}.githubcopilot.com`;
+}
+function copilotHeaders(auth$1, config, vision = false) {
+	const headers = {
+		"Authorization": `Bearer ${auth$1.copilotToken}`,
+		"content-type": standardHeaders()["content-type"],
+		"copilot-integration-id": "vscode-chat",
+		"editor-version": `vscode/${config.vsCodeVersion ?? "unknown"}`,
+		"editor-plugin-version": EDITOR_PLUGIN_VERSION,
+		"user-agent": USER_AGENT,
+		"openai-intent": "conversation-panel",
+		"x-github-api-version": API_VERSION,
+		"x-request-id": randomUUID(),
+		"x-vscode-user-agent-library-version": "electron-fetch"
+	};
+	if (vision) headers["copilot-vision-request"] = "true";
+	return headers;
+}
+const GITHUB_API_BASE_URL = "https://api.github.com";
+function githubHeaders(auth$1, config) {
+	return {
+		...standardHeaders(),
+		"authorization": `token ${auth$1.githubToken}`,
+		"editor-version": `vscode/${config.vsCodeVersion ?? "unknown"}`,
+		"editor-plugin-version": EDITOR_PLUGIN_VERSION,
+		"user-agent": USER_AGENT,
+		"x-github-api-version": API_VERSION,
+		"x-vscode-user-agent-library-version": "electron-fetch"
+	};
+}
+const GITHUB_BASE_URL = "https://github.com";
+const GITHUB_CLIENT_ID = "Iv1.b507a08c87ecfe98";
+const GITHUB_APP_SCOPES = ["read:user"].join(" ");
+
+//#endregion
+//#region src/lib/error.ts
+var HTTPError = class extends Error {
+	response;
+	constructor(message, response) {
+		super(message);
+		this.response = response;
+	}
+};
+async function forwardError(c, error) {
+	consola.error("Error occurred:", error);
+	if (error instanceof HTTPError) {
+		const errorText = await error.response.text();
+		let errorJson;
+		try {
+			errorJson = JSON.parse(errorText);
+		} catch {
+			errorJson = errorText;
+		}
+		consola.error("HTTP error:", errorJson);
+		return c.json({ error: {
+			message: errorText,
+			type: "error"
+		} }, error.response.status);
+	}
+	return c.json({ error: {
+		message: error.message,
+		type: "error"
+	} }, 500);
+}
+
+//#endregion
+//#region src/clients/copilot-client.ts
+var CopilotClient = class {
+	auth;
+	config;
+	fetchImpl;
+	constructor(auth$1, config, deps) {
+		this.auth = auth$1;
+		this.config = config;
+		this.fetchImpl = deps?.fetch ?? fetch;
+	}
+	async createChatCompletions(payload, options) {
+		if (!this.auth.copilotToken) throw new Error("Copilot token not found");
+		const enableVision = payload.messages.some((x) => typeof x.content !== "string" && x.content?.some((content) => content.type === "image_url"));
+		const isAgentCall = payload.messages.some((msg) => ["assistant", "tool"].includes(msg.role));
+		const headers = {
+			...copilotHeaders(this.auth, this.config, enableVision),
+			"X-Initiator": isAgentCall ? "agent" : "user"
+		};
+		const response = await this.fetchImpl(`${copilotBaseUrl(this.config)}/chat/completions`, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(payload),
+			signal: options?.signal
+		});
+		if (!response.ok) {
+			consola.error("Failed to create chat completions", response);
+			throw new HTTPError("Failed to create chat completions", response);
+		}
+		if (payload.stream) return events(response);
+		return await response.json();
+	}
+	async createEmbeddings(payload) {
+		if (!this.auth.copilotToken) throw new Error("Copilot token not found");
+		const response = await this.fetchImpl(`${copilotBaseUrl(this.config)}/embeddings`, {
+			method: "POST",
+			headers: copilotHeaders(this.auth, this.config),
+			body: JSON.stringify(payload)
+		});
+		if (!response.ok) throw new HTTPError("Failed to create embeddings", response);
+		return await response.json();
+	}
+	async getModels() {
+		const response = await this.fetchImpl(`${copilotBaseUrl(this.config)}/models`, { headers: copilotHeaders(this.auth, this.config) });
+		if (!response.ok) throw new HTTPError("Failed to get models", response);
+		return await response.json();
+	}
+};
+
+//#endregion
+//#region src/lib/client-config.ts
+function getClientConfig(appState) {
+	return {
+		accountType: appState.config.accountType,
+		vsCodeVersion: appState.cache.vsCodeVersion
+	};
+}
+
+//#endregion
+//#region src/lib/utils.ts
+function sleep(ms) {
+	return new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	});
+}
+function isNullish(value) {
+	return value === null || value === void 0;
+}
+async function cacheModels(client) {
+	const models = await (client ?? new CopilotClient(state.auth, getClientConfig(state))).getModels();
+	state.cache.models = models;
+}
+async function cacheVSCodeVersion() {
+	const response = await getVSCodeVersion();
+	state.cache.vsCodeVersion = response;
+	consola.info(`Using VSCode version: ${response}`);
+}
+
+//#endregion
+//#region src/clients/github-client.ts
+var GitHubClient = class {
+	auth;
+	config;
+	fetchImpl;
+	constructor(auth$1, config, deps) {
+		this.auth = auth$1;
+		this.config = config;
+		this.fetchImpl = deps?.fetch ?? fetch;
+	}
+	async getCopilotUsage() {
+		const response = await this.fetchImpl(`${GITHUB_API_BASE_URL}/copilot_internal/user`, { headers: githubHeaders(this.auth, this.config) });
+		if (!response.ok) throw new HTTPError("Failed to get Copilot usage", response);
+		return await response.json();
+	}
+	async getCopilotToken() {
+		const response = await this.fetchImpl(`${GITHUB_API_BASE_URL}/copilot_internal/v2/token`, { headers: githubHeaders(this.auth, this.config) });
+		if (!response.ok) throw new HTTPError("Failed to get Copilot token", response);
+		return await response.json();
+	}
+	async getDeviceCode() {
+		const response = await this.fetchImpl(`${GITHUB_BASE_URL}/login/device/code`, {
+			method: "POST",
+			headers: standardHeaders(),
+			body: JSON.stringify({
+				client_id: GITHUB_CLIENT_ID,
+				scope: GITHUB_APP_SCOPES
+			})
+		});
+		if (!response.ok) throw new HTTPError("Failed to get device code", response);
+		return await response.json();
+	}
+	async pollAccessToken(deviceCode) {
+		const sleepDuration = (deviceCode.interval + 1) * 1e3;
+		consola.debug(`Polling access token with interval of ${sleepDuration}ms`);
+		while (true) {
+			const response = await this.fetchImpl(`${GITHUB_BASE_URL}/login/oauth/access_token`, {
+				method: "POST",
+				headers: standardHeaders(),
+				body: JSON.stringify({
+					client_id: GITHUB_CLIENT_ID,
+					device_code: deviceCode.device_code,
+					grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+				})
+			});
+			if (!response.ok) {
+				await sleep(sleepDuration);
+				consola.error("Failed to poll access token:", await response.text());
+				continue;
+			}
+			const json = await response.json();
+			consola.debug("Polling access token response:", json);
+			if (json.access_token) return json.access_token;
+			await sleep(sleepDuration);
+		}
+	}
+	async getGitHubUser() {
+		const response = await this.fetchImpl(`${GITHUB_API_BASE_URL}/user`, { headers: {
+			authorization: `token ${this.auth.githubToken}`,
+			...standardHeaders()
+		} });
+		if (!response.ok) throw new HTTPError("Failed to get GitHub user", response);
+		return await response.json();
+	}
+};
+
+//#endregion
+//#region src/clients/vscode-client.ts
+const FALLBACK = "1.104.3";
+async function getVSCodeVersion() {
+	const controller = new AbortController();
+	const timeout = setTimeout(() => {
+		controller.abort();
+	}, 5e3);
+	try {
+		const match = (await (await fetch("https://aur.archlinux.org/cgit/aur.git/plain/PKGBUILD?h=visual-studio-code-bin", { signal: controller.signal })).text()).match(/pkgver=([0-9.]+)/);
+		if (match) return match[1];
+		return FALLBACK;
+	} catch {
+		return FALLBACK;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+
+//#endregion
+//#region src/lib/token.ts
+async function writeGithubToken(token) {
+	await writeConfigField("githubToken", token);
+}
+async function setupCopilotToken() {
+	await ensureVSCodeVersion();
+	const githubClient = createGitHubClient();
+	const { token, refresh_in } = await githubClient.getCopilotToken();
+	state.auth.copilotToken = token;
+	consola.debug("GitHub Copilot Token fetched successfully!");
+	if (state.config.showToken) consola.info("Copilot token:", token);
+	const refreshInterval = (refresh_in - 60) * 1e3;
+	const refreshCopilotToken = async () => {
+		consola.debug("Refreshing Copilot token");
+		try {
+			const { token: token$1 } = await githubClient.getCopilotToken();
+			state.auth.copilotToken = token$1;
+			consola.debug("Copilot token refreshed");
+			if (state.config.showToken) consola.info("Refreshed Copilot token:", token$1);
+		} catch (error) {
+			consola.error("Failed to refresh Copilot token:", error);
+		}
+	};
+	setInterval(() => {
+		refreshCopilotToken();
+	}, refreshInterval);
+}
+async function setupGitHubToken(options) {
+	try {
+		await ensureVSCodeVersion();
+		const githubToken = getCachedConfig().githubToken?.trim() || "";
+		if (githubToken && !options?.force) {
+			state.auth.githubToken = githubToken;
+			if (state.config.showToken) consola.info("GitHub token:", githubToken);
+			try {
+				await logUser();
+				return;
+			} catch (error) {
+				if (isAuthError(error) && !options?.force) {
+					consola.warn("Stored GitHub token invalid or expired. Re-authenticating...");
+					await setupGitHubToken({ force: true });
+					return;
+				}
+				throw error;
+			}
+		}
+		consola.info("Not logged in, getting new access token");
+		const githubClient = createGitHubClient();
+		const response = await githubClient.getDeviceCode();
+		consola.debug("Device code response:", response);
+		consola.info(`Please enter the code "${response.user_code}" in ${response.verification_uri}`);
+		const token = await githubClient.pollAccessToken(response);
+		await writeGithubToken(token);
+		state.auth.githubToken = token;
+		if (state.config.showToken) consola.info("GitHub token:", token);
+		await logUser();
+	} catch (error) {
+		if (error instanceof HTTPError) {
+			consola.error("Failed to get GitHub token:", await error.response.json());
+			throw error;
+		}
+		consola.error("Failed to get GitHub token:", error);
+		throw error;
+	}
+}
+function isAuthError(error) {
+	return error instanceof HTTPError && (error.response.status === 401 || error.response.status === 403);
+}
+async function logUser() {
+	const user = await createGitHubClient().getGitHubUser();
+	consola.info(`Logged in as ${user.login}`);
+}
+function createGitHubClient() {
+	return new GitHubClient(state.auth, getClientConfig(state));
+}
+async function ensureVSCodeVersion() {
+	if (!state.cache.vsCodeVersion) await cacheVSCodeVersion();
+}
+
+//#endregion
+//#region src/auth.ts
+async function runAuth(options) {
+	if (options.verbose) {
+		consola.level = 5;
+		consola.info("Verbose logging enabled");
+	}
+	state.config.showToken = options.showToken;
+	await ensurePaths();
+	await readConfig();
+	await cacheVSCodeVersion();
+	await setupGitHubToken({ force: true });
+	consola.success("GitHub token written to config.json");
+}
+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/check-usage.ts
+const checkUsage = defineCommand({
+	meta: {
+		name: "check-usage",
+		description: "Show current GitHub Copilot usage/quota information"
+	},
+	async run() {
+		await ensurePaths();
+		await readConfig();
+		await cacheVSCodeVersion();
+		await setupGitHubToken();
+		try {
+			const usage = await new GitHubClient(state.auth, getClientConfig(state)).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() {
+	try {
+		const packageJsonPath = new URL("../package.json", import.meta.url).pathname;
+		return JSON.parse(await fs.readFile(packageJsonPath)).version;
+	} catch {
+		return "unknown";
+	}
+}
+function getRuntimeInfo() {
+	return {
+		name: "bun",
+		version: Bun.version,
+		platform: os.platform(),
+		arch: os.arch()
+	};
+}
+function hasToken() {
+	try {
+		const config = getCachedConfig();
+		return Boolean(config.githubToken?.trim());
+	} catch {
+		return false;
+	}
+}
+async function checkConfigExists() {
+	try {
+		if (!(await fs.stat(PATHS.CONFIG_PATH)).isFile()) return false;
+		return (await fs.readFile(PATHS.CONFIG_PATH, "utf8")).trim().length > 0;
+	} catch {
+		return false;
+	}
+}
+async function getDebugInfo() {
+	const [version, configExists] = await Promise.all([getPackageVersion(), checkConfigExists()]);
+	return {
+		version,
+		runtime: getRuntimeInfo(),
+		paths: {
+			APP_DIR: PATHS.APP_DIR,
+			CONFIG_PATH: PATHS.CONFIG_PATH
+		},
+		configExists,
+		tokenExists: hasToken()
+	};
+}
+function printDebugInfoPlain(info) {
+	consola.info(`ghc-proxy debug
+
+Version: ${info.version}
+Runtime: ${info.runtime.name} ${info.runtime.version} (${info.runtime.platform} ${info.runtime.arch})
+
+Paths:
+- APP_DIR: ${info.paths.APP_DIR}
+- CONFIG_PATH: ${info.paths.CONFIG_PATH}
+
+Config exists: ${info.configExists ? "Yes" : "No"}
+Token exists: ${info.tokenExists ? "Yes" : "No"}`);
+}
+async function runDebug(options) {
+	const debugInfo = await getDebugInfo();
+	if (options.json) await Bun.write(Bun.stdout, `${JSON.stringify(debugInfo, null, 2)}\n`);
+	else printDebugInfoPlain(debugInfo);
+}
+const debug = defineCommand({
+	meta: {
+		name: "debug",
+		description: "Print debug information about the application"
+	},
+	args: { json: {
+		type: "boolean",
+		default: false,
+		description: "Output debug information as JSON"
+	} },
+	run({ args }) {
+		return runDebug({ json: args.json });
+	}
+});
+
+//#endregion
+//#region src/lib/proxy.ts
+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();
+			}
+		});
+		consola.debug("HTTP proxy configured from environment (per-URL)");
+	} catch (err) {
+		consola.debug("Proxy setup skipped:", err);
+	}
+}
+
+//#endregion
+//#region src/lib/shell.ts
+function getShell() {
+	const { platform, ppid, env } = process;
+	if (platform === "win32") {
+		try {
+			const command = `wmic process get ParentProcessId,Name | findstr "${ppid}"`;
+			if (execSync(command, { 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}`).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}`).join("; ");
+			break;
+		default: {
+			const assignments = filteredEnvVars.map(([key, value]) => `${key}=${value}`).join(" ");
+			commandBlock = filteredEnvVars.length > 0 ? `export ${assignments}` : "";
+			break;
+		}
+	}
+	if (commandBlock && commandToRun) return `${commandBlock}${shell === "cmd" ? " & " : " && "}${commandToRun}`;
+	return commandBlock || commandToRun;
+}
+
+//#endregion
+//#region src/lib/request-logger.ts
+function formatElapsed(start$1) {
+	const delta = Date.now() - start$1;
+	return delta < 1e3 ? `${delta}ms` : `${Math.round(delta / 1e3)}s`;
+}
+function formatPath(rawUrl) {
+	try {
+		const url = new URL(rawUrl);
+		return `${url.pathname}${url.search}`;
+	} catch {
+		return rawUrl;
+	}
+}
+function colorizeStatus(status) {
+	if (status >= 500) return colorize("red", status);
+	if (status >= 400) return colorize("yellow", status);
+	if (status >= 300) return colorize("cyan", status);
+	return colorize("green", status);
+}
+const methodColors = {
+	GET: "cyan",
+	POST: "magenta",
+	PUT: "yellow",
+	PATCH: "yellow",
+	DELETE: "red"
+};
+function colorizeMethod(method) {
+	return colorize(methodColors[method] ?? "white", method);
+}
+function formatModelMapping(info) {
+	if (!info) return "";
+	const { originalModel, mappedModel } = info;
+	if (!originalModel && !mappedModel) return "";
+	const original = originalModel ?? "-";
+	const mapped = mappedModel ?? "-";
+	if (original === mapped) return ` ${colorize("dim", "model=")}${colorize("blueBright", original)}`;
+	return ` ${colorize("dim", "model=")}${colorize("blueBright", original)} ${colorize("dim", "→")} ${colorize("greenBright", mapped)}`;
+}
+const requestLogger = async (c, next) => {
+	const { method, url } = c.req;
+	const path$1 = formatPath(url);
+	const start$1 = Date.now();
+	try {
+		await next();
+	} finally {
+		const elapsed = formatElapsed(start$1);
+		const status = c.res.status;
+		const modelInfo = c.get("modelMappingInfo");
+		const line = [
+			colorizeMethod(method),
+			colorize("white", path$1),
+			colorizeStatus(status),
+			colorize("dim", elapsed)
+		].join(" ");
+		consola.info(`${line}${formatModelMapping(modelInfo)}`);
+	}
+};
+function setModelMappingInfo(c, info) {
+	c.set("modelMappingInfo", info);
+}
+
+//#endregion
+//#region src/lib/approval.ts
+async function awaitApproval() {
+	if (!await consola.prompt(`Accept incoming request?`, { type: "confirm" })) throw new HTTPError("Request rejected", Response.json({ message: "Request rejected" }, { status: 403 }));
+}
+
+//#endregion
+//#region src/lib/rate-limit.ts
+async function checkRateLimit(state$1) {
+	if (state$1.config.rateLimitSeconds === void 0) return;
+	const now = Date.now();
+	if (!state$1.rateLimit.lastRequestTimestamp) {
+		state$1.rateLimit.lastRequestTimestamp = now;
+		return;
+	}
+	const elapsedSeconds = (now - state$1.rateLimit.lastRequestTimestamp) / 1e3;
+	if (elapsedSeconds > state$1.config.rateLimitSeconds) {
+		state$1.rateLimit.lastRequestTimestamp = now;
+		return;
+	}
+	const waitTimeSeconds = Math.ceil(state$1.config.rateLimitSeconds - elapsedSeconds);
+	if (!state$1.config.rateLimitWait) {
+		consola.warn(`Rate limit exceeded. Need to wait ${waitTimeSeconds} more seconds.`);
+		throw new HTTPError("Rate limit exceeded", Response.json({ message: "Rate limit exceeded" }, { status: 429 }));
+	}
+	const waitTimeMs = waitTimeSeconds * 1e3;
+	consola.warn(`Rate limit reached. Waiting ${waitTimeSeconds} seconds before proceeding...`);
+	await sleep(waitTimeMs);
+	state$1.rateLimit.lastRequestTimestamp = now;
+	consola.info("Rate limit wait completed, proceeding with request");
+}
+
+//#endregion
+//#region src/routes/middleware/request-guard.ts
+const requestGuard = async (c, next) => {
+	await checkRateLimit(state);
+	if (state.config.manualApprove) await awaitApproval();
+	await next();
+};
+
+//#endregion
+//#region src/lib/tokenizer.ts
+const ENCODING_MAP = {
+	o200k_base: () => import("gpt-tokenizer/encoding/o200k_base"),
+	cl100k_base: () => import("gpt-tokenizer/encoding/cl100k_base"),
+	p50k_base: () => import("gpt-tokenizer/encoding/p50k_base"),
+	p50k_edit: () => import("gpt-tokenizer/encoding/p50k_edit"),
+	r50k_base: () => import("gpt-tokenizer/encoding/r50k_base")
+};
+const encodingCache = /* @__PURE__ */ new Map();
+/**
+* Calculate tokens for tool calls
+*/
+function calculateToolCallsTokens(toolCalls, encoder, constants) {
+	let tokens = 0;
+	for (const toolCall of toolCalls) {
+		tokens += constants.funcInit;
+		tokens += encoder.encode(JSON.stringify(toolCall)).length;
+	}
+	tokens += constants.funcEnd;
+	return tokens;
+}
+/**
+* Calculate tokens for content parts
+*/
+function calculateContentPartsTokens(contentParts, encoder) {
+	let tokens = 0;
+	for (const part of contentParts) if (part.type === "image_url") tokens += encoder.encode(part.image_url.url).length + 85;
+	else if (part.text) tokens += encoder.encode(part.text).length;
+	return tokens;
+}
+/**
+* Calculate tokens for a single message
+*/
+function calculateMessageTokens(message, encoder, constants) {
+	const tokensPerMessage = 3;
+	const tokensPerName = 1;
+	let tokens = tokensPerMessage;
+	for (const [key, value] of Object.entries(message)) {
+		if (typeof value === "string") tokens += encoder.encode(value).length;
+		if (key === "name") tokens += tokensPerName;
+		if (key === "tool_calls") tokens += calculateToolCallsTokens(value, encoder, constants);
+		if (key === "content" && Array.isArray(value)) tokens += calculateContentPartsTokens(value, encoder);
+	}
+	return tokens;
+}
+/**
+* Calculate tokens using custom algorithm
+*/
+function calculateTokens(messages, encoder, constants) {
+	if (messages.length === 0) return 0;
+	let numTokens = 0;
+	for (const message of messages) numTokens += calculateMessageTokens(message, encoder, constants);
+	numTokens += 3;
+	return numTokens;
+}
+/**
+* Get the corresponding encoder module based on encoding type
+*/
+async function getEncodeChatFunction(encoding) {
+	if (encodingCache.has(encoding)) {
+		const cached = encodingCache.get(encoding);
+		if (cached) return cached;
+	}
+	const supportedEncoding = encoding;
+	if (!(supportedEncoding in ENCODING_MAP)) {
+		const fallbackModule = await ENCODING_MAP.o200k_base();
+		encodingCache.set(encoding, fallbackModule);
+		return fallbackModule;
+	}
+	const encodingModule = await ENCODING_MAP[supportedEncoding]();
+	encodingCache.set(encoding, encodingModule);
+	return encodingModule;
+}
+/**
+* Get tokenizer type from model information
+*/
+function getTokenizerFromModel(model) {
+	return model.capabilities.tokenizer || "o200k_base";
+}
+/**
+* Get model-specific constants for token calculation
+*/
+function getModelConstants(model) {
+	return model.id === "gpt-3.5-turbo" || model.id === "gpt-4" ? {
+		funcInit: 10,
+		propInit: 3,
+		propKey: 3,
+		enumInit: -3,
+		enumItem: 3,
+		funcEnd: 12
+	} : {
+		funcInit: 7,
+		propInit: 3,
+		propKey: 3,
+		enumInit: -3,
+		enumItem: 3,
+		funcEnd: 12
+	};
+}
+/**
+* Calculate tokens for a single parameter
+*/
+function calculateParameterTokens(key, prop, context) {
+	const { encoder, constants } = context;
+	let tokens = constants.propKey;
+	if (typeof prop !== "object" || prop === null) return tokens;
+	const param = prop;
+	const paramName = key;
+	const paramType = param.type || "string";
+	let paramDesc = param.description || "";
+	if (param.enum && Array.isArray(param.enum)) {
+		tokens += constants.enumInit;
+		for (const item of param.enum) {
+			tokens += constants.enumItem;
+			tokens += encoder.encode(String(item)).length;
+		}
+	}
+	if (paramDesc.endsWith(".")) paramDesc = paramDesc.slice(0, -1);
+	const line = `${paramName}:${paramType}:${paramDesc}`;
+	tokens += encoder.encode(line).length;
+	const excludedKeys = new Set([
+		"type",
+		"description",
+		"enum"
+	]);
+	for (const propertyName of Object.keys(param)) if (!excludedKeys.has(propertyName)) {
+		const propertyValue = param[propertyName];
+		const propertyText = typeof propertyValue === "string" ? propertyValue : JSON.stringify(propertyValue);
+		tokens += encoder.encode(`${propertyName}:${propertyText}`).length;
+	}
+	return tokens;
+}
+/**
+* Calculate tokens for function parameters
+*/
+function calculateParametersTokens(parameters, encoder, constants) {
+	if (!parameters || typeof parameters !== "object") return 0;
+	const params = parameters;
+	let tokens = 0;
+	for (const [key, value] of Object.entries(params)) if (key === "properties") {
+		const properties = value;
+		if (Object.keys(properties).length > 0) {
+			tokens += constants.propInit;
+			for (const propKey of Object.keys(properties)) tokens += calculateParameterTokens(propKey, properties[propKey], {
+				encoder,
+				constants
+			});
+		}
+	} else {
+		const paramText = typeof value === "string" ? value : JSON.stringify(value);
+		tokens += encoder.encode(`${key}:${paramText}`).length;
+	}
+	return tokens;
+}
+/**
+* Calculate tokens for a single tool
+*/
+function calculateToolTokens(tool, encoder, constants) {
+	let tokens = constants.funcInit;
+	const func = tool.function;
+	const fName = func.name;
+	let fDesc = func.description || "";
+	if (fDesc.endsWith(".")) fDesc = fDesc.slice(0, -1);
+	const line = `${fName}:${fDesc}`;
+	tokens += encoder.encode(line).length;
+	if (typeof func.parameters === "object" && func.parameters !== null) tokens += calculateParametersTokens(func.parameters, encoder, constants);
+	return tokens;
+}
+/**
+* Calculate token count for tools based on model
+*/
+function numTokensForTools(tools, encoder, constants) {
+	let funcTokenCount = 0;
+	for (const tool of tools) funcTokenCount += calculateToolTokens(tool, encoder, constants);
+	funcTokenCount += constants.funcEnd;
+	return funcTokenCount;
+}
+/**
+* Calculate the token count of messages, supporting multiple GPT encoders
+*/
+async function getTokenCount(payload, model) {
+	const tokenizer = getTokenizerFromModel(model);
+	const encoder = await getEncodeChatFunction(tokenizer);
+	const simplifiedMessages = payload.messages;
+	const inputMessages = simplifiedMessages.filter((msg) => msg.role !== "assistant");
+	const outputMessages = simplifiedMessages.filter((msg) => msg.role === "assistant");
+	const constants = getModelConstants(model);
+	let inputTokens = calculateTokens(inputMessages, encoder, constants);
+	if (payload.tools && payload.tools.length > 0) inputTokens += numTokensForTools(payload.tools, encoder, constants);
+	const outputTokens = calculateTokens(outputMessages, encoder, constants);
+	return {
+		input: inputTokens,
+		output: outputTokens
+	};
+}
+
+//#endregion
+//#region src/lib/validation.ts
+const openAIMessageSchema = z.object({
+	role: z.string(),
+	content: z.union([
+		z.string(),
+		z.array(z.any()),
+		z.null()
+	]),
+	name: z.string().optional(),
+	tool_calls: z.array(z.any()).optional(),
+	tool_call_id: z.string().optional()
+}).loose();
+const openAIChatPayloadSchema = z.object({
+	model: z.string(),
+	messages: z.array(openAIMessageSchema).min(1)
+}).loose();
+const anthropicMessageSchema = z.object({
+	role: z.enum(["user", "assistant"]),
+	content: z.union([z.string(), z.array(z.any())])
+}).loose();
+const anthropicMessagesBasePayloadSchema = z.object({
+	model: z.string(),
+	messages: z.array(anthropicMessageSchema).min(1)
+}).loose();
+const anthropicMessagesPayloadSchema = anthropicMessagesBasePayloadSchema.extend({ max_tokens: z.number() }).loose();
+const anthropicCountTokensPayloadSchema = anthropicMessagesBasePayloadSchema.extend({ max_tokens: z.number().optional() }).loose();
+const embeddingRequestSchema = z.object({
+	input: z.union([z.string(), z.array(z.string())]),
+	model: z.string()
+}).loose();
+function throwInvalidPayload(context, issues) {
+	consola.warn("Invalid request payload", {
+		context,
+		issues
+	});
+	throw new HTTPError("Invalid request payload", new Response("Invalid request payload", { status: 400 }));
+}
+function parseOpenAIChatPayload(payload) {
+	const result = openAIChatPayloadSchema.safeParse(payload);
+	if (!result.success) throwInvalidPayload("openai.chat", result.error.issues);
+	return result.data;
+}
+function parseAnthropicMessagesPayload(payload) {
+	const result = anthropicMessagesPayloadSchema.safeParse(payload);
+	if (!result.success) throwInvalidPayload("anthropic.messages", result.error.issues);
+	return result.data;
+}
+function parseAnthropicCountTokensPayload(payload) {
+	const result = anthropicCountTokensPayloadSchema.safeParse(payload);
+	if (!result.success) throwInvalidPayload("anthropic.messages.count_tokens", result.error.issues);
+	return result.data;
+}
+function parseEmbeddingRequest(payload) {
+	const result = embeddingRequestSchema.safeParse(payload);
+	if (!result.success) throwInvalidPayload("openai.embeddings", result.error.issues);
+	return result.data;
+}
+
+//#endregion
+//#region src/routes/chat-completions/handler.ts
+async function handleCompletion$1(c) {
+	let payload = parseOpenAIChatPayload(await c.req.json());
+	consola.debug("Request payload:", JSON.stringify(payload).slice(-400));
+	const selectedModel = state.cache.models?.data.find((model) => model.id === payload.model);
+	try {
+		if (selectedModel) {
+			const tokenCount = await getTokenCount(payload, selectedModel);
+			consola.info("Current token count:", tokenCount);
+		} else consola.warn("No model selected, skipping token count calculation");
+	} catch (error) {
+		consola.warn("Failed to calculate token count:", error);
+	}
+	if (isNullish(payload.max_tokens)) {
+		payload = {
+			...payload,
+			max_tokens: selectedModel?.capabilities.limits.max_output_tokens
+		};
+		consola.debug("Set max_tokens to:", JSON.stringify(payload.max_tokens));
+	}
+	const response = await new CopilotClient(state.auth, getClientConfig(state)).createChatCompletions(payload, { signal: c.req.raw.signal });
+	if (isNonStreaming$1(response)) {
+		consola.debug("Non-streaming response:", JSON.stringify(response));
+		return c.json(response);
+	}
+	consola.debug("Streaming response");
+	return streamSSE(c, async (stream) => {
+		try {
+			for await (const chunk of response) {
+				consola.debug("Streaming chunk:", JSON.stringify(chunk));
+				await stream.writeSSE(chunk);
+			}
+		} finally {}
+	});
+}
+function isNonStreaming$1(response) {
+	return Object.hasOwn(response, "choices");
+}
+
+//#endregion
+//#region src/routes/chat-completions/route.ts
+const completionRoutes = new Hono();
+completionRoutes.post("/", requestGuard, (c) => handleCompletion$1(c));
+
+//#endregion
+//#region src/routes/embeddings/route.ts
+const embeddingRoutes = new Hono();
+embeddingRoutes.post("/", async (c) => {
+	const payload = parseEmbeddingRequest(await c.req.json());
+	const response = await new CopilotClient(state.auth, getClientConfig(state)).createEmbeddings(payload);
+	return c.json(response);
+});
+
+//#endregion
+//#region src/translator/anthropic/shared.ts
+function mapOpenAIStopReasonToAnthropic(finishReason) {
+	if (finishReason === null) return null;
+	return {
+		stop: "end_turn",
+		length: "max_tokens",
+		tool_calls: "tool_use",
+		content_filter: "end_turn"
+	}[finishReason];
+}
+
+//#endregion
+//#region src/translator/anthropic/anthropic-stream-translator.ts
+var AnthropicStreamTranslator = class {
+	state;
+	constructor() {
+		this.state = {
+			messageStartSent: false,
+			contentBlockIndex: 0,
+			contentBlockOpen: false,
+			toolCalls: {}
+		};
+	}
+	onChunk(chunk) {
+		if (chunk.choices.length === 0) return [];
+		const events$1 = [];
+		const choice = chunk.choices[0];
+		const { delta } = choice;
+		this.appendMessageStart(events$1, chunk);
+		this.appendContentDelta(events$1, delta.content);
+		this.appendToolCalls(events$1, delta.tool_calls);
+		this.appendFinish(events$1, chunk, choice.finish_reason);
+		return events$1;
+	}
+	onError(error) {
+		return [{
+			type: "error",
+			error: {
+				type: "api_error",
+				message: this.getErrorMessage(error)
+			}
+		}];
+	}
+	getErrorMessage(error) {
+		if (this.isTimeoutError(error)) return "Upstream streaming request timed out. Please retry.";
+		return "An unexpected error occurred during streaming.";
+	}
+	isTimeoutError(error) {
+		if (error instanceof DOMException) return error.name === "TimeoutError";
+		if (error instanceof Error) return error.name === "TimeoutError";
+		return false;
+	}
+	isToolBlockOpen() {
+		if (!this.state.contentBlockOpen) return false;
+		return Object.values(this.state.toolCalls).some((tc) => {
+			return tc !== void 0 && tc.anthropicBlockIndex === this.state.contentBlockIndex;
+		});
+	}
+	appendMessageStart(events$1, chunk) {
+		if (this.state.messageStartSent) return;
+		events$1.push({
+			type: "message_start",
+			message: {
+				id: chunk.id,
+				type: "message",
+				role: "assistant",
+				content: [],
+				model: chunk.model,
+				stop_reason: null,
+				stop_sequence: null,
+				usage: {
+					input_tokens: (chunk.usage?.prompt_tokens ?? 0) - (chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0),
+					output_tokens: 0,
+					...chunk.usage?.prompt_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: chunk.usage.prompt_tokens_details.cached_tokens }
+				}
+			}
+		});
+		this.state.messageStartSent = true;
+	}
+	appendContentDelta(events$1, content) {
+		if (!content) return;
+		if (this.isToolBlockOpen()) {
+			events$1.push({
+				type: "content_block_stop",
+				index: this.state.contentBlockIndex
+			});
+			this.state.contentBlockIndex++;
+			this.state.contentBlockOpen = false;
+		}
+		if (!this.state.contentBlockOpen) {
+			events$1.push({
+				type: "content_block_start",
+				index: this.state.contentBlockIndex,
+				content_block: {
+					type: "text",
+					text: ""
+				}
+			});
+			this.state.contentBlockOpen = true;
+		}
+		events$1.push({
+			type: "content_block_delta",
+			index: this.state.contentBlockIndex,
+			delta: {
+				type: "text_delta",
+				text: content
+			}
+		});
+	}
+	appendToolCalls(events$1, toolCalls) {
+		if (!toolCalls || toolCalls.length === 0) return;
+		for (const toolCall of toolCalls) {
+			if (toolCall.id && toolCall.function?.name) {
+				if (this.state.contentBlockOpen) {
+					events$1.push({
+						type: "content_block_stop",
+						index: this.state.contentBlockIndex
+					});
+					this.state.contentBlockIndex++;
+					this.state.contentBlockOpen = false;
+				}
+				const anthropicBlockIndex = this.state.contentBlockIndex;
+				this.state.toolCalls[toolCall.index] = {
+					id: toolCall.id,
+					name: toolCall.function.name,
+					anthropicBlockIndex
+				};
+				events$1.push({
+					type: "content_block_start",
+					index: anthropicBlockIndex,
+					content_block: {
+						type: "tool_use",
+						id: toolCall.id,
+						name: toolCall.function.name,
+						input: {}
+					}
+				});
+				this.state.contentBlockOpen = true;
+			}
+			if (toolCall.function?.arguments) {
+				const toolCallInfo = this.state.toolCalls[toolCall.index];
+				if (!toolCallInfo) continue;
+				events$1.push({
+					type: "content_block_delta",
+					index: toolCallInfo.anthropicBlockIndex,
+					delta: {
+						type: "input_json_delta",
+						partial_json: toolCall.function.arguments
+					}
+				});
+			}
+		}
+	}
+	appendFinish(events$1, chunk, finishReason) {
+		if (!finishReason) return;
+		if (this.state.contentBlockOpen) {
+			events$1.push({
+				type: "content_block_stop",
+				index: this.state.contentBlockIndex
+			});
+			this.state.contentBlockOpen = false;
+		}
+		events$1.push({
+			type: "message_delta",
+			delta: {
+				stop_reason: mapOpenAIStopReasonToAnthropic(finishReason),
+				stop_sequence: null
+			},
+			usage: {
+				input_tokens: (chunk.usage?.prompt_tokens ?? 0) - (chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0),
+				output_tokens: chunk.usage?.completion_tokens ?? 0,
+				...chunk.usage?.prompt_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: chunk.usage.prompt_tokens_details.cached_tokens }
+			}
+		}, { type: "message_stop" });
+	}
+};
+
+//#endregion
+//#region src/lib/model-resolver.ts
+const DEFAULT_FALLBACKS = {
+	claudeOpus: "claude-opus-4.6",
+	claudeSonnet: "claude-sonnet-4.5",
+	claudeHaiku: "claude-haiku-4.5"
+};
+function getModelFallbackConfig() {
+	const cachedConfig$1 = getCachedConfig();
+	return {
+		claudeOpus: process.env.MODEL_FALLBACK_CLAUDE_OPUS || cachedConfig$1.modelFallback?.claudeOpus || DEFAULT_FALLBACKS.claudeOpus,
+		claudeSonnet: process.env.MODEL_FALLBACK_CLAUDE_SONNET || cachedConfig$1.modelFallback?.claudeSonnet || DEFAULT_FALLBACKS.claudeSonnet,
+		claudeHaiku: process.env.MODEL_FALLBACK_CLAUDE_HAIKU || cachedConfig$1.modelFallback?.claudeHaiku || DEFAULT_FALLBACKS.claudeHaiku
+	};
+}
+function resolveModel(modelId, knownModelIds, config) {
+	if (knownModelIds?.has(modelId)) return modelId;
+	if (modelId.startsWith("claude-opus-")) return config.claudeOpus;
+	if (modelId.startsWith("claude-sonnet-")) return config.claudeSonnet;
+	if (modelId.startsWith("claude-haiku-")) return config.claudeHaiku;
+	return modelId;
+}
+
+//#endregion
+//#region src/translator/anthropic/anthropic-translator.ts
+var AnthropicTranslator = class {
+	toOpenAI(payload) {
+		return {
+			model: this.translateModelName(payload.model),
+			messages: this.translateAnthropicMessagesToOpenAI(payload.messages, payload.system),
+			max_tokens: payload.max_tokens,
+			stop: payload.stop_sequences,
+			stream: payload.stream,
+			temperature: payload.temperature,
+			top_p: payload.top_p,
+			user: payload.metadata?.user_id,
+			tools: this.translateAnthropicToolsToOpenAI(payload.tools),
+			tool_choice: this.translateAnthropicToolChoiceToOpenAI(payload.tool_choice)
+		};
+	}
+	fromOpenAI(response) {
+		const allTextBlocks = [];
+		const allToolUseBlocks = [];
+		let stopReason = null;
+		stopReason = response.choices[0]?.finish_reason ?? stopReason;
+		for (const choice of response.choices) {
+			const textBlocks = this.getAnthropicTextBlocks(choice.message.content);
+			const toolUseBlocks = this.getAnthropicToolUseBlocks(choice.message.tool_calls);
+			allTextBlocks.push(...textBlocks);
+			allToolUseBlocks.push(...toolUseBlocks);
+			if (choice.finish_reason === "tool_calls" || stopReason === "stop") stopReason = choice.finish_reason;
+		}
+		return {
+			id: response.id,
+			type: "message",
+			role: "assistant",
+			model: response.model,
+			content: [...allTextBlocks, ...allToolUseBlocks],
+			stop_reason: mapOpenAIStopReasonToAnthropic(stopReason),
+			stop_sequence: null,
+			usage: {
+				input_tokens: (response.usage?.prompt_tokens ?? 0) - (response.usage?.prompt_tokens_details?.cached_tokens ?? 0),
+				output_tokens: response.usage?.completion_tokens ?? 0,
+				...response.usage?.prompt_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: response.usage.prompt_tokens_details.cached_tokens }
+			}
+		};
+	}
+	createStreamTranslator() {
+		return new AnthropicStreamTranslator();
+	}
+	translateModelName(model) {
+		const knownModelIds = state.cache.models ? new Set(state.cache.models.data.map((m) => m.id)) : void 0;
+		const config = getModelFallbackConfig();
+		return resolveModel(model, knownModelIds, config);
+	}
+	translateAnthropicMessagesToOpenAI(anthropicMessages, system) {
+		const systemMessages = this.handleSystemPrompt(system);
+		const otherMessages = anthropicMessages.flatMap((message) => message.role === "user" ? this.handleUserMessage(message) : this.handleAssistantMessage(message));
+		return [...systemMessages, ...otherMessages];
+	}
+	handleSystemPrompt(system) {
+		if (!system) return [];
+		if (typeof system === "string") return [{
+			role: "system",
+			content: system
+		}];
+		return [{
+			role: "system",
+			content: system.map((block) => block.text).join("\n\n")
+		}];
+	}
+	handleUserMessage(message) {
+		const newMessages = [];
+		if (Array.isArray(message.content)) {
+			const toolResultBlocks = message.content.filter((block) => block.type === "tool_result");
+			const otherBlocks = message.content.filter((block) => block.type !== "tool_result");
+			for (const block of toolResultBlocks) newMessages.push({
+				role: "tool",
+				tool_call_id: block.tool_use_id,
+				content: this.mapContent(block.content)
+			});
+			if (otherBlocks.length > 0) newMessages.push({
+				role: "user",
+				content: this.mapContent(otherBlocks)
+			});
+		} else newMessages.push({
+			role: "user",
+			content: this.mapContent(message.content)
+		});
+		return newMessages;
+	}
+	handleAssistantMessage(message) {
+		if (!Array.isArray(message.content)) return [{
+			role: "assistant",
+			content: this.mapContent(message.content)
+		}];
+		const toolUseBlocks = message.content.filter((block) => block.type === "tool_use");
+		const textBlocks = message.content.filter((block) => block.type === "text");
+		const thinkingBlocks = message.content.filter((block) => block.type === "thinking");
+		const allTextContent = [...textBlocks.map((b) => b.text), ...thinkingBlocks.map((b) => b.thinking)].join("\n\n");
+		return toolUseBlocks.length > 0 ? [{
+			role: "assistant",
+			content: allTextContent || null,
+			tool_calls: toolUseBlocks.map((toolUse) => ({
+				id: toolUse.id,
+				type: "function",
+				function: {
+					name: toolUse.name,
+					arguments: JSON.stringify(toolUse.input)
+				}
+			}))
+		}] : [{
+			role: "assistant",
+			content: this.mapContent(message.content)
+		}];
+	}
+	mapContent(content) {
+		if (typeof content === "string") return content;
+		if (!Array.isArray(content)) return null;
+		if (!content.some((block) => block.type === "image")) return content.filter((block) => block.type === "text" || block.type === "thinking").map((block) => block.type === "text" ? block.text : block.thinking).join("\n\n");
+		const contentParts = [];
+		for (const block of content) switch (block.type) {
+			case "text":
+				contentParts.push({
+					type: "text",
+					text: block.text
+				});
+				break;
+			case "thinking":
+				contentParts.push({
+					type: "text",
+					text: block.thinking
+				});
+				break;
+			case "image":
+				contentParts.push({
+					type: "image_url",
+					image_url: { url: `data:${block.source.media_type};base64,${block.source.data}` }
+				});
+				break;
+			default: break;
+		}
+		return contentParts;
+	}
+	translateAnthropicToolsToOpenAI(anthropicTools) {
+		if (!anthropicTools) return;
+		return anthropicTools.map((tool) => ({
+			type: "function",
+			function: {
+				name: tool.name,
+				description: tool.description,
+				parameters: tool.input_schema
+			}
+		}));
+	}
+	translateAnthropicToolChoiceToOpenAI(anthropicToolChoice) {
+		if (!anthropicToolChoice) return;
+		switch (anthropicToolChoice.type) {
+			case "auto": return "auto";
+			case "any": return "required";
+			case "tool":
+				if (anthropicToolChoice.name) return {
+					type: "function",
+					function: { name: anthropicToolChoice.name }
+				};
+				return;
+			case "none": return "none";
+			default: return;
+		}
+	}
+	getAnthropicTextBlocks(messageContent) {
+		if (typeof messageContent === "string") return [{
+			type: "text",
+			text: messageContent
+		}];
+		if (Array.isArray(messageContent)) return messageContent.filter((part) => part.type === "text").map((part) => ({
+			type: "text",
+			text: part.text
+		}));
+		return [];
+	}
+	getAnthropicToolUseBlocks(toolCalls) {
+		if (!toolCalls) return [];
+		return toolCalls.map((toolCall) => ({
+			type: "tool_use",
+			id: toolCall.id,
+			name: toolCall.function.name,
+			input: JSON.parse(toolCall.function.arguments)
+		}));
+	}
+};
+
+//#endregion
+//#region src/routes/messages/count-tokens-handler.ts
+/**
+* Handles token counting for Anthropic messages
+*/
+async function handleCountTokens(c) {
+	const anthropicBeta = c.req.header("anthropic-beta");
+	const anthropicPayload = parseAnthropicCountTokensPayload(await c.req.json());
+	const normalizedPayload = {
+		...anthropicPayload,
+		max_tokens: anthropicPayload.max_tokens ?? 0
+	};
+	const openAIPayload = new AnthropicTranslator().toOpenAI(normalizedPayload);
+	const selectedModel = state.cache.models?.data.find((model) => model.id === openAIPayload.model);
+	if (!selectedModel) throw new HTTPError(`Model not found for token counting: "${openAIPayload.model}"`, new Response(`Model not found for token counting: "${openAIPayload.model}"`, { status: 400 }));
+	const tokenCount = await getTokenCount(openAIPayload, selectedModel);
+	if (anthropicPayload.tools && anthropicPayload.tools.length > 0) {
+		let mcpToolExist = false;
+		if (anthropicBeta?.startsWith("claude-code")) mcpToolExist = anthropicPayload.tools.some((tool) => tool.name.startsWith("mcp__"));
+		if (!mcpToolExist) {
+			if (anthropicPayload.model.startsWith("claude")) tokenCount.input = tokenCount.input + 346;
+			else if (anthropicPayload.model.startsWith("grok")) tokenCount.input = tokenCount.input + 480;
+		}
+	}
+	let finalTokenCount = tokenCount.input + tokenCount.output;
+	if (anthropicPayload.model.startsWith("claude")) finalTokenCount = Math.round(finalTokenCount * 1.15);
+	else if (anthropicPayload.model.startsWith("grok")) finalTokenCount = Math.round(finalTokenCount * 1.03);
+	consola.info("Token count:", finalTokenCount);
+	return c.json({ input_tokens: finalTokenCount });
+}
+
+//#endregion
+//#region src/routes/messages/handler.ts
+async function handleCompletion(c) {
+	const anthropicPayload = parseAnthropicMessagesPayload(await c.req.json());
+	consola.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
+	const translator = new AnthropicTranslator();
+	const openAIPayload = translator.toOpenAI(anthropicPayload);
+	setModelMappingInfo(c, {
+		originalModel: anthropicPayload.model,
+		mappedModel: openAIPayload.model
+	});
+	consola.debug("Claude Code requested model:", anthropicPayload.model, "-> Copilot model:", openAIPayload.model);
+	consola.debug("Translated OpenAI request payload:", JSON.stringify(openAIPayload));
+	const response = await new CopilotClient(state.auth, getClientConfig(state)).createChatCompletions(openAIPayload, { signal: c.req.raw.signal });
+	if (isNonStreaming(response)) {
+		consola.debug("Non-streaming response from Copilot:", JSON.stringify(response).slice(-400));
+		const anthropicResponse = translator.fromOpenAI(response);
+		consola.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
+		return c.json(anthropicResponse);
+	}
+	consola.debug("Streaming response from Copilot");
+	return streamSSE(c, async (stream) => {
+		const streamTranslator = translator.createStreamTranslator();
+		try {
+			for await (const rawEvent of response) {
+				consola.debug("Copilot raw stream event:", JSON.stringify(rawEvent));
+				if (rawEvent.data === "[DONE]") break;
+				if (!rawEvent.data) continue;
+				const chunk = JSON.parse(rawEvent.data);
+				const events$1 = streamTranslator.onChunk(chunk);
+				for (const event of events$1) {
+					consola.debug("Translated Anthropic event:", JSON.stringify(event));
+					await stream.writeSSE({
+						event: event.type,
+						data: JSON.stringify(event)
+					});
+				}
+			}
+		} catch (error) {
+			if (c.req.raw.signal.aborted) {
+				consola.debug("Client disconnected during Anthropic stream");
+				return;
+			}
+			consola.error("Error streaming Anthropic response:", error);
+			const errorEvents = streamTranslator.onError(error);
+			for (const event of errorEvents) await stream.writeSSE({
+				event: event.type,
+				data: JSON.stringify(event)
+			});
+		}
+	});
+}
+function isNonStreaming(response) {
+	return Object.hasOwn(response, "choices");
+}
+
+//#endregion
+//#region src/routes/messages/route.ts
+const messageRoutes = new Hono();
+messageRoutes.post("/", requestGuard, (c) => handleCompletion(c));
+messageRoutes.post("/count_tokens", (c) => handleCountTokens(c));
+
+//#endregion
+//#region src/routes/models/route.ts
+const modelRoutes = new Hono();
+modelRoutes.get("/", async (c) => {
+	if (!state.cache.models) {
+		const copilotClient = new CopilotClient(state.auth, getClientConfig(state));
+		await cacheModels(copilotClient);
+	}
+	const models = state.cache.models?.data.map((model) => ({
+		id: model.id,
+		object: "model",
+		type: "model",
+		created: 0,
+		created_at: (/* @__PURE__ */ new Date(0)).toISOString(),
+		owned_by: model.vendor,
+		display_name: model.name
+	}));
+	return c.json({
+		object: "list",
+		data: models,
+		has_more: false
+	});
+});
+
+//#endregion
+//#region src/routes/token/route.ts
+const tokenRoute = new Hono();
+tokenRoute.get("/", (c) => {
+	return c.json({ token: state.auth.copilotToken });
+});
+
+//#endregion
+//#region src/routes/usage/route.ts
+const usageRoute = new Hono();
+usageRoute.get("/", async (c) => {
+	const usage = await new GitHubClient(state.auth, getClientConfig(state)).getCopilotUsage();
+	return c.json(usage);
+});
+
+//#endregion
+//#region src/server.ts
+const server = new Hono();
+server.use(requestLogger);
+server.use(cors());
+server.onError((error, c) => forwardError(c, error));
+server.get("/", (c) => c.text("Server running"));
+server.route("/chat/completions", completionRoutes);
+server.route("/models", modelRoutes);
+server.route("/embeddings", embeddingRoutes);
+server.route("/usage", usageRoute);
+server.route("/token", tokenRoute);
+server.route("/v1/chat/completions", completionRoutes);
+server.route("/v1/models", modelRoutes);
+server.route("/v1/embeddings", embeddingRoutes);
+server.route("/v1/messages", messageRoutes);
+
+//#endregion
+//#region src/start.ts
+async function maybeCopyClaudeCodeCommand(serverUrl) {
+	if (!state.cache.models) return;
+	const selectableModels = state.cache.models.data.filter((model) => model.model_picker_enabled);
+	const modelOptions = selectableModels.length > 0 ? selectableModels : state.cache.models.data;
+	const selectedModel = await consola.prompt("Select a model to use with Claude Code", {
+		type: "select",
+		options: modelOptions.map((model) => model.id)
+	});
+	const selectedSmallModel = await consola.prompt("Select a small model to use with Claude Code", {
+		type: "select",
+		options: modelOptions.map((model) => model.id)
+	});
+	const command = generateEnvScript({
+		ANTHROPIC_BASE_URL: serverUrl,
+		ANTHROPIC_AUTH_TOKEN: "dummy",
+		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);
+	}
+}
+async function runServer(options) {
+	const accountType = options.accountType === "individual" || options.accountType === "business" || options.accountType === "enterprise" ? options.accountType : "individual";
+	if (accountType !== options.accountType) consola.warn(`Unknown account type "${options.accountType}". Falling back to "individual".`);
+	if (options.proxyEnv) initProxyFromEnv();
+	if (options.verbose) {
+		consola.level = 5;
+		consola.info("Verbose logging enabled");
+	}
+	state.config.accountType = accountType;
+	if (accountType !== "individual") consola.info(`Using ${accountType} plan GitHub account`);
+	if (options.githubToken) {
+		state.auth.githubToken = options.githubToken;
+		consola.info("Using provided GitHub token");
+	}
+	state.config.manualApprove = options.manual;
+	state.config.rateLimitSeconds = options.rateLimit;
+	state.config.rateLimitWait = options.rateLimitWait;
+	state.config.showToken = options.showToken;
+	await ensurePaths();
+	await readConfig();
+	await cacheVSCodeVersion();
+	if (!options.githubToken) await setupGitHubToken();
+	await setupCopilotToken();
+	const clientConfig = {
+		...getClientConfig(state),
+		accountType
+	};
+	const copilotClient = new CopilotClient(state.auth, clientConfig);
+	await cacheModels(copilotClient);
+	consola.info(`Available models: \n${state.cache.models?.data.map((model) => `- ${model.id}`).join("\n")}`);
+	const serverUrl = `http://localhost:${options.port}`;
+	if (options.claudeCode) {
+		invariant(state.cache.models, "Models should be loaded by now");
+		await maybeCopyClaudeCodeCommand(serverUrl);
+	}
+	serve({
+		fetch: server.fetch,
+		port: options.port,
+		bun: options.idleTimeoutSeconds === void 0 ? void 0 : { idleTimeout: options.idleTimeoutSeconds }
+	});
+}
+const start = defineCommand({
+	meta: {
+		name: "start",
+		description: "Start the Copilot API server"
+	},
+	args: {
+		"port": {
+			alias: "p",
+			type: "string",
+			default: "4141",
+			description: "Port to listen on"
+		},
+		"verbose": {
+			alias: "v",
+			type: "boolean",
+			default: false,
+			description: "Enable verbose logging"
+		},
+		"account-type": {
+			alias: "a",
+			type: "string",
+			default: "individual",
+			description: "Account type to use (individual, business, enterprise)"
+		},
+		"manual": {
+			type: "boolean",
+			default: false,
+			description: "Enable manual request approval"
+		},
+		"rate-limit": {
+			alias: "r",
+			type: "string",
+			description: "Rate limit in seconds between requests"
+		},
+		"wait": {
+			alias: "w",
+			type: "boolean",
+			default: false,
+			description: "Wait instead of error when rate limit is hit. Has no effect if rate limit is not set"
+		},
+		"github-token": {
+			alias: "g",
+			type: "string",
+			description: "Provide GitHub token directly (must be generated using the `auth` subcommand)"
+		},
+		"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"
+		},
+		"proxy-env": {
+			type: "boolean",
+			default: false,
+			description: "Initialize proxy from environment variables"
+		},
+		"idle-timeout": {
+			type: "string",
+			default: "120",
+			description: "Bun server idle timeout in seconds"
+		}
+	},
+	run({ args }) {
+		const rateLimitRaw = args["rate-limit"];
+		const rateLimit = rateLimitRaw === void 0 ? void 0 : Number.parseInt(rateLimitRaw, 10);
+		const idleTimeoutRaw = args["idle-timeout"];
+		let idleTimeoutSeconds = idleTimeoutRaw === void 0 ? void 0 : Number.parseInt(idleTimeoutRaw, 10);
+		if (idleTimeoutSeconds !== void 0 && (Number.isNaN(idleTimeoutSeconds) || idleTimeoutSeconds < 0)) {
+			consola.warn(`Invalid --idle-timeout value "${idleTimeoutRaw}". Falling back to Bun default.`);
+			idleTimeoutSeconds = void 0;
+		}
+		return runServer({
+			port: Number.parseInt(args.port, 10),
+			verbose: args.verbose,
+			accountType: args["account-type"],
+			manual: args.manual,
+			rateLimit,
+			rateLimitWait: args.wait,
+			githubToken: args["github-token"],
+			claudeCode: args["claude-code"],
+			showToken: args["show-token"],
+			proxyEnv: args["proxy-env"],
+			idleTimeoutSeconds
+		});
+	}
+});
+
+//#endregion
+//#region src/main.ts
+const main = defineCommand({
+	meta: {
+		name: "ghc-proxy",
+		description: "A wrapper around GitHub Copilot API to make it OpenAI compatible, making it usable for other tools."
+	},
+	subCommands: {
+		auth,
+		start,
+		"check-usage": checkUsage,
+		debug
+	}
+});
+runMain(main).catch((error) => {
+	consola.error("Failed to start CLI:", error);
+	process.exitCode = 1;
+});
+
+//#endregion
+export {  };
+//# sourceMappingURL=main.js.map