@hsupu/copilot-api 0.7.0

package/dist/main.js

@@ -0,0 +1,3271 @@
+#!/usr/bin/env node
+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 { 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 process$1 from "node:process";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { logger } from "hono/logger";
+import { streamSSE } from "hono/streaming";
+import { events } from "fetch-event-stream";
+
+//#region src/lib/paths.ts
+const APP_DIR = path.join(os.homedir(), ".local", "share", "copilot-api");
+const GITHUB_TOKEN_PATH = path.join(APP_DIR, "github_token");
+const PATHS = {
+	APP_DIR,
+	GITHUB_TOKEN_PATH
+};
+async function ensurePaths() {
+	await fs.mkdir(PATHS.APP_DIR, { recursive: true });
+	await ensureFile(PATHS.GITHUB_TOKEN_PATH);
+}
+async function ensureFile(filePath) {
+	try {
+		await fs.access(filePath, fs.constants.W_OK);
+		if (((await fs.stat(filePath)).mode & 511) !== 384) await fs.chmod(filePath, 384);
+	} catch {
+		await fs.writeFile(filePath, "");
+		await fs.chmod(filePath, 384);
+	}
+}
+
+//#endregion
+//#region src/lib/state.ts
+const state = {
+	accountType: "individual",
+	manualApprove: false,
+	rateLimitWait: false,
+	showToken: false
+};
+
+//#endregion
+//#region src/lib/api-config.ts
+const standardHeaders = () => ({
+	"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";
+const copilotBaseUrl = (state$1) => state$1.accountType === "individual" ? "https://api.githubcopilot.com" : `https://api.${state$1.accountType}.githubcopilot.com`;
+const copilotHeaders = (state$1, vision = false) => {
+	const headers = {
+		Authorization: `Bearer ${state$1.copilotToken}`,
+		"content-type": standardHeaders()["content-type"],
+		"copilot-integration-id": "vscode-chat",
+		"editor-version": `vscode/${state$1.vsCodeVersion}`,
+		"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";
+const githubHeaders = (state$1) => ({
+	...standardHeaders(),
+	authorization: `token ${state$1.githubToken}`,
+	"editor-version": `vscode/${state$1.vsCodeVersion}`,
+	"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 HTTPError extends Error {
+	status;
+	responseText;
+	constructor(message, status, responseText) {
+		super(message);
+		this.status = status;
+		this.responseText = responseText;
+	}
+	static async fromResponse(message, response) {
+		const text = await response.text();
+		return new HTTPError(message, response.status, text);
+	}
+};
+async function forwardError(c, error) {
+	consola.error("Error occurred:", error);
+	if (error instanceof HTTPError) {
+		let errorJson;
+		try {
+			errorJson = JSON.parse(error.responseText);
+		} catch {
+			errorJson = error.responseText;
+		}
+		consola.error("HTTP error:", errorJson);
+		return c.json({ error: {
+			message: error.responseText,
+			type: "error"
+		} }, error.status);
+	}
+	return c.json({ error: {
+		message: error.message,
+		type: "error"
+	} }, 500);
+}
+
+//#endregion
+//#region src/services/github/get-copilot-token.ts
+const getCopilotToken = async () => {
+	const response = await fetch(`${GITHUB_API_BASE_URL}/copilot_internal/v2/token`, { headers: githubHeaders(state) });
+	if (!response.ok) throw await HTTPError.fromResponse("Failed to get Copilot token", response);
+	return await response.json();
+};
+
+//#endregion
+//#region src/services/github/get-device-code.ts
+async function getDeviceCode() {
+	const response = await fetch(`${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 await HTTPError.fromResponse("Failed to get device code", response);
+	return await response.json();
+}
+
+//#endregion
+//#region src/services/github/get-user.ts
+async function getGitHubUser() {
+	const response = await fetch(`${GITHUB_API_BASE_URL}/user`, { headers: {
+		authorization: `token ${state.githubToken}`,
+		...standardHeaders()
+	} });
+	if (!response.ok) throw await HTTPError.fromResponse("Failed to get GitHub user", response);
+	return await response.json();
+}
+
+//#endregion
+//#region src/services/copilot/get-models.ts
+const getModels = async () => {
+	const response = await fetch(`${copilotBaseUrl(state)}/models`, { headers: copilotHeaders(state) });
+	if (!response.ok) throw await HTTPError.fromResponse("Failed to get models", response);
+	return await response.json();
+};
+
+//#endregion
+//#region src/services/get-vscode-version.ts
+const FALLBACK = "1.104.3";
+const GITHUB_API_URL = "https://api.github.com/repos/microsoft/vscode/releases/latest";
+async function getVSCodeVersion() {
+	const controller = new AbortController();
+	const timeout = setTimeout(() => {
+		controller.abort();
+	}, 5e3);
+	try {
+		const response = await fetch(GITHUB_API_URL, {
+			signal: controller.signal,
+			headers: {
+				Accept: "application/vnd.github.v3+json",
+				"User-Agent": "copilot-api"
+			}
+		});
+		if (!response.ok) return FALLBACK;
+		const version = (await response.json()).tag_name;
+		if (version && /^\d+\.\d+\.\d+$/.test(version)) return version;
+		return FALLBACK;
+	} catch {
+		return FALLBACK;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+
+//#endregion
+//#region src/lib/utils.ts
+const sleep = (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+});
+const isNullish = (value) => value === null || value === void 0;
+async function cacheModels() {
+	state.models = await getModels();
+}
+const cacheVSCodeVersion = async () => {
+	const response = await getVSCodeVersion();
+	state.vsCodeVersion = response;
+	consola.info(`Using VSCode version: ${response}`);
+};
+
+//#endregion
+//#region src/services/github/poll-access-token.ts
+async function pollAccessToken(deviceCode) {
+	const sleepDuration = (deviceCode.interval + 1) * 1e3;
+	consola.debug(`Polling access token with interval of ${sleepDuration}ms`);
+	const expiresAt = Date.now() + deviceCode.expires_in * 1e3;
+	while (Date.now() < expiresAt) {
+		const response = await fetch(`${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);
+		const { access_token } = json;
+		if (access_token) return access_token;
+		else await sleep(sleepDuration);
+	}
+	throw new Error("Device code expired. Please run the authentication flow again.");
+}
+
+//#endregion
+//#region src/lib/token.ts
+const readGithubToken = () => fs.readFile(PATHS.GITHUB_TOKEN_PATH, "utf8");
+const writeGithubToken = (token) => fs.writeFile(PATHS.GITHUB_TOKEN_PATH, token);
+const setupCopilotToken = async () => {
+	const { token, refresh_in } = await getCopilotToken();
+	state.copilotToken = token;
+	consola.debug("GitHub Copilot Token fetched successfully!");
+	if (state.showToken) consola.info("Copilot token:", token);
+	const refreshInterval = (refresh_in - 60) * 1e3;
+	setInterval(async () => {
+		consola.debug("Refreshing Copilot token");
+		try {
+			const { token: token$1 } = await getCopilotToken();
+			state.copilotToken = token$1;
+			consola.debug("Copilot token refreshed");
+			if (state.showToken) consola.info("Refreshed Copilot token:", token$1);
+		} catch (error) {
+			consola.error("Failed to refresh Copilot token (will retry on next interval):", error);
+		}
+	}, refreshInterval);
+};
+async function setupGitHubToken(options) {
+	try {
+		const githubToken = await readGithubToken();
+		if (githubToken && !options?.force) {
+			state.githubToken = githubToken;
+			if (state.showToken) consola.info("GitHub token:", githubToken);
+			await logUser();
+			return;
+		}
+		consola.info("Not logged in, getting new access token");
+		const response = await getDeviceCode();
+		consola.debug("Device code response:", response);
+		consola.info(`Please enter the code "${response.user_code}" in ${response.verification_uri}`);
+		const token = await pollAccessToken(response);
+		await writeGithubToken(token);
+		state.githubToken = token;
+		if (state.showToken) consola.info("GitHub token:", token);
+		await logUser();
+	} catch (error) {
+		if (error instanceof HTTPError) {
+			consola.error("Failed to get GitHub token:", error.responseText);
+			throw error;
+		}
+		consola.error("Failed to get GitHub token:", error);
+		throw error;
+	}
+}
+async function logUser() {
+	const user = await getGitHubUser();
+	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;
+	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 () => {
+	const response = await fetch(`${GITHUB_API_BASE_URL}/copilot_internal/user`, { headers: githubHeaders(state) });
+	if (!response.ok) throw await HTTPError.fromResponse("Failed to get Copilot usage", response);
+	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() {
+		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() {
+	try {
+		const packageJsonPath = new URL("../package.json", import.meta.url).pathname;
+		return JSON.parse(await fs.readFile(packageJsonPath)).version;
+	} catch {
+		return "unknown";
+	}
+}
+function getRuntimeInfo() {
+	const isBun = typeof Bun !== "undefined";
+	return {
+		name: isBun ? "bun" : "node",
+		version: isBun ? Bun.version : process.version.slice(1),
+		platform: os.platform(),
+		arch: os.arch()
+	};
+}
+async function checkTokenExists() {
+	try {
+		if (!(await fs.stat(PATHS.GITHUB_TOKEN_PATH)).isFile()) return false;
+		return (await fs.readFile(PATHS.GITHUB_TOKEN_PATH, "utf8")).trim().length > 0;
+	} catch {
+		return false;
+	}
+}
+async function getDebugInfo() {
+	const [version, tokenExists] = await Promise.all([getPackageVersion(), checkTokenExists()]);
+	return {
+		version,
+		runtime: getRuntimeInfo(),
+		paths: {
+			APP_DIR: PATHS.APP_DIR,
+			GITHUB_TOKEN_PATH: PATHS.GITHUB_TOKEN_PATH
+		},
+		tokenExists
+	};
+}
+function printDebugInfoPlain(info) {
+	consola.info(`copilot-api debug
+
+Version: ${info.version}
+Runtime: ${info.runtime.name} ${info.runtime.version} (${info.runtime.platform} ${info.runtime.arch})
+
+Paths:
+- APP_DIR: ${info.paths.APP_DIR}
+- GITHUB_TOKEN_PATH: ${info.paths.GITHUB_TOKEN_PATH}
+
+Token exists: ${info.tokenExists ? "Yes" : "No"}`);
+}
+function printDebugInfoJson(info) {
+	console.log(JSON.stringify(info, null, 2));
+}
+async function runDebug(options) {
+	const debugInfo = await getDebugInfo();
+	if (options.json) printDebugInfoJson(debugInfo);
+	else printDebugInfoPlain(debugInfo);
+}
+const 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/logout.ts
+async function runLogout() {
+	try {
+		await fs.unlink(PATHS.GITHUB_TOKEN_PATH);
+		consola.success("Logged out successfully. GitHub token removed.");
+	} catch (error) {
+		if (error.code === "ENOENT") consola.info("No token found. Already logged out.");
+		else {
+			consola.error("Failed to remove token:", error);
+			throw error;
+		}
+	}
+}
+const logout = defineCommand({
+	meta: {
+		name: "logout",
+		description: "Remove stored GitHub token and log out"
+	},
+	run() {
+		return runLogout();
+	}
+});
+
+//#endregion
+//#region src/lib/history.ts
+function generateId() {
+	return Date.now().toString(36) + Math.random().toString(36).slice(2, 9);
+}
+const historyState = {
+	enabled: false,
+	entries: [],
+	sessions: /* @__PURE__ */ new Map(),
+	currentSessionId: "",
+	maxEntries: 1e3,
+	sessionTimeoutMs: 1800 * 1e3
+};
+function initHistory(enabled, maxEntries) {
+	historyState.enabled = enabled;
+	historyState.maxEntries = maxEntries;
+	historyState.entries = [];
+	historyState.sessions = /* @__PURE__ */ new Map();
+	historyState.currentSessionId = enabled ? generateId() : "";
+}
+function isHistoryEnabled() {
+	return historyState.enabled;
+}
+function getCurrentSession(endpoint) {
+	const now = Date.now();
+	if (historyState.currentSessionId) {
+		const session = historyState.sessions.get(historyState.currentSessionId);
+		if (session && now - session.lastActivity < historyState.sessionTimeoutMs) {
+			session.lastActivity = now;
+			return historyState.currentSessionId;
+		}
+	}
+	const sessionId = generateId();
+	historyState.currentSessionId = sessionId;
+	historyState.sessions.set(sessionId, {
+		id: sessionId,
+		startTime: now,
+		lastActivity: now,
+		requestCount: 0,
+		totalInputTokens: 0,
+		totalOutputTokens: 0,
+		models: [],
+		endpoint
+	});
+	return sessionId;
+}
+function recordRequest(endpoint, request) {
+	if (!historyState.enabled) return "";
+	const sessionId = getCurrentSession(endpoint);
+	const session = historyState.sessions.get(sessionId);
+	if (!session) return "";
+	const entry = {
+		id: generateId(),
+		sessionId,
+		timestamp: Date.now(),
+		endpoint,
+		request: {
+			model: request.model,
+			messages: request.messages,
+			stream: request.stream,
+			tools: request.tools,
+			max_tokens: request.max_tokens,
+			temperature: request.temperature,
+			system: request.system
+		}
+	};
+	historyState.entries.push(entry);
+	session.requestCount++;
+	if (!session.models.includes(request.model)) session.models.push(request.model);
+	while (historyState.entries.length > historyState.maxEntries) {
+		const removed = historyState.entries.shift();
+		if (removed) {
+			if (historyState.entries.filter((e) => e.sessionId === removed.sessionId).length === 0) historyState.sessions.delete(removed.sessionId);
+		}
+	}
+	return entry.id;
+}
+function recordResponse(id, response, durationMs) {
+	if (!historyState.enabled || !id) return;
+	const entry = historyState.entries.find((e) => e.id === id);
+	if (entry) {
+		entry.response = response;
+		entry.durationMs = durationMs;
+		const session = historyState.sessions.get(entry.sessionId);
+		if (session) {
+			session.totalInputTokens += response.usage.input_tokens;
+			session.totalOutputTokens += response.usage.output_tokens;
+			session.lastActivity = Date.now();
+		}
+	}
+}
+function getHistory(options = {}) {
+	const { page = 1, limit = 50, model, endpoint, success, from, to, search, sessionId } = options;
+	let filtered = [...historyState.entries];
+	if (sessionId) filtered = filtered.filter((e) => e.sessionId === sessionId);
+	if (model) {
+		const modelLower = model.toLowerCase();
+		filtered = filtered.filter((e) => e.request.model.toLowerCase().includes(modelLower) || e.response?.model.toLowerCase().includes(modelLower));
+	}
+	if (endpoint) filtered = filtered.filter((e) => e.endpoint === endpoint);
+	if (success !== void 0) filtered = filtered.filter((e) => e.response?.success === success);
+	if (from) filtered = filtered.filter((e) => e.timestamp >= from);
+	if (to) filtered = filtered.filter((e) => e.timestamp <= to);
+	if (search) {
+		const searchLower = search.toLowerCase();
+		filtered = filtered.filter((e) => {
+			const msgMatch = e.request.messages.some((m) => {
+				if (typeof m.content === "string") return m.content.toLowerCase().includes(searchLower);
+				if (Array.isArray(m.content)) return m.content.some((c) => c.text && c.text.toLowerCase().includes(searchLower));
+				return false;
+			});
+			const respMatch = e.response?.content && typeof e.response.content.content === "string" && e.response.content.content.toLowerCase().includes(searchLower);
+			const toolMatch = e.response?.toolCalls?.some((t) => t.name.toLowerCase().includes(searchLower));
+			const sysMatch = e.request.system?.toLowerCase().includes(searchLower);
+			return msgMatch || respMatch || toolMatch || sysMatch;
+		});
+	}
+	filtered.sort((a, b) => b.timestamp - a.timestamp);
+	const total = filtered.length;
+	const totalPages = Math.ceil(total / limit);
+	const start$1 = (page - 1) * limit;
+	return {
+		entries: filtered.slice(start$1, start$1 + limit),
+		total,
+		page,
+		limit,
+		totalPages
+	};
+}
+function getEntry(id) {
+	return historyState.entries.find((e) => e.id === id);
+}
+function getSessions() {
+	const sessions = Array.from(historyState.sessions.values()).sort((a, b) => b.lastActivity - a.lastActivity);
+	return {
+		sessions,
+		total: sessions.length
+	};
+}
+function getSession(id) {
+	return historyState.sessions.get(id);
+}
+function getSessionEntries(sessionId) {
+	return historyState.entries.filter((e) => e.sessionId === sessionId).sort((a, b) => a.timestamp - b.timestamp);
+}
+function clearHistory() {
+	historyState.entries = [];
+	historyState.sessions = /* @__PURE__ */ new Map();
+	historyState.currentSessionId = generateId();
+}
+function deleteSession(sessionId) {
+	if (!historyState.sessions.has(sessionId)) return false;
+	historyState.entries = historyState.entries.filter((e) => e.sessionId !== sessionId);
+	historyState.sessions.delete(sessionId);
+	if (historyState.currentSessionId === sessionId) historyState.currentSessionId = generateId();
+	return true;
+}
+function getStats() {
+	const entries = historyState.entries;
+	const modelDist = {};
+	const endpointDist = {};
+	const hourlyActivity = {};
+	let totalInput = 0;
+	let totalOutput = 0;
+	let totalDuration = 0;
+	let durationCount = 0;
+	let successCount = 0;
+	let failCount = 0;
+	for (const entry of entries) {
+		const model = entry.response?.model || entry.request.model;
+		modelDist[model] = (modelDist[model] || 0) + 1;
+		endpointDist[entry.endpoint] = (endpointDist[entry.endpoint] || 0) + 1;
+		const hour = new Date(entry.timestamp).toISOString().slice(0, 13);
+		hourlyActivity[hour] = (hourlyActivity[hour] || 0) + 1;
+		if (entry.response) {
+			if (entry.response.success) successCount++;
+			else failCount++;
+			totalInput += entry.response.usage.input_tokens;
+			totalOutput += entry.response.usage.output_tokens;
+		}
+		if (entry.durationMs) {
+			totalDuration += entry.durationMs;
+			durationCount++;
+		}
+	}
+	const recentActivity = Object.entries(hourlyActivity).sort(([a], [b]) => a.localeCompare(b)).slice(-24).map(([hour, count]) => ({
+		hour,
+		count
+	}));
+	const now = Date.now();
+	let activeSessions = 0;
+	for (const session of historyState.sessions.values()) if (now - session.lastActivity < historyState.sessionTimeoutMs) activeSessions++;
+	return {
+		totalRequests: entries.length,
+		successfulRequests: successCount,
+		failedRequests: failCount,
+		totalInputTokens: totalInput,
+		totalOutputTokens: totalOutput,
+		averageDurationMs: durationCount > 0 ? totalDuration / durationCount : 0,
+		modelDistribution: modelDist,
+		endpointDistribution: endpointDist,
+		recentActivity,
+		activeSessions
+	};
+}
+function exportHistory(format = "json") {
+	if (format === "json") return JSON.stringify({
+		sessions: Array.from(historyState.sessions.values()),
+		entries: historyState.entries
+	}, null, 2);
+	const headers = [
+		"id",
+		"session_id",
+		"timestamp",
+		"endpoint",
+		"request_model",
+		"message_count",
+		"stream",
+		"success",
+		"response_model",
+		"input_tokens",
+		"output_tokens",
+		"duration_ms",
+		"stop_reason",
+		"error"
+	];
+	const rows = historyState.entries.map((e) => [
+		e.id,
+		e.sessionId,
+		new Date(e.timestamp).toISOString(),
+		e.endpoint,
+		e.request.model,
+		e.request.messages.length,
+		e.request.stream,
+		e.response?.success ?? "",
+		e.response?.model ?? "",
+		e.response?.usage.input_tokens ?? "",
+		e.response?.usage.output_tokens ?? "",
+		e.durationMs ?? "",
+		e.response?.stop_reason ?? "",
+		e.response?.error ?? ""
+	]);
+	return [headers.join(","), ...rows.map((r) => r.join(","))].join("\n");
+}
+
+//#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$1;
+	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.replace(/"/g, "`\"")}"`).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.replace(/"/g, "\\\"")}"`).join("; ");
+			break;
+		default: {
+			const assignments = filteredEnvVars.map(([key, value]) => `${key}="${value.replace(/"/g, "\\\"")}"`).join(" ");
+			commandBlock = filteredEnvVars.length > 0 ? `export ${assignments}` : "";
+			break;
+		}
+	}
+	if (commandBlock && commandToRun) return `${commandBlock}${shell === "cmd" ? " & " : " && "}${commandToRun}`;
+	return commandBlock || commandToRun;
+}
+
+//#endregion
+//#region src/lib/approval.ts
+const awaitApproval = async () => {
+	if (!await consola.prompt(`Accept incoming request?`, { type: "confirm" })) throw new HTTPError("Request rejected", 403, JSON.stringify({ message: "Request rejected" }));
+};
+
+//#endregion
+//#region src/lib/queue.ts
+var RequestQueue = class {
+	queue = [];
+	processing = false;
+	lastRequestTime = 0;
+	async enqueue(execute, rateLimitSeconds) {
+		return new Promise((resolve, reject) => {
+			this.queue.push({
+				execute,
+				resolve,
+				reject
+			});
+			if (this.queue.length > 1) {
+				const waitTime = Math.ceil((this.queue.length - 1) * rateLimitSeconds);
+				consola.info(`Request queued. Position: ${this.queue.length}, estimated wait: ${waitTime}s`);
+			}
+			this.processQueue(rateLimitSeconds);
+		});
+	}
+	async processQueue(rateLimitSeconds) {
+		if (this.processing) return;
+		this.processing = true;
+		while (this.queue.length > 0) {
+			const elapsedMs = Date.now() - this.lastRequestTime;
+			const requiredMs = rateLimitSeconds * 1e3;
+			if (this.lastRequestTime > 0 && elapsedMs < requiredMs) {
+				const waitMs = requiredMs - elapsedMs;
+				consola.debug(`Rate limit: waiting ${Math.ceil(waitMs / 1e3)}s`);
+				await new Promise((resolve) => setTimeout(resolve, waitMs));
+			}
+			const request = this.queue.shift();
+			if (!request) break;
+			this.lastRequestTime = Date.now();
+			try {
+				const result = await request.execute();
+				request.resolve(result);
+			} catch (error) {
+				request.reject(error);
+			}
+		}
+		this.processing = false;
+	}
+	get length() {
+		return this.queue.length;
+	}
+};
+const requestQueue = new RequestQueue();
+/**
+* Execute a request with rate limiting via queue.
+* Requests are queued and processed sequentially at the configured rate.
+*/
+async function executeWithRateLimit(state$1, execute) {
+	if (state$1.rateLimitSeconds === void 0) return execute();
+	return requestQueue.enqueue(execute, state$1.rateLimitSeconds);
+}
+
+//#endregion
+//#region src/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
+*/
+const 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
+*/
+const 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
+*/
+const 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
+*/
+const 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
+*/
+const getEncodeChatFunction = async (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
+*/
+const getTokenizerFromModel = (model) => {
+	return model.capabilities.tokenizer || "o200k_base";
+};
+/**
+* Get model-specific constants for token calculation.
+* These values are empirically determined based on OpenAI's function calling token overhead.
+* - funcInit: Tokens for initializing a function definition
+* - propInit: Tokens for initializing the properties section
+* - propKey: Tokens per property key
+* - enumInit: Token adjustment when enum is present (negative because type info is replaced)
+* - enumItem: Tokens per enum value
+* - funcEnd: Tokens for closing the function definition
+*/
+const 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
+*/
+const 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
+*/
+const 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
+*/
+const 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
+*/
+const 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
+*/
+const getTokenCount = async (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/services/copilot/create-chat-completions.ts
+const createChatCompletions = async (payload) => {
+	if (!state.copilotToken) throw new Error("Copilot token not found");
+	const enableVision = payload.messages.some((x) => typeof x.content !== "string" && x.content?.some((x$1) => x$1.type === "image_url"));
+	const isAgentCall = payload.messages.some((msg) => ["assistant", "tool"].includes(msg.role));
+	const headers = {
+		...copilotHeaders(state, enableVision),
+		"X-Initiator": isAgentCall ? "agent" : "user"
+	};
+	const response = await fetch(`${copilotBaseUrl(state)}/chat/completions`, {
+		method: "POST",
+		headers,
+		body: JSON.stringify(payload)
+	});
+	if (!response.ok) {
+		consola.error("Failed to create chat completions", response);
+		throw await HTTPError.fromResponse("Failed to create chat completions", response);
+	}
+	if (payload.stream) return events(response);
+	return await response.json();
+};
+
+//#endregion
+//#region src/routes/chat-completions/handler.ts
+async function handleCompletion$1(c) {
+	const startTime = Date.now();
+	let payload = await c.req.json();
+	consola.debug("Request payload:", JSON.stringify(payload).slice(-400));
+	const historyId = recordRequest("openai", {
+		model: payload.model,
+		messages: convertOpenAIMessages(payload.messages),
+		stream: payload.stream ?? false,
+		tools: payload.tools?.map((t) => ({
+			name: t.function.name,
+			description: t.function.description
+		})),
+		max_tokens: payload.max_tokens ?? void 0,
+		temperature: payload.temperature ?? void 0
+	});
+	const selectedModel = state.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 (state.manualApprove) await awaitApproval();
+	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));
+	}
+	try {
+		const response = await executeWithRateLimit(state, () => createChatCompletions(payload));
+		if (isNonStreaming$1(response)) {
+			consola.debug("Non-streaming response:", JSON.stringify(response));
+			const choice = response.choices[0];
+			recordResponse(historyId, {
+				success: true,
+				model: response.model,
+				usage: {
+					input_tokens: response.usage?.prompt_tokens ?? 0,
+					output_tokens: response.usage?.completion_tokens ?? 0
+				},
+				stop_reason: choice?.finish_reason ?? void 0,
+				content: choice?.message ? {
+					role: choice.message.role,
+					content: typeof choice.message.content === "string" ? choice.message.content : JSON.stringify(choice.message.content),
+					tool_calls: choice.message.tool_calls?.map((tc) => ({
+						id: tc.id,
+						type: tc.type,
+						function: {
+							name: tc.function.name,
+							arguments: tc.function.arguments
+						}
+					}))
+				} : null,
+				toolCalls: choice?.message?.tool_calls?.map((tc) => ({
+					id: tc.id,
+					name: tc.function.name,
+					input: tc.function.arguments
+				}))
+			}, Date.now() - startTime);
+			return c.json(response);
+		}
+		consola.debug("Streaming response");
+		return streamSSE(c, async (stream) => {
+			let streamModel = "";
+			let streamInputTokens = 0;
+			let streamOutputTokens = 0;
+			let streamFinishReason = "";
+			let streamContent = "";
+			const streamToolCalls = [];
+			const toolCallAccumulators = /* @__PURE__ */ new Map();
+			try {
+				for await (const chunk of response) {
+					consola.debug("Streaming chunk:", JSON.stringify(chunk));
+					if (chunk.data && chunk.data !== "[DONE]") try {
+						const parsed = JSON.parse(chunk.data);
+						if (parsed.model && !streamModel) streamModel = parsed.model;
+						if (parsed.usage) {
+							streamInputTokens = parsed.usage.prompt_tokens;
+							streamOutputTokens = parsed.usage.completion_tokens;
+						}
+						const choice = parsed.choices[0];
+						if (choice?.delta?.content) streamContent += choice.delta.content;
+						if (choice?.delta?.tool_calls) for (const tc of choice.delta.tool_calls) {
+							const idx = tc.index;
+							if (!toolCallAccumulators.has(idx)) toolCallAccumulators.set(idx, {
+								id: tc.id || "",
+								name: tc.function?.name || "",
+								arguments: ""
+							});
+							const acc = toolCallAccumulators.get(idx);
+							if (acc) {
+								if (tc.id) acc.id = tc.id;
+								if (tc.function?.name) acc.name = tc.function.name;
+								if (tc.function?.arguments) acc.arguments += tc.function.arguments;
+							}
+						}
+						if (choice?.finish_reason) streamFinishReason = choice.finish_reason;
+					} catch {}
+					await stream.writeSSE(chunk);
+				}
+				for (const tc of toolCallAccumulators.values()) if (tc.id && tc.name) streamToolCalls.push({
+					id: tc.id,
+					name: tc.name,
+					arguments: tc.arguments
+				});
+				const toolCallsForContent = streamToolCalls.map((tc) => ({
+					id: tc.id,
+					type: "function",
+					function: {
+						name: tc.name,
+						arguments: tc.arguments
+					}
+				}));
+				recordResponse(historyId, {
+					success: true,
+					model: streamModel || payload.model,
+					usage: {
+						input_tokens: streamInputTokens,
+						output_tokens: streamOutputTokens
+					},
+					stop_reason: streamFinishReason || void 0,
+					content: {
+						role: "assistant",
+						content: streamContent || void 0,
+						tool_calls: toolCallsForContent.length > 0 ? toolCallsForContent : void 0
+					},
+					toolCalls: streamToolCalls.length > 0 ? streamToolCalls.map((tc) => ({
+						id: tc.id,
+						name: tc.name,
+						input: tc.arguments
+					})) : void 0
+				}, Date.now() - startTime);
+			} catch (error) {
+				recordResponse(historyId, {
+					success: false,
+					model: streamModel || payload.model,
+					usage: {
+						input_tokens: 0,
+						output_tokens: 0
+					},
+					error: error instanceof Error ? error.message : "Stream error",
+					content: null
+				}, Date.now() - startTime);
+				throw error;
+			}
+		});
+	} catch (error) {
+		recordResponse(historyId, {
+			success: false,
+			model: payload.model,
+			usage: {
+				input_tokens: 0,
+				output_tokens: 0
+			},
+			error: error instanceof Error ? error.message : "Unknown error",
+			content: null
+		}, Date.now() - startTime);
+		throw error;
+	}
+}
+const isNonStreaming$1 = (response) => Object.hasOwn(response, "choices");
+function convertOpenAIMessages(messages) {
+	return messages.map((msg) => {
+		const result = {
+			role: msg.role,
+			content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+		};
+		if ("tool_calls" in msg && msg.tool_calls) result.tool_calls = msg.tool_calls.map((tc) => ({
+			id: tc.id,
+			type: tc.type,
+			function: {
+				name: tc.function.name,
+				arguments: tc.function.arguments
+			}
+		}));
+		if ("tool_call_id" in msg && msg.tool_call_id) result.tool_call_id = msg.tool_call_id;
+		if ("name" in msg && msg.name) result.name = msg.name;
+		return result;
+	});
+}
+
+//#endregion
+//#region src/routes/chat-completions/route.ts
+const completionRoutes = new Hono();
+completionRoutes.post("/", async (c) => {
+	try {
+		return await handleCompletion$1(c);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+
+//#endregion
+//#region src/services/copilot/create-embeddings.ts
+const createEmbeddings = async (payload) => {
+	if (!state.copilotToken) throw new Error("Copilot token not found");
+	const response = await fetch(`${copilotBaseUrl(state)}/embeddings`, {
+		method: "POST",
+		headers: copilotHeaders(state),
+		body: JSON.stringify(payload)
+	});
+	if (!response.ok) throw await HTTPError.fromResponse("Failed to create embeddings", response);
+	return await response.json();
+};
+
+//#endregion
+//#region src/routes/embeddings/route.ts
+const embeddingRoutes = new Hono();
+embeddingRoutes.post("/", async (c) => {
+	try {
+		const payload = await c.req.json();
+		const response = await createEmbeddings(payload);
+		return c.json(response);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+
+//#endregion
+//#region src/routes/event-logging/route.ts
+const eventLoggingRoutes = new Hono();
+eventLoggingRoutes.post("/batch", (c) => {
+	return c.text("OK", 200);
+});
+
+//#endregion
+//#region src/routes/history/api.ts
+function handleGetEntries(c) {
+	if (!isHistoryEnabled()) return c.json({ error: "History recording is not enabled" }, 400);
+	const query = c.req.query();
+	const options = {
+		page: query.page ? Number.parseInt(query.page, 10) : void 0,
+		limit: query.limit ? Number.parseInt(query.limit, 10) : void 0,
+		model: query.model || void 0,
+		endpoint: query.endpoint,
+		success: query.success ? query.success === "true" : void 0,
+		from: query.from ? Number.parseInt(query.from, 10) : void 0,
+		to: query.to ? Number.parseInt(query.to, 10) : void 0,
+		search: query.search || void 0,
+		sessionId: query.sessionId || void 0
+	};
+	const result = getHistory(options);
+	return c.json(result);
+}
+function handleGetEntry(c) {
+	if (!isHistoryEnabled()) return c.json({ error: "History recording is not enabled" }, 400);
+	const id = c.req.param("id");
+	const entry = getEntry(id);
+	if (!entry) return c.json({ error: "Entry not found" }, 404);
+	return c.json(entry);
+}
+function handleDeleteEntries(c) {
+	if (!isHistoryEnabled()) return c.json({ error: "History recording is not enabled" }, 400);
+	clearHistory();
+	return c.json({
+		success: true,
+		message: "History cleared"
+	});
+}
+function handleGetStats(c) {
+	if (!isHistoryEnabled()) return c.json({ error: "History recording is not enabled" }, 400);
+	const stats = getStats();
+	return c.json(stats);
+}
+function handleExport(c) {
+	if (!isHistoryEnabled()) return c.json({ error: "History recording is not enabled" }, 400);
+	const format = c.req.query("format") || "json";
+	const data = exportHistory(format);
+	if (format === "csv") {
+		c.header("Content-Type", "text/csv");
+		c.header("Content-Disposition", "attachment; filename=history.csv");
+	} else {
+		c.header("Content-Type", "application/json");
+		c.header("Content-Disposition", "attachment; filename=history.json");
+	}
+	return c.body(data);
+}
+function handleGetSessions(c) {
+	if (!isHistoryEnabled()) return c.json({ error: "History recording is not enabled" }, 400);
+	const result = getSessions();
+	return c.json(result);
+}
+function handleGetSession(c) {
+	if (!isHistoryEnabled()) return c.json({ error: "History recording is not enabled" }, 400);
+	const id = c.req.param("id");
+	const session = getSession(id);
+	if (!session) return c.json({ error: "Session not found" }, 404);
+	const entries = getSessionEntries(id);
+	return c.json({
+		...session,
+		entries
+	});
+}
+function handleDeleteSession(c) {
+	if (!isHistoryEnabled()) return c.json({ error: "History recording is not enabled" }, 400);
+	const id = c.req.param("id");
+	if (!deleteSession(id)) return c.json({ error: "Session not found" }, 404);
+	return c.json({
+		success: true,
+		message: "Session deleted"
+	});
+}
+
+//#endregion
+//#region src/routes/history/ui/script.ts
+const script = `
+let currentSessionId = null;
+let currentEntryId = null;
+let debounceTimer = null;
+
+function formatTime(ts) {
+  const d = new Date(ts);
+  return d.toLocaleTimeString([], {hour:'2-digit',minute:'2-digit',second:'2-digit'});
+}
+
+function formatDate(ts) {
+  const d = new Date(ts);
+  return d.toLocaleDateString([], {month:'short',day:'numeric'}) + ' ' + formatTime(ts);
+}
+
+function formatNumber(n) {
+  if (n >= 1000000) return (n / 1000000).toFixed(1) + 'M';
+  if (n >= 1000) return (n / 1000).toFixed(1) + 'K';
+  return n.toString();
+}
+
+function formatDuration(ms) {
+  if (!ms) return '-';
+  if (ms < 1000) return ms + 'ms';
+  return (ms / 1000).toFixed(1) + 's';
+}
+
+function getContentText(content) {
+  if (!content) return '';
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content.map(c => {
+      if (c.type === 'text') return c.text || '';
+      if (c.type === 'tool_use') return '[tool_use: ' + c.name + ']';
+      if (c.type === 'tool_result') return '[tool_result: ' + (c.tool_use_id || '').slice(0,8) + ']';
+      if (c.type === 'image' || c.type === 'image_url') return '[image]';
+      return c.text || '[' + (c.type || 'unknown') + ']';
+    }).join('\\n');
+  }
+  return JSON.stringify(content, null, 2);
+}
+
+function formatContentForDisplay(content) {
+  if (!content) return { summary: '', raw: 'null' };
+  if (typeof content === 'string') return { summary: content, raw: JSON.stringify(content) };
+  if (Array.isArray(content)) {
+    const parts = [];
+    for (const c of content) {
+      if (c.type === 'text') {
+        parts.push(c.text || '');
+      } else if (c.type === 'tool_use') {
+        parts.push('--- tool_use: ' + c.name + ' [' + (c.id || '').slice(0,8) + '] ---\\n' + JSON.stringify(c.input, null, 2));
+      } else if (c.type === 'tool_result') {
+        const resultContent = typeof c.content === 'string' ? c.content : JSON.stringify(c.content, null, 2);
+        parts.push('--- tool_result [' + (c.tool_use_id || '').slice(0,8) + '] ---\\n' + resultContent);
+      } else if (c.type === 'image' || c.type === 'image_url') {
+        parts.push('[image data]');
+      } else {
+        parts.push(JSON.stringify(c, null, 2));
+      }
+    }
+    return { summary: parts.join('\\n\\n'), raw: JSON.stringify(content, null, 2) };
+  }
+  const raw = JSON.stringify(content, null, 2);
+  return { summary: raw, raw };
+}
+
+async function loadStats() {
+  try {
+    const res = await fetch('/history/api/stats');
+    const data = await res.json();
+    if (data.error) return;
+    document.getElementById('stat-total').textContent = formatNumber(data.totalRequests);
+    document.getElementById('stat-success').textContent = formatNumber(data.successfulRequests);
+    document.getElementById('stat-failed').textContent = formatNumber(data.failedRequests);
+    document.getElementById('stat-input').textContent = formatNumber(data.totalInputTokens);
+    document.getElementById('stat-output').textContent = formatNumber(data.totalOutputTokens);
+    document.getElementById('stat-sessions').textContent = data.activeSessions;
+  } catch (e) {
+    console.error('Failed to load stats', e);
+  }
+}
+
+async function loadSessions() {
+  try {
+    const res = await fetch('/history/api/sessions');
+    const data = await res.json();
+    if (data.error) {
+      document.getElementById('sessions-list').innerHTML = '<div class="empty-state">Not enabled</div>';
+      return;
+    }
+
+    let html = '<div class="session-item all' + (currentSessionId === null ? ' active' : '') + '" onclick="selectSession(null)">All Requests</div>';
+
+    for (const s of data.sessions) {
+      const isActive = currentSessionId === s.id;
+      const shortId = s.id.slice(0, 8);
+      html += \`
+        <div class="session-item\${isActive ? ' active' : ''}" onclick="selectSession('\${s.id}')">
+          <div class="session-meta">
+            <span>\${s.models[0] || 'Unknown'}</span>
+            <span class="session-time">\${formatDate(s.startTime)}</span>
+          </div>
+          <div class="session-stats">
+            <span style="color:var(--text-dim);font-family:monospace;font-size:10px;">\${shortId}</span>
+            <span>\${s.requestCount} req</span>
+            <span>\${formatNumber(s.totalInputTokens + s.totalOutputTokens)} tok</span>
+            <span class="badge \${s.endpoint}">\${s.endpoint}</span>
+          </div>
+        </div>
+      \`;
+    }
+
+    document.getElementById('sessions-list').innerHTML = html || '<div class="empty-state">No sessions</div>';
+  } catch (e) {
+    document.getElementById('sessions-list').innerHTML = '<div class="empty-state">Error loading</div>';
+  }
+}
+
+function selectSession(id) {
+  currentSessionId = id;
+  loadSessions();
+  loadEntries();
+  closeDetail();
+}
+
+async function loadEntries() {
+  const container = document.getElementById('entries-container');
+  container.innerHTML = '<div class="loading">Loading...</div>';
+
+  const params = new URLSearchParams();
+  params.set('limit', '100');
+
+  if (currentSessionId) params.set('sessionId', currentSessionId);
+
+  const endpoint = document.getElementById('filter-endpoint').value;
+  const success = document.getElementById('filter-success').value;
+  const search = document.getElementById('filter-search').value;
+
+  if (endpoint) params.set('endpoint', endpoint);
+  if (success) params.set('success', success);
+  if (search) params.set('search', search);
+
+  try {
+    const res = await fetch('/history/api/entries?' + params.toString());
+    const data = await res.json();
+
+    if (data.error) {
+      container.innerHTML = '<div class="empty-state"><h3>History Not Enabled</h3><p>Start server with --history</p></div>';
+      return;
+    }
+
+    if (data.entries.length === 0) {
+      container.innerHTML = '<div class="empty-state"><h3>No entries</h3><p>Make some API requests</p></div>';
+      return;
+    }
+
+    let html = '';
+    for (const e of data.entries) {
+      const isSelected = currentEntryId === e.id;
+      const status = !e.response ? 'pending' : (e.response.success ? 'success' : 'error');
+      const statusLabel = !e.response ? 'pending' : (e.response.success ? 'success' : 'error');
+      const tokens = e.response ? formatNumber(e.response.usage.input_tokens) + '/' + formatNumber(e.response.usage.output_tokens) : '-';
+      const shortId = e.id.slice(0, 8);
+
+      html += \`
+        <div class="entry-item\${isSelected ? ' selected' : ''}" onclick="showDetail('\${e.id}')">
+          <div class="entry-header">
+            <span class="entry-time">\${formatTime(e.timestamp)}</span>
+            <span style="color:var(--text-dim);font-family:monospace;font-size:10px;">\${shortId}</span>
+            <span class="badge \${e.endpoint}">\${e.endpoint}</span>
+            <span class="badge \${status}">\${statusLabel}</span>
+            \${e.request.stream ? '<span class="badge stream">stream</span>' : ''}
+            <span class="entry-model">\${e.response?.model || e.request.model}</span>
+            <span class="entry-tokens">\${tokens}</span>
+            <span class="entry-duration">\${formatDuration(e.durationMs)}</span>
+          </div>
+        </div>
+      \`;
+    }
+
+    container.innerHTML = html;
+  } catch (e) {
+    container.innerHTML = '<div class="empty-state">Error: ' + e.message + '</div>';
+  }
+}
+
+async function showDetail(id) {
+  // Update selected state without reloading
+  const prevSelected = document.querySelector('.entry-item.selected');
+  if (prevSelected) prevSelected.classList.remove('selected');
+  const newSelected = document.querySelector(\`.entry-item[onclick*="'\${id}'"]\`);
+  if (newSelected) newSelected.classList.add('selected');
+  currentEntryId = id;
+
+  const panel = document.getElementById('detail-panel');
+  const content = document.getElementById('detail-content');
+  panel.classList.add('open');
+  content.innerHTML = '<div class="loading">Loading...</div>';
+
+  try {
+    const res = await fetch('/history/api/entries/' + id);
+    const entry = await res.json();
+    if (entry.error) {
+      content.innerHTML = '<div class="empty-state">Not found</div>';
+      return;
+    }
+
+    let html = '';
+
+    // Entry metadata (IDs)
+    html += \`
+      <div class="detail-section">
+        <h4>Entry Info</h4>
+        <div class="response-info">
+          <div class="info-item"><div class="info-label">Entry ID</div><div class="info-value" style="font-family:monospace;font-size:11px;">\${entry.id}</div></div>
+          <div class="info-item"><div class="info-label">Session ID</div><div class="info-value" style="font-family:monospace;font-size:11px;">\${entry.sessionId || '-'}</div></div>
+          <div class="info-item"><div class="info-label">Timestamp</div><div class="info-value">\${formatDate(entry.timestamp)}</div></div>
+          <div class="info-item"><div class="info-label">Endpoint</div><div class="info-value"><span class="badge \${entry.endpoint}">\${entry.endpoint}</span></div></div>
+        </div>
+      </div>
+    \`;
+
+    // Response info
+    if (entry.response) {
+      html += \`
+        <div class="detail-section">
+          <h4>Response</h4>
+          <div class="response-info">
+            <div class="info-item"><div class="info-label">Status</div><div class="info-value"><span class="badge \${entry.response.success ? 'success' : 'error'}">\${entry.response.success ? 'Success' : 'Error'}</span></div></div>
+            <div class="info-item"><div class="info-label">Model</div><div class="info-value">\${entry.response.model}</div></div>
+            <div class="info-item"><div class="info-label">Input Tokens</div><div class="info-value">\${formatNumber(entry.response.usage.input_tokens)}</div></div>
+            <div class="info-item"><div class="info-label">Output Tokens</div><div class="info-value">\${formatNumber(entry.response.usage.output_tokens)}</div></div>
+            <div class="info-item"><div class="info-label">Duration</div><div class="info-value">\${formatDuration(entry.durationMs)}</div></div>
+            <div class="info-item"><div class="info-label">Stop Reason</div><div class="info-value">\${entry.response.stop_reason || '-'}</div></div>
+          </div>
+          \${entry.response.error ? '<div style="color:var(--error);margin-top:8px;">Error: ' + entry.response.error + '</div>' : ''}
+        </div>
+      \`;
+    }
+
+    // System prompt
+    if (entry.request.system) {
+      html += \`
+        <div class="detail-section">
+          <h4>System Prompt</h4>
+          <div class="message system">
+            <div class="message-content">\${escapeHtml(entry.request.system)}</div>
+          </div>
+        </div>
+      \`;
+    }
+
+    // Messages
+    html += '<div class="detail-section"><h4>Messages</h4><div class="messages-list">';
+    for (const msg of entry.request.messages) {
+      const roleClass = msg.role === 'user' ? 'user' : (msg.role === 'assistant' ? 'assistant' : (msg.role === 'system' ? 'system' : 'tool'));
+      const formatted = formatContentForDisplay(msg.content);
+      const isLong = formatted.summary.length > 500;
+      const rawContent = JSON.stringify(msg, null, 2);
+
+      html += \`
+        <div class="message \${roleClass}">
+          <button class="raw-btn small" onclick="showRawJson(event, \${escapeAttr(rawContent)})">Raw</button>
+          <button class="copy-btn small" onclick="copyText(event, this)" data-content="\${escapeAttr(formatted.summary)}">Copy</button>
+          <div class="message-role">\${msg.role}\${msg.name ? ' (' + msg.name + ')' : ''}\${msg.tool_call_id ? ' [' + (msg.tool_call_id || '').slice(0,8) + ']' : ''}</div>
+          <div class="message-content\${isLong ? ' collapsed' : ''}" id="msg-\${Math.random().toString(36).slice(2)}">\${escapeHtml(formatted.summary)}</div>
+          \${isLong ? '<span class="expand-btn" onclick="toggleExpand(this)">Show more</span>' : ''}
+      \`;
+
+      // Tool calls
+      if (msg.tool_calls && msg.tool_calls.length > 0) {
+        for (const tc of msg.tool_calls) {
+          html += \`
+            <div class="tool-call">
+              <span class="tool-name">\${tc.function.name}</span>
+              <div class="tool-args">\${escapeHtml(tc.function.arguments)}</div>
+            </div>
+          \`;
+        }
+      }
+
+      html += '</div>';
+    }
+    html += '</div></div>';
+
+    // Response content
+    if (entry.response?.content) {
+      const formatted = formatContentForDisplay(entry.response.content.content);
+      const rawContent = JSON.stringify(entry.response.content, null, 2);
+      html += \`
+        <div class="detail-section">
+          <h4>Response Content</h4>
+          <div class="message assistant">
+            <button class="raw-btn small" onclick="showRawJson(event, \${escapeAttr(rawContent)})">Raw</button>
+            <button class="copy-btn small" onclick="copyText(event, this)" data-content="\${escapeAttr(formatted.summary)}">Copy</button>
+            <div class="message-content">\${escapeHtml(formatted.summary)}</div>
+          </div>
+        </div>
+      \`;
+    }
+
+    // Response tool calls
+    if (entry.response?.toolCalls && entry.response.toolCalls.length > 0) {
+      html += '<div class="detail-section"><h4>Tool Calls</h4>';
+      for (const tc of entry.response.toolCalls) {
+        const tcRaw = JSON.stringify(tc, null, 2);
+        html += \`
+          <div class="tool-call" style="position:relative;">
+            <button class="raw-btn small" style="position:absolute;top:4px;right:4px;opacity:1;" onclick="showRawJson(event, \${escapeAttr(tcRaw)})">Raw</button>
+            <span class="tool-name">\${tc.name}</span> <span style="color:var(--text-muted);font-size:11px;">[\${(tc.id || '').slice(0,8)}]</span>
+            <div class="tool-args">\${escapeHtml(tc.input)}</div>
+          </div>
+        \`;
+      }
+      html += '</div>';
+    }
+
+    // Tools defined
+    if (entry.request.tools && entry.request.tools.length > 0) {
+      html += '<div class="detail-section"><h4>Available Tools (' + entry.request.tools.length + ')</h4>';
+      html += '<div style="font-size:11px;color:var(--text-muted)">' + entry.request.tools.map(t => t.name).join(', ') + '</div>';
+      html += '</div>';
+    }
+
+    content.innerHTML = html;
+  } catch (e) {
+    content.innerHTML = '<div class="empty-state">Error: ' + e.message + '</div>';
+  }
+}
+
+function closeDetail() {
+  currentEntryId = null;
+  document.getElementById('detail-panel').classList.remove('open');
+  loadEntries();
+}
+
+function toggleExpand(btn) {
+  const content = btn.previousElementSibling;
+  const isCollapsed = content.classList.contains('collapsed');
+  content.classList.toggle('collapsed');
+  btn.textContent = isCollapsed ? 'Show less' : 'Show more';
+}
+
+function copyText(event, btn) {
+  event.stopPropagation();
+  const text = btn.getAttribute('data-content');
+  navigator.clipboard.writeText(text);
+  const orig = btn.textContent;
+  btn.textContent = 'Copied!';
+  setTimeout(() => btn.textContent = orig, 1000);
+}
+
+function escapeHtml(str) {
+  if (!str) return '';
+  return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+
+function escapeAttr(str) {
+  if (!str) return '';
+  return str.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/'/g, '&#39;');
+}
+
+let currentRawContent = '';
+
+function showRawJson(event, content) {
+  event.stopPropagation();
+  currentRawContent = typeof content === 'string' ? content : JSON.stringify(content, null, 2);
+  document.getElementById('raw-content').textContent = currentRawContent;
+  document.getElementById('raw-modal').classList.add('open');
+}
+
+function closeRawModal(event) {
+  if (event && event.target !== event.currentTarget) return;
+  document.getElementById('raw-modal').classList.remove('open');
+}
+
+function copyRawContent() {
+  navigator.clipboard.writeText(currentRawContent);
+  const btns = document.querySelectorAll('.modal-header button');
+  const copyBtn = btns[0];
+  const orig = copyBtn.textContent;
+  copyBtn.textContent = 'Copied!';
+  setTimeout(() => copyBtn.textContent = orig, 1000);
+}
+
+function debounceFilter() {
+  clearTimeout(debounceTimer);
+  debounceTimer = setTimeout(loadEntries, 300);
+}
+
+function refresh() {
+  loadStats();
+  loadSessions();
+  loadEntries();
+}
+
+function exportData(format) {
+  window.open('/history/api/export?format=' + format, '_blank');
+}
+
+async function clearAll() {
+  if (!confirm('Clear all history? This cannot be undone.')) return;
+  try {
+    await fetch('/history/api/entries', { method: 'DELETE' });
+    currentSessionId = null;
+    currentEntryId = null;
+    closeDetail();
+    refresh();
+  } catch (e) {
+    alert('Failed: ' + e.message);
+  }
+}
+
+// Initial load
+loadStats();
+loadSessions();
+loadEntries();
+
+// Keyboard shortcuts
+document.addEventListener('keydown', (e) => {
+  if (e.key === 'Escape') {
+    if (document.getElementById('raw-modal').classList.contains('open')) {
+      closeRawModal();
+    } else {
+      closeDetail();
+    }
+  }
+  if (e.key === 'r' && (e.metaKey || e.ctrlKey)) {
+    e.preventDefault();
+    refresh();
+  }
+});
+
+// Auto-refresh every 10 seconds
+setInterval(() => {
+  loadStats();
+  loadSessions();
+}, 10000);
+`;
+
+//#endregion
+//#region src/routes/history/ui/styles.ts
+const styles = `
+:root {
+  --bg: #0d1117;
+  --bg-secondary: #161b22;
+  --bg-tertiary: #21262d;
+  --bg-hover: #30363d;
+  --text: #e6edf3;
+  --text-muted: #8b949e;
+  --text-dim: #6e7681;
+  --border: #30363d;
+  --primary: #58a6ff;
+  --success: #3fb950;
+  --error: #f85149;
+  --warning: #d29922;
+  --purple: #a371f7;
+  --cyan: #39c5cf;
+}
+@media (prefers-color-scheme: light) {
+  :root {
+    --bg: #ffffff;
+    --bg-secondary: #f6f8fa;
+    --bg-tertiary: #eaeef2;
+    --bg-hover: #d0d7de;
+    --text: #1f2328;
+    --text-muted: #656d76;
+    --text-dim: #8c959f;
+    --border: #d0d7de;
+  }
+}
+* { box-sizing: border-box; margin: 0; padding: 0; }
+body {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica, Arial, sans-serif;
+  background: var(--bg);
+  color: var(--text);
+  line-height: 1.4;
+  font-size: 13px;
+}
+
+/* Layout */
+.layout { display: flex; height: 100vh; }
+.sidebar {
+  width: 280px;
+  border-right: 1px solid var(--border);
+  display: flex;
+  flex-direction: column;
+  background: var(--bg-secondary);
+}
+.main { flex: 1; display: flex; flex-direction: column; overflow: hidden; }
+
+/* Header */
+.header {
+  padding: 12px 16px;
+  border-bottom: 1px solid var(--border);
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  background: var(--bg-secondary);
+}
+.header h1 { font-size: 16px; font-weight: 600; }
+.header-actions { display: flex; gap: 8px; }
+
+/* Stats bar */
+.stats-bar {
+  display: flex;
+  gap: 16px;
+  padding: 8px 16px;
+  border-bottom: 1px solid var(--border);
+  background: var(--bg-tertiary);
+  font-size: 12px;
+}
+.stat { display: flex; align-items: center; gap: 4px; }
+.stat-value { font-weight: 600; }
+.stat-label { color: var(--text-muted); }
+
+/* Sessions sidebar */
+.sidebar-header {
+  padding: 12px;
+  border-bottom: 1px solid var(--border);
+  font-weight: 600;
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+.sessions-list {
+  flex: 1;
+  overflow-y: auto;
+}
+.session-item {
+  padding: 10px 12px;
+  border-bottom: 1px solid var(--border);
+  cursor: pointer;
+  transition: background 0.15s;
+}
+.session-item:hover { background: var(--bg-hover); }
+.session-item.active { background: var(--bg-tertiary); border-left: 3px solid var(--primary); }
+.session-item.all { font-weight: 600; color: var(--primary); }
+.session-meta { display: flex; justify-content: space-between; margin-bottom: 4px; }
+.session-time { color: var(--text-muted); font-size: 11px; }
+.session-stats { display: flex; gap: 8px; font-size: 11px; color: var(--text-dim); }
+
+/* Buttons */
+button {
+  background: var(--bg-tertiary);
+  border: 1px solid var(--border);
+  color: var(--text);
+  padding: 5px 10px;
+  border-radius: 6px;
+  cursor: pointer;
+  font-size: 12px;
+  transition: all 0.15s;
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+}
+button:hover { background: var(--bg-hover); }
+button.primary { background: var(--primary); color: #fff; border-color: var(--primary); }
+button.danger { color: var(--error); }
+button.danger:hover { background: rgba(248,81,73,0.1); }
+button:disabled { opacity: 0.5; cursor: not-allowed; }
+button.small { padding: 3px 6px; font-size: 11px; }
+button.icon-only { padding: 5px 6px; }
+
+/* Filters */
+.filters {
+  display: flex;
+  gap: 8px;
+  padding: 8px 16px;
+  border-bottom: 1px solid var(--border);
+  flex-wrap: wrap;
+}
+input, select {
+  background: var(--bg);
+  border: 1px solid var(--border);
+  color: var(--text);
+  padding: 5px 8px;
+  border-radius: 6px;
+  font-size: 12px;
+}
+input:focus, select:focus { outline: none; border-color: var(--primary); }
+input::placeholder { color: var(--text-dim); }
+
+/* Entries list */
+.entries-container { flex: 1; overflow-y: auto; }
+.entry-item {
+  border-bottom: 1px solid var(--border);
+  cursor: pointer;
+  transition: background 0.15s;
+}
+.entry-item:hover { background: var(--bg-secondary); }
+.entry-item.selected { background: var(--bg-tertiary); }
+.entry-header {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 8px 16px;
+}
+.entry-time { color: var(--text-muted); font-size: 11px; min-width: 70px; }
+.entry-model { font-weight: 500; flex: 1; }
+.entry-tokens { font-size: 11px; color: var(--text-dim); }
+.entry-duration { font-size: 11px; color: var(--text-dim); min-width: 50px; text-align: right; }
+
+/* Badges */
+.badge {
+  display: inline-block;
+  padding: 1px 6px;
+  border-radius: 10px;
+  font-size: 10px;
+  font-weight: 500;
+}
+.badge.success { background: rgba(63, 185, 80, 0.15); color: var(--success); }
+.badge.error { background: rgba(248, 81, 73, 0.15); color: var(--error); }
+.badge.pending { background: rgba(136, 136, 136, 0.15); color: var(--text-muted); }
+.badge.anthropic { background: rgba(163, 113, 247, 0.15); color: var(--purple); }
+.badge.openai { background: rgba(210, 153, 34, 0.15); color: var(--warning); }
+.badge.stream { background: rgba(57, 197, 207, 0.15); color: var(--cyan); }
+
+/* Detail panel */
+.detail-panel {
+  width: 0;
+  border-left: 1px solid var(--border);
+  background: var(--bg-secondary);
+  transition: width 0.2s;
+  overflow: hidden;
+  display: flex;
+  flex-direction: column;
+}
+.detail-panel.open { width: 50%; min-width: 400px; }
+.detail-header {
+  padding: 12px 16px;
+  border-bottom: 1px solid var(--border);
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+.detail-content { flex: 1; overflow-y: auto; padding: 16px; }
+.detail-section { margin-bottom: 16px; }
+.detail-section h4 {
+  font-size: 11px;
+  text-transform: uppercase;
+  color: var(--text-muted);
+  margin-bottom: 8px;
+  letter-spacing: 0.5px;
+}
+
+/* Messages display */
+.messages-list { display: flex; flex-direction: column; gap: 8px; }
+.message {
+  padding: 10px 12px;
+  border-radius: 8px;
+  background: var(--bg);
+  border: 1px solid var(--border);
+  position: relative;
+}
+.message.user { border-left: 3px solid var(--primary); }
+.message.assistant { border-left: 3px solid var(--success); }
+.message.system { border-left: 3px solid var(--warning); background: var(--bg-tertiary); }
+.message.tool { border-left: 3px solid var(--purple); }
+.message-role {
+  font-size: 10px;
+  text-transform: uppercase;
+  color: var(--text-muted);
+  margin-bottom: 4px;
+  font-weight: 600;
+}
+.message-content {
+  white-space: pre-wrap;
+  word-break: break-word;
+  font-family: 'SF Mono', Monaco, 'Courier New', monospace;
+  font-size: 12px;
+  max-height: 300px;
+  overflow-y: auto;
+}
+.message-content.collapsed { max-height: 100px; }
+.expand-btn {
+  color: var(--primary);
+  cursor: pointer;
+  font-size: 11px;
+  margin-top: 4px;
+  display: inline-block;
+}
+
+/* Tool calls */
+.tool-call {
+  background: var(--bg-tertiary);
+  padding: 8px;
+  border-radius: 6px;
+  margin-top: 8px;
+  font-size: 12px;
+}
+.tool-name { color: var(--purple); font-weight: 600; }
+.tool-args {
+  font-family: monospace;
+  font-size: 11px;
+  color: var(--text-muted);
+  margin-top: 4px;
+  white-space: pre-wrap;
+  max-height: 150px;
+  overflow-y: auto;
+}
+
+/* Response info */
+.response-info {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(100px, 1fr));
+  gap: 12px;
+}
+.info-item { }
+.info-label { font-size: 11px; color: var(--text-muted); }
+.info-value { font-weight: 500; }
+
+/* Empty state */
+.empty-state {
+  text-align: center;
+  padding: 40px 20px;
+  color: var(--text-muted);
+}
+.empty-state h3 { margin-bottom: 8px; color: var(--text); }
+
+/* Loading */
+.loading { text-align: center; padding: 20px; color: var(--text-muted); }
+
+/* Scrollbar */
+::-webkit-scrollbar { width: 8px; height: 8px; }
+::-webkit-scrollbar-track { background: var(--bg); }
+::-webkit-scrollbar-thumb { background: var(--border); border-radius: 4px; }
+::-webkit-scrollbar-thumb:hover { background: var(--text-dim); }
+
+/* Copy/Raw buttons */
+.copy-btn, .raw-btn {
+  position: absolute;
+  top: 4px;
+  opacity: 0;
+  transition: opacity 0.15s;
+}
+.copy-btn { right: 4px; }
+.raw-btn { right: 50px; }
+.message:hover .copy-btn, .message:hover .raw-btn { opacity: 1; }
+
+/* Raw JSON modal */
+.modal-overlay {
+  position: fixed;
+  top: 0; left: 0; right: 0; bottom: 0;
+  background: rgba(0,0,0,0.6);
+  display: none;
+  justify-content: center;
+  align-items: center;
+  z-index: 1000;
+}
+.modal-overlay.open { display: flex; }
+.modal {
+  background: var(--bg-secondary);
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  width: 80%;
+  max-width: 800px;
+  max-height: 80vh;
+  display: flex;
+  flex-direction: column;
+}
+.modal-header {
+  padding: 12px 16px;
+  border-bottom: 1px solid var(--border);
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+.modal-body {
+  flex: 1;
+  overflow: auto;
+  padding: 16px;
+}
+.modal-body pre {
+  margin: 0;
+  font-family: 'SF Mono', Monaco, 'Courier New', monospace;
+  font-size: 12px;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+`;
+
+//#endregion
+//#region src/routes/history/ui/template.ts
+const template = `
+<div class="layout">
+  <!-- Sidebar: Sessions -->
+  <div class="sidebar">
+    <div class="sidebar-header">
+      <span>Sessions</span>
+      <button class="small danger" onclick="clearAll()" title="Clear all">Clear</button>
+    </div>
+    <div class="sessions-list" id="sessions-list">
+      <div class="loading">Loading...</div>
+    </div>
+  </div>
+
+  <!-- Main content -->
+  <div class="main">
+    <div class="header">
+      <h1>Request History</h1>
+      <div class="header-actions">
+        <button onclick="refresh()">Refresh</button>
+        <button onclick="exportData('json')">Export JSON</button>
+        <button onclick="exportData('csv')">Export CSV</button>
+      </div>
+    </div>
+
+    <div class="stats-bar" id="stats-bar">
+      <div class="stat"><span class="stat-value" id="stat-total">-</span><span class="stat-label">requests</span></div>
+      <div class="stat"><span class="stat-value" id="stat-success">-</span><span class="stat-label">success</span></div>
+      <div class="stat"><span class="stat-value" id="stat-failed">-</span><span class="stat-label">failed</span></div>
+      <div class="stat"><span class="stat-value" id="stat-input">-</span><span class="stat-label">in tokens</span></div>
+      <div class="stat"><span class="stat-value" id="stat-output">-</span><span class="stat-label">out tokens</span></div>
+      <div class="stat"><span class="stat-value" id="stat-sessions">-</span><span class="stat-label">sessions</span></div>
+    </div>
+
+    <div class="filters">
+      <input type="text" id="filter-search" placeholder="Search messages..." style="flex:1;min-width:150px" onkeyup="debounceFilter()">
+      <select id="filter-endpoint" onchange="loadEntries()">
+        <option value="">All Endpoints</option>
+        <option value="anthropic">Anthropic</option>
+        <option value="openai">OpenAI</option>
+      </select>
+      <select id="filter-success" onchange="loadEntries()">
+        <option value="">All Status</option>
+        <option value="true">Success</option>
+        <option value="false">Failed</option>
+      </select>
+    </div>
+
+    <div style="display:flex;flex:1;overflow:hidden;">
+      <div class="entries-container" id="entries-container">
+        <div class="loading">Loading...</div>
+      </div>
+
+      <!-- Detail panel -->
+      <div class="detail-panel" id="detail-panel">
+        <div class="detail-header">
+          <span>Request Details</span>
+          <button class="icon-only" onclick="closeDetail()">&times;</button>
+        </div>
+        <div class="detail-content" id="detail-content"></div>
+      </div>
+    </div>
+  </div>
+</div>
+
+<!-- Raw JSON Modal -->
+<div class="modal-overlay" id="raw-modal" onclick="closeRawModal(event)">
+  <div class="modal" onclick="event.stopPropagation()">
+    <div class="modal-header">
+      <span>Raw JSON</span>
+      <div>
+        <button class="small" onclick="copyRawContent()">Copy</button>
+        <button class="icon-only" onclick="closeRawModal()">&times;</button>
+      </div>
+    </div>
+    <div class="modal-body">
+      <pre id="raw-content"></pre>
+    </div>
+  </div>
+</div>
+`;
+
+//#endregion
+//#region src/routes/history/ui.ts
+function getHistoryUI() {
+	return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Copilot API - Request History</title>
+  <style>${styles}</style>
+</head>
+<body>
+  ${template}
+  <script>${script}<\/script>
+</body>
+</html>`;
+}
+
+//#endregion
+//#region src/routes/history/route.ts
+const historyRoutes = new Hono();
+historyRoutes.get("/api/entries", handleGetEntries);
+historyRoutes.get("/api/entries/:id", handleGetEntry);
+historyRoutes.delete("/api/entries", handleDeleteEntries);
+historyRoutes.get("/api/stats", handleGetStats);
+historyRoutes.get("/api/export", handleExport);
+historyRoutes.get("/api/sessions", handleGetSessions);
+historyRoutes.get("/api/sessions/:id", handleGetSession);
+historyRoutes.delete("/api/sessions/:id", handleDeleteSession);
+historyRoutes.get("/", (c) => {
+	return c.html(getHistoryUI());
+});
+
+//#endregion
+//#region src/routes/messages/utils.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/routes/messages/non-stream-translation.ts
+const OPENAI_TOOL_NAME_LIMIT = 64;
+function fixMessageSequence(messages) {
+	const fixedMessages = [];
+	for (let i = 0; i < messages.length; i++) {
+		const message = messages[i];
+		fixedMessages.push(message);
+		if (message.role === "assistant" && message.tool_calls && message.tool_calls.length > 0) {
+			const foundToolResponses = /* @__PURE__ */ new Set();
+			let j = i + 1;
+			while (j < messages.length && messages[j].role === "tool") {
+				const toolMessage = messages[j];
+				if (toolMessage.tool_call_id) foundToolResponses.add(toolMessage.tool_call_id);
+				j++;
+			}
+			for (const toolCall of message.tool_calls) if (!foundToolResponses.has(toolCall.id)) {
+				consola.debug(`Adding placeholder tool_result for ${toolCall.id}`);
+				fixedMessages.push({
+					role: "tool",
+					tool_call_id: toolCall.id,
+					content: "Tool execution was interrupted or failed."
+				});
+			}
+		}
+	}
+	return fixedMessages;
+}
+function translateToOpenAI(payload) {
+	const toolNameMapping = {
+		truncatedToOriginal: /* @__PURE__ */ new Map(),
+		originalToTruncated: /* @__PURE__ */ new Map()
+	};
+	const messages = translateAnthropicMessagesToOpenAI(payload.messages, payload.system, toolNameMapping);
+	return {
+		payload: {
+			model: translateModelName(payload.model),
+			messages: fixMessageSequence(messages),
+			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: translateAnthropicToolsToOpenAI(payload.tools, toolNameMapping),
+			tool_choice: translateAnthropicToolChoiceToOpenAI(payload.tool_choice, toolNameMapping)
+		},
+		toolNameMapping
+	};
+}
+function translateModelName(model) {
+	const shortNameMap = {
+		opus: "claude-opus-4.5",
+		sonnet: "claude-sonnet-4.5",
+		haiku: "claude-haiku-4.5"
+	};
+	if (shortNameMap[model]) return shortNameMap[model];
+	if (model.match(/^claude-sonnet-4-5-\d+$/)) return "claude-sonnet-4.5";
+	if (model.match(/^claude-sonnet-4-\d+$/)) return "claude-sonnet-4";
+	if (model.match(/^claude-opus-4-5-\d+$/)) return "claude-opus-4.5";
+	if (model.match(/^claude-opus-4-\d+$/)) return "claude-opus-4.5";
+	if (model.match(/^claude-haiku-4-5-\d+$/)) return "claude-haiku-4.5";
+	if (model.match(/^claude-haiku-3-5-\d+$/)) return "claude-haiku-4.5";
+	return model;
+}
+function translateAnthropicMessagesToOpenAI(anthropicMessages, system, toolNameMapping) {
+	const systemMessages = handleSystemPrompt(system);
+	const otherMessages = anthropicMessages.flatMap((message) => message.role === "user" ? handleUserMessage(message) : handleAssistantMessage(message, toolNameMapping));
+	return [...systemMessages, ...otherMessages];
+}
+function handleSystemPrompt(system) {
+	if (!system) return [];
+	if (typeof system === "string") return [{
+		role: "system",
+		content: system
+	}];
+	else return [{
+		role: "system",
+		content: system.map((block) => block.text).join("\n\n")
+	}];
+}
+function 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: mapContent(block.content)
+		});
+		if (otherBlocks.length > 0) newMessages.push({
+			role: "user",
+			content: mapContent(otherBlocks)
+		});
+	} else newMessages.push({
+		role: "user",
+		content: mapContent(message.content)
+	});
+	return newMessages;
+}
+function handleAssistantMessage(message, toolNameMapping) {
+	if (!Array.isArray(message.content)) return [{
+		role: "assistant",
+		content: 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: getTruncatedToolName(toolUse.name, toolNameMapping),
+				arguments: JSON.stringify(toolUse.input)
+			}
+		}))
+	}] : [{
+		role: "assistant",
+		content: mapContent(message.content)
+	}];
+}
+function 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;
+	}
+	return contentParts;
+}
+function getTruncatedToolName(originalName, toolNameMapping) {
+	if (originalName.length <= OPENAI_TOOL_NAME_LIMIT) return originalName;
+	const existingTruncated = toolNameMapping.originalToTruncated.get(originalName);
+	if (existingTruncated) return existingTruncated;
+	let hash = 0;
+	for (let i = 0; i < originalName.length; i++) {
+		const char = originalName.charCodeAt(i);
+		hash = (hash << 5) - hash + char;
+		hash = hash & hash;
+	}
+	const hashSuffix = Math.abs(hash).toString(36).slice(0, 8);
+	const truncatedName = originalName.slice(0, OPENAI_TOOL_NAME_LIMIT - 9) + "_" + hashSuffix;
+	toolNameMapping.truncatedToOriginal.set(truncatedName, originalName);
+	toolNameMapping.originalToTruncated.set(originalName, truncatedName);
+	consola.debug(`Truncated tool name: "${originalName}" -> "${truncatedName}"`);
+	return truncatedName;
+}
+function translateAnthropicToolsToOpenAI(anthropicTools, toolNameMapping) {
+	if (!anthropicTools) return;
+	return anthropicTools.map((tool) => ({
+		type: "function",
+		function: {
+			name: getTruncatedToolName(tool.name, toolNameMapping),
+			description: tool.description,
+			parameters: tool.input_schema
+		}
+	}));
+}
+function translateAnthropicToolChoiceToOpenAI(anthropicToolChoice, toolNameMapping) {
+	if (!anthropicToolChoice) return;
+	switch (anthropicToolChoice.type) {
+		case "auto": return "auto";
+		case "any": return "required";
+		case "tool":
+			if (anthropicToolChoice.name) return {
+				type: "function",
+				function: { name: getTruncatedToolName(anthropicToolChoice.name, toolNameMapping) }
+			};
+			return;
+		case "none": return "none";
+		default: return;
+	}
+}
+function translateToAnthropic(response, toolNameMapping) {
+	if (response.choices.length === 0) return {
+		id: response.id,
+		type: "message",
+		role: "assistant",
+		model: response.model,
+		content: [],
+		stop_reason: "end_turn",
+		stop_sequence: null,
+		usage: {
+			input_tokens: response.usage?.prompt_tokens ?? 0,
+			output_tokens: response.usage?.completion_tokens ?? 0
+		}
+	};
+	const allTextBlocks = [];
+	const allToolUseBlocks = [];
+	let stopReason = null;
+	stopReason = response.choices[0]?.finish_reason ?? stopReason;
+	for (const choice of response.choices) {
+		const textBlocks = getAnthropicTextBlocks(choice.message.content);
+		const toolUseBlocks = getAnthropicToolUseBlocks(choice.message.tool_calls, toolNameMapping);
+		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 }
+		}
+	};
+}
+function 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 [];
+}
+function getAnthropicToolUseBlocks(toolCalls, toolNameMapping) {
+	if (!toolCalls) return [];
+	return toolCalls.map((toolCall) => {
+		let input = {};
+		try {
+			input = JSON.parse(toolCall.function.arguments);
+		} catch (error) {
+			consola.warn(`Failed to parse tool call arguments for ${toolCall.function.name}:`, error);
+		}
+		const originalName = toolNameMapping?.truncatedToOriginal.get(toolCall.function.name) ?? toolCall.function.name;
+		return {
+			type: "tool_use",
+			id: toolCall.id,
+			name: originalName,
+			input
+		};
+	});
+}
+
+//#endregion
+//#region src/routes/messages/count-tokens-handler.ts
+/**
+* Handles token counting for Anthropic messages
+*/
+async function handleCountTokens(c) {
+	try {
+		const anthropicBeta = c.req.header("anthropic-beta");
+		const anthropicPayload = await c.req.json();
+		const { payload: openAIPayload } = translateToOpenAI(anthropicPayload);
+		const selectedModel = state.models?.data.find((model) => model.id === anthropicPayload.model);
+		if (!selectedModel) {
+			consola.warn("Model not found, returning default token count");
+			return c.json({ input_tokens: 1 });
+		}
+		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 });
+	} catch (error) {
+		consola.error("Error counting tokens:", error);
+		return c.json({ input_tokens: 1 });
+	}
+}
+
+//#endregion
+//#region src/routes/messages/stream-translation.ts
+function isToolBlockOpen(state$1) {
+	if (!state$1.contentBlockOpen) return false;
+	return Object.values(state$1.toolCalls).some((tc) => tc.anthropicBlockIndex === state$1.contentBlockIndex);
+}
+function translateChunkToAnthropicEvents(chunk, state$1, toolNameMapping) {
+	const events$1 = [];
+	if (chunk.choices.length === 0) {
+		if (chunk.model && !state$1.model) state$1.model = chunk.model;
+		return events$1;
+	}
+	const choice = chunk.choices[0];
+	const { delta } = choice;
+	if (!state$1.messageStartSent) {
+		const model = chunk.model || state$1.model || "unknown";
+		events$1.push({
+			type: "message_start",
+			message: {
+				id: chunk.id || `msg_${Date.now()}`,
+				type: "message",
+				role: "assistant",
+				content: [],
+				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 }
+				}
+			}
+		});
+		state$1.messageStartSent = true;
+	}
+	if (delta.content) {
+		if (isToolBlockOpen(state$1)) {
+			events$1.push({
+				type: "content_block_stop",
+				index: state$1.contentBlockIndex
+			});
+			state$1.contentBlockIndex++;
+			state$1.contentBlockOpen = false;
+		}
+		if (!state$1.contentBlockOpen) {
+			events$1.push({
+				type: "content_block_start",
+				index: state$1.contentBlockIndex,
+				content_block: {
+					type: "text",
+					text: ""
+				}
+			});
+			state$1.contentBlockOpen = true;
+		}
+		events$1.push({
+			type: "content_block_delta",
+			index: state$1.contentBlockIndex,
+			delta: {
+				type: "text_delta",
+				text: delta.content
+			}
+		});
+	}
+	if (delta.tool_calls) for (const toolCall of delta.tool_calls) {
+		if (toolCall.id && toolCall.function?.name) {
+			if (state$1.contentBlockOpen) {
+				events$1.push({
+					type: "content_block_stop",
+					index: state$1.contentBlockIndex
+				});
+				state$1.contentBlockIndex++;
+				state$1.contentBlockOpen = false;
+			}
+			const originalName = toolNameMapping?.truncatedToOriginal.get(toolCall.function.name) ?? toolCall.function.name;
+			const anthropicBlockIndex = state$1.contentBlockIndex;
+			state$1.toolCalls[toolCall.index] = {
+				id: toolCall.id,
+				name: originalName,
+				anthropicBlockIndex
+			};
+			events$1.push({
+				type: "content_block_start",
+				index: anthropicBlockIndex,
+				content_block: {
+					type: "tool_use",
+					id: toolCall.id,
+					name: originalName,
+					input: {}
+				}
+			});
+			state$1.contentBlockOpen = true;
+		}
+		if (toolCall.function?.arguments) {
+			const toolCallInfo = state$1.toolCalls[toolCall.index];
+			if (toolCallInfo) events$1.push({
+				type: "content_block_delta",
+				index: toolCallInfo.anthropicBlockIndex,
+				delta: {
+					type: "input_json_delta",
+					partial_json: toolCall.function.arguments
+				}
+			});
+		}
+	}
+	if (choice.finish_reason) {
+		if (state$1.contentBlockOpen) {
+			events$1.push({
+				type: "content_block_stop",
+				index: state$1.contentBlockIndex
+			});
+			state$1.contentBlockOpen = false;
+		}
+		events$1.push({
+			type: "message_delta",
+			delta: {
+				stop_reason: mapOpenAIStopReasonToAnthropic(choice.finish_reason),
+				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" });
+	}
+	return events$1;
+}
+function translateErrorToAnthropicErrorEvent() {
+	return {
+		type: "error",
+		error: {
+			type: "api_error",
+			message: "An unexpected error occurred during streaming."
+		}
+	};
+}
+
+//#endregion
+//#region src/routes/messages/handler.ts
+async function handleCompletion(c) {
+	const startTime = Date.now();
+	const anthropicPayload = await c.req.json();
+	consola.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
+	const historyId = recordRequest("anthropic", {
+		model: anthropicPayload.model,
+		messages: convertAnthropicMessages(anthropicPayload.messages),
+		stream: anthropicPayload.stream ?? false,
+		tools: anthropicPayload.tools?.map((t) => ({
+			name: t.name,
+			description: t.description
+		})),
+		max_tokens: anthropicPayload.max_tokens,
+		temperature: anthropicPayload.temperature,
+		system: extractSystemPrompt(anthropicPayload.system)
+	});
+	const { payload: openAIPayload, toolNameMapping } = translateToOpenAI(anthropicPayload);
+	consola.debug("Translated OpenAI request payload:", JSON.stringify(openAIPayload));
+	if (state.manualApprove) await awaitApproval();
+	try {
+		const response = await executeWithRateLimit(state, () => createChatCompletions(openAIPayload));
+		if (isNonStreaming(response)) {
+			consola.debug("Non-streaming response from Copilot:", JSON.stringify(response).slice(-400));
+			const anthropicResponse = translateToAnthropic(response, toolNameMapping);
+			consola.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
+			recordResponse(historyId, {
+				success: true,
+				model: anthropicResponse.model,
+				usage: anthropicResponse.usage,
+				stop_reason: anthropicResponse.stop_reason ?? void 0,
+				content: {
+					role: "assistant",
+					content: anthropicResponse.content.map((block) => {
+						if (block.type === "text") return {
+							type: "text",
+							text: block.text
+						};
+						if (block.type === "tool_use") return {
+							type: "tool_use",
+							id: block.id,
+							name: block.name,
+							input: JSON.stringify(block.input)
+						};
+						return { type: block.type };
+					})
+				},
+				toolCalls: extractToolCallsFromContent(anthropicResponse.content)
+			}, Date.now() - startTime);
+			return c.json(anthropicResponse);
+		}
+		consola.debug("Streaming response from Copilot");
+		return streamSSE(c, async (stream) => {
+			const streamState = {
+				messageStartSent: false,
+				contentBlockIndex: 0,
+				contentBlockOpen: false,
+				toolCalls: {}
+			};
+			let streamModel = "";
+			let streamInputTokens = 0;
+			let streamOutputTokens = 0;
+			let streamStopReason = "";
+			let streamContent = "";
+			const streamToolCalls = [];
+			let currentToolCall = null;
+			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;
+					let chunk;
+					try {
+						chunk = JSON.parse(rawEvent.data);
+					} catch (parseError) {
+						consola.error("Failed to parse stream chunk:", parseError, rawEvent.data);
+						continue;
+					}
+					if (chunk.model && !streamModel) streamModel = chunk.model;
+					const events$1 = translateChunkToAnthropicEvents(chunk, streamState, toolNameMapping);
+					for (const event of events$1) {
+						consola.debug("Translated Anthropic event:", JSON.stringify(event));
+						switch (event.type) {
+							case "content_block_delta":
+								if ("text" in event.delta) streamContent += event.delta.text;
+								else if ("partial_json" in event.delta && currentToolCall) currentToolCall.input += event.delta.partial_json;
+								break;
+							case "content_block_start":
+								if (event.content_block.type === "tool_use") currentToolCall = {
+									id: event.content_block.id,
+									name: event.content_block.name,
+									input: ""
+								};
+								break;
+							case "content_block_stop":
+								if (currentToolCall) {
+									streamToolCalls.push(currentToolCall);
+									currentToolCall = null;
+								}
+								break;
+							case "message_delta":
+								if (event.delta.stop_reason) streamStopReason = event.delta.stop_reason;
+								if (event.usage) {
+									streamInputTokens = event.usage.input_tokens ?? 0;
+									streamOutputTokens = event.usage.output_tokens;
+								}
+								break;
+						}
+						await stream.writeSSE({
+							event: event.type,
+							data: JSON.stringify(event)
+						});
+					}
+				}
+				const contentBlocks = [];
+				if (streamContent) contentBlocks.push({
+					type: "text",
+					text: streamContent
+				});
+				for (const tc of streamToolCalls) contentBlocks.push({
+					type: "tool_use",
+					...tc
+				});
+				recordResponse(historyId, {
+					success: true,
+					model: streamModel || anthropicPayload.model,
+					usage: {
+						input_tokens: streamInputTokens,
+						output_tokens: streamOutputTokens
+					},
+					stop_reason: streamStopReason || void 0,
+					content: contentBlocks.length > 0 ? {
+						role: "assistant",
+						content: contentBlocks
+					} : null,
+					toolCalls: streamToolCalls.length > 0 ? streamToolCalls.map((tc) => ({
+						id: tc.id,
+						name: tc.name,
+						input: tc.input
+					})) : void 0
+				}, Date.now() - startTime);
+			} catch (error) {
+				consola.error("Stream error:", error);
+				recordResponse(historyId, {
+					success: false,
+					model: streamModel || anthropicPayload.model,
+					usage: {
+						input_tokens: 0,
+						output_tokens: 0
+					},
+					error: error instanceof Error ? error.message : "Stream error",
+					content: null
+				}, Date.now() - startTime);
+				const errorEvent = translateErrorToAnthropicErrorEvent();
+				await stream.writeSSE({
+					event: errorEvent.type,
+					data: JSON.stringify(errorEvent)
+				});
+			}
+		});
+	} catch (error) {
+		recordResponse(historyId, {
+			success: false,
+			model: anthropicPayload.model,
+			usage: {
+				input_tokens: 0,
+				output_tokens: 0
+			},
+			error: error instanceof Error ? error.message : "Unknown error",
+			content: null
+		}, Date.now() - startTime);
+		throw error;
+	}
+}
+function convertAnthropicMessages(messages) {
+	return messages.map((msg) => {
+		if (typeof msg.content === "string") return {
+			role: msg.role,
+			content: msg.content
+		};
+		const content = msg.content.map((block) => {
+			if (block.type === "text") return {
+				type: "text",
+				text: block.text
+			};
+			if (block.type === "tool_use") return {
+				type: "tool_use",
+				id: block.id,
+				name: block.name,
+				input: JSON.stringify(block.input)
+			};
+			if (block.type === "tool_result") {
+				const resultContent = typeof block.content === "string" ? block.content : block.content.map((c) => c.type === "text" ? c.text : `[${c.type}]`).join("\n");
+				return {
+					type: "tool_result",
+					tool_use_id: block.tool_use_id,
+					content: resultContent
+				};
+			}
+			return { type: block.type };
+		});
+		return {
+			role: msg.role,
+			content
+		};
+	});
+}
+function extractSystemPrompt(system) {
+	if (!system) return void 0;
+	if (typeof system === "string") return system;
+	return system.map((block) => block.text).join("\n");
+}
+function extractToolCallsFromContent(content) {
+	const tools = [];
+	for (const block of content) if (typeof block === "object" && block !== null && "type" in block && block.type === "tool_use" && "id" in block && "name" in block && "input" in block) tools.push({
+		id: String(block.id),
+		name: String(block.name),
+		input: JSON.stringify(block.input)
+	});
+	return tools.length > 0 ? tools : void 0;
+}
+const isNonStreaming = (response) => Object.hasOwn(response, "choices");
+
+//#endregion
+//#region src/routes/messages/route.ts
+const messageRoutes = new Hono();
+messageRoutes.post("/", async (c) => {
+	try {
+		return await handleCompletion(c);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+messageRoutes.post("/count_tokens", async (c) => {
+	try {
+		return await handleCountTokens(c);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+
+//#endregion
+//#region src/routes/models/route.ts
+const modelRoutes = new Hono();
+modelRoutes.get("/", async (c) => {
+	try {
+		if (!state.models) await cacheModels();
+		const models = state.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
+		});
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+
+//#endregion
+//#region src/routes/token/route.ts
+const tokenRoute = new Hono();
+tokenRoute.get("/", async (c) => {
+	try {
+		return c.json({ token: state.copilotToken });
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+
+//#endregion
+//#region src/routes/usage/route.ts
+const usageRoute = new Hono();
+usageRoute.get("/", async (c) => {
+	try {
+		const usage = await getCopilotUsage();
+		return c.json(usage);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+
+//#endregion
+//#region src/server.ts
+const server = new Hono();
+server.use(logger());
+server.use(cors());
+server.get("/", (c) => c.text("Server running"));
+server.get("/health", (c) => {
+	const healthy = Boolean(state.copilotToken && state.githubToken);
+	return c.json({
+		status: healthy ? "healthy" : "unhealthy",
+		checks: {
+			copilotToken: Boolean(state.copilotToken),
+			githubToken: Boolean(state.githubToken),
+			models: Boolean(state.models)
+		}
+	}, healthy ? 200 : 503);
+});
+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);
+server.route("/api/event_logging", eventLoggingRoutes);
+server.route("/history", historyRoutes);
+
+//#endregion
+//#region src/start.ts
+async function runServer(options) {
+	if (options.proxyEnv) initProxyFromEnv();
+	if (options.verbose) {
+		consola.level = 5;
+		consola.info("Verbose logging enabled");
+	}
+	state.accountType = options.accountType;
+	if (options.accountType !== "individual") consola.info(`Using ${options.accountType} plan GitHub account`);
+	state.manualApprove = options.manual;
+	state.rateLimitSeconds = options.rateLimit;
+	state.rateLimitWait = options.rateLimitWait;
+	state.showToken = options.showToken;
+	initHistory(options.history, options.historyLimit);
+	if (options.history) consola.info(`History recording enabled (max ${options.historyLimit} entries)`);
+	await ensurePaths();
+	await cacheVSCodeVersion();
+	if (options.githubToken) {
+		state.githubToken = options.githubToken;
+		consola.info("Using provided GitHub token");
+	} else await setupGitHubToken();
+	await setupCopilotToken();
+	await cacheModels();
+	consola.info(`Available models: \n${state.models?.data.map((model) => `- ${model.id}`).join("\n")}`);
+	const serverUrl = `http://${options.host ?? "localhost"}:${options.port}`;
+	if (options.claudeCode) {
+		invariant(state.models, "Models should be loaded by now");
+		const selectedModel = await consola.prompt("Select a model to use with Claude Code", {
+			type: "select",
+			options: state.models.data.map((model) => model.id)
+		});
+		const selectedSmallModel = await consola.prompt("Select a small model to use with Claude Code", {
+			type: "select",
+			options: state.models.data.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);
+		}
+	}
+	consola.box(`🌐 Usage Viewer: https://ericc-ch.github.io/copilot-api?endpoint=${serverUrl}/usage${options.history ? `\n📜 History UI: ${serverUrl}/history` : ""}`);
+	serve({
+		fetch: server.fetch,
+		port: options.port,
+		hostname: options.host
+	});
+}
+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"
+		},
+		host: {
+			alias: "H",
+			type: "string",
+			description: "Host/interface to bind to (e.g., 127.0.0.1 for localhost only, 0.0.0.0 for all interfaces)"
+		},
+		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"
+		},
+		history: {
+			type: "boolean",
+			default: false,
+			description: "Enable request history recording and Web UI at /history"
+		},
+		"history-limit": {
+			type: "string",
+			default: "1000",
+			description: "Maximum number of history entries to keep in memory"
+		}
+	},
+	run({ args }) {
+		const rateLimitRaw = args["rate-limit"];
+		const rateLimit = rateLimitRaw === void 0 ? void 0 : Number.parseInt(rateLimitRaw, 10);
+		return runServer({
+			port: Number.parseInt(args.port, 10),
+			host: args.host,
+			verbose: args.verbose,
+			accountType: args["account-type"],
+			manual: args.manual,
+			rateLimit,
+			rateLimitWait: args.wait,
+			githubToken: args["github-token"],
+			claudeCode: args["claude-code"],
+			showToken: args["show-token"],
+			proxyEnv: args["proxy-env"],
+			history: args.history,
+			historyLimit: Number.parseInt(args["history-limit"], 10)
+		});
+	}
+});
+
+//#endregion
+//#region src/main.ts
+consola.options.formatOptions.date = true;
+const main = defineCommand({
+	meta: {
+		name: "copilot-api",
+		description: "A wrapper around GitHub Copilot API to make it OpenAI compatible, making it usable for other tools."
+	},
+	subCommands: {
+		auth,
+		logout,
+		start,
+		"check-usage": checkUsage,
+		debug
+	}
+});
+await runMain(main);
+
+//#endregion
+export {  };
+//# sourceMappingURL=main.js.map