copilot-api-node20 0.6.0 → 0.7.0

package/dist/main.js

@@ -4,8 +4,7 @@ import consola from "consola";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { EventEmitter } from "node:events";
-import { randomUUID } from "node:crypto";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
 import clipboard from "clipboardy";
 import process$1 from "node:process";
 import { serve } from "srvx";
@@ -13,22 +12,26 @@ import invariant from "tiny-invariant";
 import { execSync } from "node:child_process";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
-import { logger } from "hono/logger";
 import { streamSSE } from "hono/streaming";
-import { countTokens } from "gpt-tokenizer/model/gpt-4o";
 import { events } from "fetch-event-stream";
 import { request } from "undici";
 
 //#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 MACHINE_ID_PATH = path.join(APP_DIR, "machine_id");
+const SESSION_ID_PATH = path.join(APP_DIR, "session_id");
 const PATHS = {
 	APP_DIR,
-	GITHUB_TOKEN_PATH
+	GITHUB_TOKEN_PATH,
+	MACHINE_ID_PATH,
+	SESSION_ID_PATH
 };
 async function ensurePaths() {
 	await fs.mkdir(PATHS.APP_DIR, { recursive: true });
 	await ensureFile(PATHS.GITHUB_TOKEN_PATH);
+	await ensureFile(PATHS.MACHINE_ID_PATH);
+	await ensureFile(PATHS.SESSION_ID_PATH);
 }
 async function ensureFile(filePath) {
 	try {
@@ -64,7 +67,7 @@ const state = {
 
 //#endregion
 //#region src/lib/connectivity.ts
-var ConnectivityMonitor = class extends EventEmitter {
+var ConnectivityMonitor = class extends EventTarget {
 	isOnline = true;
 	lastChecked = (/* @__PURE__ */ new Date()).toISOString();
 	consecutiveFailures = 0;
@@ -74,6 +77,14 @@ var ConnectivityMonitor = class extends EventEmitter {
 	endpointFailureStats = {};
 	checkInterval;
 	abortController;
+	on(event, listener) {
+		this.addEventListener(event, listener);
+		return this;
+	}
+	off(event, listener) {
+		this.removeEventListener(event, listener);
+		return this;
+	}
 	start() {
 		if (!state.connectivity.enabled) {
 			consola.debug("Connectivity monitoring disabled");
@@ -108,7 +119,9 @@ var ConnectivityMonitor = class extends EventEmitter {
 		const jitter = Math.random() * state.connectivity.jitterMaxMs;
 		const interval = baseInterval + jitter;
 		this.checkInterval = setTimeout(() => {
-			this.performConnectivityCheck();
+			this.performConnectivityCheck().catch((error) => {
+				consola.error("Connectivity check failed:", error);
+			});
 		}, interval);
 	}
 	async performConnectivityCheck() {
@@ -151,12 +164,12 @@ var ConnectivityMonitor = class extends EventEmitter {
 			this.consecutiveFailures = 0;
 			this.lastErrorType = void 0;
 			this.lastErrorMessage = void 0;
-			if (!wasOnline) this.emit("online");
+			if (!wasOnline) this.dispatchEvent(new CustomEvent("online"));
 		} else {
 			this.consecutiveFailures++;
 			if (wasOnline) {
 				consola.warn("Connectivity lost");
-				this.emit("offline");
+				this.dispatchEvent(new CustomEvent("offline"));
 			}
 		}
 	}
@@ -197,24 +210,68 @@ const standardHeaders = () => ({
 	"content-type": "application/json",
 	accept: "application/json"
 });
-const COPILOT_VERSION = "0.32.2025093001";
+const COPILOT_VERSION = "0.32.2025100203";
 const EDITOR_PLUGIN_VERSION = `copilot-chat/${COPILOT_VERSION}`;
 const USER_AGENT = `GitHubCopilotChat/${COPILOT_VERSION}`;
 const API_VERSION = "2025-08-20";
+const generateMachineId = () => {
+	const hash = createHash("sha256");
+	hash.update(process.platform);
+	hash.update(process.arch);
+	hash.update(process.env.USER || process.env.USERNAME || "anonymous");
+	hash.update(os.hostname());
+	hash.update(Date.now().toString());
+	hash.update(randomBytes(16));
+	return hash.digest("hex");
+};
+const readMachineId = async () => {
+	try {
+		const machineId = await fs.readFile(PATHS.MACHINE_ID_PATH, "utf8");
+		if (machineId.trim()) return machineId.trim();
+	} catch {}
+	const newMachineId = generateMachineId();
+	await fs.writeFile(PATHS.MACHINE_ID_PATH, newMachineId);
+	await fs.chmod(PATHS.MACHINE_ID_PATH, 384);
+	return newMachineId;
+};
+const readSessionId = async () => {
+	try {
+		const sessionId = await fs.readFile(PATHS.SESSION_ID_PATH, "utf8");
+		if (sessionId.trim()) return sessionId.trim();
+	} catch {}
+	const newSessionId = randomUUID();
+	await fs.writeFile(PATHS.SESSION_ID_PATH, newSessionId);
+	await fs.chmod(PATHS.SESSION_ID_PATH, 384);
+	return newSessionId;
+};
+const initializeVSCodeIdentifiers = async (state$1) => {
+	if (!state$1.machineId) state$1.machineId = await readMachineId();
+	if (!state$1.sessionId) state$1.sessionId = await readSessionId();
+};
 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) => {
+	if (!state$1.machineId || !state$1.sessionId) throw new Error("VSCode identifiers not initialized. Call initializeVSCodeIdentifiers() during startup.");
 	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": "model-access",
-		"x-github-api-version": API_VERSION,
-		"x-interaction-type": "model-access",
-		"x-request-id": randomUUID(),
-		"x-vscode-user-agent-library-version": "electron-fetch"
+		"Content-Type": "application/json",
+		accept: "*/*",
+		"accept-encoding": "br, gzip, deflate",
+		"accept-language": "*",
+		"sec-fetch-mode": "cors",
+		"Copilot-Integration-Id": "vscode-chat",
+		"Editor-Version": `vscode/${state$1.vsCodeVersion}`,
+		"Editor-Plugin-Version": EDITOR_PLUGIN_VERSION,
+		"User-Agent": USER_AGENT,
+		"VScode-MachineId": state$1.machineId,
+		"VScode-SessionId": state$1.sessionId,
+		"OpenAI-Intent": "conversation-agent",
+		"X-Interaction-Type": "conversation-agent",
+		"X-VSCode-User-Agent-Library-Version": "node-fetch",
+		"X-GitHub-Api-Version": API_VERSION,
+		"X-Interaction-Id": randomUUID(),
+		"X-Request-Id": randomUUID(),
+		"openai-intent": "conversation-agent",
+		"x-interaction-type": "conversation-agent"
 	};
 	if (vision) headers["copilot-vision-request"] = "true";
 	return headers;
@@ -227,11 +284,119 @@ const githubHeaders = (state$1) => ({
 	"editor-plugin-version": EDITOR_PLUGIN_VERSION,
 	"user-agent": USER_AGENT,
 	"x-github-api-version": API_VERSION,
-	"x-vscode-user-agent-library-version": "electron-fetch"
+	"x-vscode-user-agent-library-version": "node-fetch"
 });
 const GITHUB_BASE_URL = "https://github.com";
-const GITHUB_CLIENT_ID = "Iv1.b507a08c87ecfe98";
-const GITHUB_APP_SCOPES = ["read:user"].join(" ");
+const GITHUB_CLIENT_ID = "01ab8ac9400c4e429b23";
+const GITHUB_APP_SCOPES = ["user:email"].join(" ");
+
+//#endregion
+//#region src/lib/logger/completion-logger.ts
+const humanize = (num) => {
+	if (num >= 1e5) return `${Math.round(num / 1e3)}K`;
+	if (num >= 1e4) return `${Math.round(num / 1e3)}K`;
+	if (num >= 1e3) return `${(num / 1e3).toFixed(1)}K`;
+	return num.toString();
+};
+const pad = (str, length) => str.padEnd(length);
+const getContextPercentage = (contextWindow, model) => {
+	if (!state.models) return "";
+	const selectedModel = state.models.data.find((m) => m.id === model);
+	if (!selectedModel) return "";
+	const maxContextTokens = selectedModel.capabilities.limits.max_context_window_tokens;
+	if (!maxContextTokens) return "";
+	const percentage = (contextWindow / maxContextTokens * 100).toFixed(1);
+	return ` (${percentage}%)`;
+};
+const formatTokenUsage = (requestData) => {
+	const parts = [];
+	if (requestData.model) {
+		const model = pad(requestData.model, 18);
+		parts.push(model);
+	}
+	if (requestData.tokenUsage) {
+		const usage = requestData.tokenUsage;
+		const contextWindow = (usage.inputTokens || 0) + (usage.outputTokens || 0);
+		const contextPercentage = requestData.model ? getContextPercentage(contextWindow, requestData.model) : "";
+		const input = humanize(usage.inputTokens || 0).padStart(5);
+		const output = humanize(usage.outputTokens || 0).padStart(5);
+		const tokenPart = `↑${input} │ ↓${output}`;
+		const tokens = pad(tokenPart, 18);
+		const contextNum = contextWindow.toString();
+		const contextFormatted = contextPercentage ? `${contextNum}${contextPercentage.padStart(15 - contextNum.length)}` : contextNum.padEnd(15);
+		parts.push(`Tokens: ${tokens} | Context: ${contextFormatted}`);
+	} else if (requestData.model) {
+		const tokens = pad("N/A", 18);
+		const context = "N/A".padEnd(15);
+		parts.push(`Tokens: ${tokens} | Context: ${context}`);
+	}
+	if (requestData.copilotDuration) {
+		const apiDuration = pad(`${Math.round(requestData.copilotDuration)}ms`, 8);
+		parts.push(`API: ${apiDuration}`);
+	}
+	return parts.length > 0 ? ` | ${parts.join(" | ")}` : "";
+};
+const CompletionLogger = {
+	completionCallbacks: /* @__PURE__ */ new Map(),
+	registerCompletion(requestId, context, startTime) {
+		this.completionCallbacks.set(requestId, {
+			context,
+			startTime,
+			requestId
+		});
+	},
+	executeCompletion(requestId) {
+		const data = this.completionCallbacks.get(requestId);
+		if (data) {
+			this.logCompletion(data);
+			this.completionCallbacks.delete(requestId);
+		}
+	},
+	logCompletion(data) {
+		const { context: c, startTime } = data;
+		const end = Date.now();
+		const duration = end - startTime;
+		const requestData = c.get("requestData");
+		const method = pad(c.req.method, 4);
+		const path$1 = pad(c.req.path, 18);
+		const status = pad(c.res.status.toString(), 3);
+		const durationStr = pad(`${duration}ms`, 8);
+		let logLine = `  --> ${method}${path$1}${status} ${durationStr}`;
+		if (requestData) logLine += formatTokenUsage(requestData);
+		consola.info(logLine);
+	},
+	logRateLimit(data, response) {
+		const { context: c, startTime } = data;
+		const end = Date.now();
+		const duration = end - startTime;
+		const rateLimitExceeded = response.headers.get("x-ratelimit-exceeded") || "";
+		const rateLimitType = rateLimitExceeded.split(":")[1] || "unknown";
+		const retry = response.headers.get("retry-after") || response.headers.get("x-ratelimit-user-retry-after") || "?";
+		const method = pad(c.req.method, 4);
+		const path$1 = pad(c.req.path, 18);
+		const status = pad("429", 3);
+		const durationStr = pad(`${duration}ms`, 8);
+		let logLine = `⚠   --> ${method}${path$1}${status} ${durationStr}`;
+		logLine += ` | Rate limited (${retry}s retry) | ${rateLimitType}`;
+		const requestData = c.get("requestData");
+		if (requestData?.copilotDuration) {
+			const apiDuration = pad(`${Math.round(requestData.copilotDuration)}ms`, 8);
+			logLine += ` | API: ${apiDuration}`;
+		}
+		consola.info(logLine);
+	},
+	cleanup() {
+		const MAX_CALLBACKS = 1e3;
+		const fiveMinutesAgo = Date.now() - 300 * 1e3;
+		for (const [requestId, data] of this.completionCallbacks) if (data.startTime < fiveMinutesAgo) this.completionCallbacks.delete(requestId);
+		if (this.completionCallbacks.size > MAX_CALLBACKS) {
+			const entries = Array.from(this.completionCallbacks.entries()).sort(([, a], [, b]) => a.startTime - b.startTime);
+			const toRemove = entries.slice(0, entries.length - MAX_CALLBACKS);
+			for (const [requestId] of toRemove) this.completionCallbacks.delete(requestId);
+		}
+	}
+};
+setInterval(() => CompletionLogger.cleanup(), 60 * 1e3);
 
 //#endregion
 //#region src/lib/error.ts
@@ -243,6 +408,25 @@ var HTTPError = class extends Error {
 	}
 };
 async function forwardError(c, error) {
+	if (error instanceof HTTPError && error.response.status === 429) {
+		const requestId = c.get("requestId");
+		const completionData = CompletionLogger.completionCallbacks.get(requestId);
+		if (completionData) {
+			CompletionLogger.logRateLimit(completionData, error.response);
+			CompletionLogger.completionCallbacks.delete(requestId);
+		}
+		const errorText = await error.response.text();
+		let errorJson;
+		try {
+			errorJson = JSON.parse(errorText);
+		} catch {
+			errorJson = { error: {
+				message: errorText,
+				type: "error"
+			} };
+		}
+		return c.json(errorJson, 429);
+	}
 	consola.error("Error occurred:", error);
 	if (error instanceof HTTPError) {
 		const errorText = await error.response.text();
@@ -369,8 +553,8 @@ async function cacheModels() {
 	const models = await getModels();
 	state.models = models;
 }
-const cacheVSCodeVersion = async () => {
-	const response = await getVSCodeVersion();
+const cacheVSCodeVersion = () => {
+	const response = getVSCodeVersion();
 	state.vsCodeVersion = response;
 	consola.info(`Using VSCode version: ${response}`);
 };
@@ -627,7 +811,8 @@ const checkUsage = defineCommand({
 async function getPackageVersion() {
 	try {
 		const packageJsonPath = new URL("../package.json", import.meta.url).pathname;
-		const packageJson = JSON.parse(await fs.readFile(packageJsonPath));
+		const packageJsonBuffer = await fs.readFile(packageJsonPath);
+		const packageJson = JSON.parse(packageJsonBuffer.toString());
 		return packageJson.version;
 	} catch {
 		return "unknown";
@@ -756,6 +941,24 @@ function generateEnvScript(envVars, commandToRun = "") {
 	return commandBlock || commandToRun;
 }
 
+//#endregion
+//#region src/lib/logger/enhanced-hono-logger.ts
+function generateRequestId() {
+	return `req_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+}
+function enhancedLogger() {
+	return async (c, next) => {
+		const start$1 = Date.now();
+		const requestId = generateRequestId();
+		c.set("requestId", requestId);
+		c.header("x-request-id", requestId);
+		CompletionLogger.registerCompletion(requestId, c, start$1);
+		await next();
+		const requestData = c.get("requestData");
+		if (requestData?.tokenUsage) CompletionLogger.executeCompletion(requestId);
+	};
+}
+
 //#endregion
 //#region src/lib/approval.ts
 const awaitApproval = async () => {
@@ -763,6 +966,28 @@ const awaitApproval = async () => {
 	if (!response) throw new HTTPError("Request rejected", Response.json({ message: "Request rejected" }, { status: 403 }));
 };
 
+//#endregion
+//#region src/lib/logger/token-tracker.ts
+const TOKEN_PRICING = {
+	input: 3e-6,
+	output: 15e-6
+};
+function parseGitHubCopilotUsage(usageData) {
+	const inputTokens = usageData.prompt_tokens || 0;
+	const outputTokens = usageData.completion_tokens || 0;
+	const totalTokens = usageData.total_tokens || inputTokens + outputTokens;
+	const estimatedCost = inputTokens * TOKEN_PRICING.input + outputTokens * TOKEN_PRICING.output;
+	return {
+		inputTokens,
+		outputTokens,
+		totalTokens,
+		estimatedCost,
+		cachedTokens: usageData.prompt_tokens_details?.cached_tokens,
+		acceptedPredictionTokens: usageData.completion_tokens_details?.accepted_prediction_tokens,
+		rejectedPredictionTokens: usageData.completion_tokens_details?.rejected_prediction_tokens
+	};
+}
+
 //#endregion
 //#region src/lib/rate-limit.ts
 async function checkRateLimit(state$1) {
@@ -789,35 +1014,6 @@ async function checkRateLimit(state$1) {
 	consola.info("Rate limit wait completed, proceeding with request");
 }
 
-//#endregion
-//#region src/lib/tokenizer.ts
-const getTokenCount = (messages) => {
-	const simplifiedMessages = messages.map((message) => {
-		let content = "";
-		if (typeof message.content === "string") content = message.content;
-		else if (Array.isArray(message.content)) content = message.content.filter((part) => part.type === "text").map((part) => part.text).join("");
-		return {
-			...message,
-			content
-		};
-	});
-	let inputMessages = simplifiedMessages.filter((message) => {
-		return message.role !== "tool";
-	});
-	let outputMessages = [];
-	const lastMessage = simplifiedMessages.at(-1);
-	if (lastMessage?.role === "assistant") {
-		inputMessages = simplifiedMessages.slice(0, -1);
-		outputMessages = [lastMessage];
-	}
-	const inputTokens = countTokens(inputMessages);
-	const outputTokens = countTokens(outputMessages);
-	return {
-		input: inputTokens,
-		output: outputTokens
-	};
-};
-
 //#endregion
 //#region src/lib/sanitize.ts
 /**
@@ -828,14 +1024,28 @@ const getTokenCount = (messages) => {
 * Removes ANSI escape sequences and problematic Unicode characters from a string
 */
 function sanitizeString(str) {
-	return str.replaceAll(/\x1b\[[0-9;]*[a-z]/gi, "").replaceAll(/\x1b\[[0-9;]*m/g, "").replaceAll(/\x1b\[[\d;]*[HfA-DsuJKmhlp]/g, "").replaceAll(/[\x00-\x08\v\f\x0E-\x1F\x7F]/g, "").replaceAll(/[\u200B-\u200D\uFEFF]/g, "").replaceAll(/[\u2060-\u2064]/g, "").replaceAll(/[\u206A-\u206F]/g, "").replaceAll(/[\u180E\u2000-\u200A\u2028\u2029\u202F\u205F\u3000]/g, "").replaceAll(/[\uFFF0-\uFFFF]/g, "");
+	let result = str;
+	const escChar = String.fromCodePoint(27);
+	const parts = result.split(escChar);
+	if (parts.length > 1) {
+		result = parts[0];
+		for (let i = 1; i < parts.length; i++) {
+			const part = parts[i];
+			const match = part.match(/^\[[0-9;]*[a-z]/i);
+			result += match ? part.slice(match[0].length) : escChar + part;
+		}
+	}
+	return result.replaceAll(/[\u200B-\u200D\uFEFF]/g, "").replaceAll(/[\u2060-\u2064]/g, "").replaceAll(/[\u206A-\u206F]/g, "").replaceAll(/[\u180E\u2000-\u200A\u2028\u2029\u202F\u205F\u3000]/g, "").replaceAll(/[\uFFF0-\uFFFF]/g, "").replaceAll(/[\x00-\x08\v\f\x0E-\x1F]/g, "");
 }
 /**
 * Recursively sanitizes all string values in an object or array
 */
 function sanitizePayload(payload) {
 	if (typeof payload === "string") return sanitizeString(payload);
-	if (Array.isArray(payload)) return payload.map((item) => sanitizePayload(item));
+	if (Array.isArray(payload)) {
+		const sanitizedArray = payload.map((item) => sanitizePayload(item));
+		return sanitizedArray;
+	}
 	if (payload && typeof payload === "object") {
 		const sanitized = {};
 		for (const [key, value] of Object.entries(payload)) sanitized[key] = sanitizePayload(value);
@@ -867,17 +1077,13 @@ const createChatCompletions = async (payload) => {
 			body: JSON.stringify(sanitizedPayload),
 			signal: controller.signal,
 			headersTimeout: timeoutMs,
-			bodyTimeout: timeoutMs * 3,
-			connectTimeout: timeoutMs
+			bodyTimeout: timeoutMs * 3
 		});
 		const response = new Response(body, {
 			status: statusCode,
 			headers: responseHeaders
 		});
-		if (!response.ok) {
-			consola.error("Failed to create chat completions", response);
-			throw new HTTPError("Failed to create chat completions", response);
-		}
+		if (!response.ok) throw new HTTPError("Failed to create chat completions", response);
 		if (sanitizedPayload.stream) return events(response);
 		return await response.json();
 	} finally {
@@ -891,7 +1097,7 @@ async function handleCompletion$1(c) {
 	await checkRateLimit(state);
 	let payload = await c.req.json();
 	consola.debug("Request payload:", JSON.stringify(payload).slice(-400));
-	consola.info("Current token count:", getTokenCount(payload.messages));
+	c.set("requestData", { model: payload.model });
 	if (state.manualApprove) await awaitApproval();
 	if (isNullish(payload.max_tokens)) {
 		const selectedModel = state.models?.data.find((model) => model.id === payload.model);
@@ -901,17 +1107,42 @@ async function handleCompletion$1(c) {
 		};
 		consola.debug("Set max_tokens to:", JSON.stringify(payload.max_tokens));
 	}
+	const copilotStart = performance.now();
 	const response = await createChatCompletions(payload);
+	const copilotDuration = performance.now() - copilotStart;
 	if (isNonStreaming$1(response)) {
+		const requestData = c.get("requestData") || {};
+		if (response.usage) requestData.tokenUsage = parseGitHubCopilotUsage(response.usage);
+		requestData.copilotDuration = copilotDuration;
+		c.set("requestData", requestData);
 		consola.debug("Non-streaming response:", JSON.stringify(response));
 		return c.json(response);
 	}
-	consola.debug("Streaming response");
 	return streamSSE(c, async (stream) => {
+		let finalUsage = null;
 		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.usage) {
+					finalUsage = parsed.usage;
+					const requestData = c.get("requestData") || {};
+					requestData.tokenUsage = parseGitHubCopilotUsage(finalUsage);
+					requestData.copilotDuration = copilotDuration;
+					c.set("requestData", requestData);
+				}
+			} catch {}
 			await stream.writeSSE(chunk);
 		}
+		if (finalUsage) {
+			const requestData = c.get("requestData") || {};
+			if (!requestData.tokenUsage) {
+				requestData.tokenUsage = parseGitHubCopilotUsage(finalUsage);
+				requestData.copilotDuration = copilotDuration;
+				c.set("requestData", requestData);
+			}
+		}
+		const requestId = c.get("requestId");
+		if (requestId) CompletionLogger.executeCompletion(requestId);
 	});
 }
 const isNonStreaming$1 = (response) => Object.hasOwn(response, "choices");
@@ -955,8 +1186,15 @@ const createEmbeddings = async (payload) => {
 const embeddingRoutes = new Hono();
 embeddingRoutes.post("/", async (c) => {
 	try {
-		const paylod = await c.req.json();
-		const response = await createEmbeddings(paylod);
+		const payload = await c.req.json();
+		c.set("requestData", { model: payload.model });
+		const copilotStart = performance.now();
+		const response = await createEmbeddings(payload);
+		const copilotDuration = performance.now() - copilotStart;
+		const requestData = c.get("requestData") || {};
+		requestData.tokenUsage = parseGitHubCopilotUsage(response.usage);
+		requestData.copilotDuration = copilotDuration;
+		c.set("requestData", requestData);
 		return c.json(response);
 	} catch (error) {
 		return await forwardError(c, error);
@@ -1293,9 +1531,16 @@ async function handleCompletion(c) {
 	consola.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
 	const openAIPayload = translateToOpenAI(anthropicPayload);
 	consola.debug("Translated OpenAI request payload:", JSON.stringify(openAIPayload));
+	c.set("requestData", { model: openAIPayload.model });
+	const copilotStart = performance.now();
 	if (state.manualApprove) await awaitApproval();
 	const response = await createChatCompletions(openAIPayload);
+	const copilotDuration = performance.now() - copilotStart;
 	if (isNonStreaming(response)) {
+		const requestData = c.get("requestData") || {};
+		if (response.usage) requestData.tokenUsage = parseGitHubCopilotUsage(response.usage);
+		requestData.copilotDuration = copilotDuration;
+		c.set("requestData", requestData);
 		consola.debug("Non-streaming response from Copilot:", JSON.stringify(response).slice(-400));
 		const anthropicResponse = translateToAnthropic(response);
 		consola.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
@@ -1303,6 +1548,7 @@ async function handleCompletion(c) {
 	}
 	consola.debug("Streaming response from Copilot");
 	return streamSSE(c, async (stream) => {
+		let finalUsage = null;
 		const streamState = {
 			messageStartSent: false,
 			contentBlockIndex: 0,
@@ -1314,6 +1560,13 @@ async function handleCompletion(c) {
 			if (rawEvent.data === "[DONE]") break;
 			if (!rawEvent.data) continue;
 			const chunk = JSON.parse(rawEvent.data);
+			if (chunk.usage) {
+				finalUsage = chunk.usage;
+				const requestData = c.get("requestData") || {};
+				requestData.tokenUsage = parseGitHubCopilotUsage(finalUsage);
+				requestData.copilotDuration = copilotDuration;
+				c.set("requestData", requestData);
+			}
 			const events$1 = translateChunkToAnthropicEvents(chunk, streamState);
 			for (const event of events$1) {
 				consola.debug("Translated Anthropic event:", JSON.stringify(event));
@@ -1323,6 +1576,16 @@ async function handleCompletion(c) {
 				});
 			}
 		}
+		if (finalUsage) {
+			const requestData = c.get("requestData") || {};
+			if (!requestData.tokenUsage) {
+				requestData.tokenUsage = parseGitHubCopilotUsage(finalUsage);
+				requestData.copilotDuration = copilotDuration;
+				c.set("requestData", requestData);
+			}
+		}
+		const requestId = c.get("requestId");
+		if (requestId) CompletionLogger.executeCompletion(requestId);
 	});
 }
 const isNonStreaming = (response) => Object.hasOwn(response, "choices");
@@ -1394,7 +1657,7 @@ usageRoute.get("/", async (c) => {
 //#endregion
 //#region src/server.ts
 const server = new Hono();
-server.use(logger());
+server.use(enhancedLogger());
 server.use(cors());
 server.get("/", (c) => c.text("Server running"));
 server.route("/chat/completions", completionRoutes);
@@ -1433,6 +1696,54 @@ function setupGracefulShutdown() {
 		cleanup().finally(() => process$1.exit(1));
 	});
 }
+async function setupClaudeCodeConfiguration(options, serverUrl) {
+	if (!options.claudeCode) return;
+	invariant(state.models, "Models should be loaded by now");
+	let selectedModel;
+	let selectedSmallModel;
+	if (options.model && options.smallModel) {
+		const availableModelIds = state.models.data.map((model) => model.id);
+		if (!availableModelIds.includes(options.model)) {
+			consola.error(`Invalid model: ${options.model}`);
+			consola.info(`Available models: \n${availableModelIds.join("\n")}`);
+			process$1.exit(1);
+		}
+		if (!availableModelIds.includes(options.smallModel)) {
+			consola.error(`Invalid small model: ${options.smallModel}`);
+			consola.info(`Available models: \n${availableModelIds.join("\n")}`);
+			process$1.exit(1);
+		}
+		selectedModel = options.model;
+		selectedSmallModel = options.smallModel;
+		consola.info(`Using model: ${selectedModel}`);
+		consola.info(`Using small model: ${selectedSmallModel}`);
+	} else if (options.model || options.smallModel) {
+		consola.error("Both --model and --small-model must be specified when using command-line model selection");
+		process$1.exit(1);
+	} else {
+		selectedModel = await consola.prompt("Select a model to use with Claude Code", {
+			type: "select",
+			options: state.models.data.map((model) => model.id)
+		});
+		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_SMALL_FAST_MODEL: selectedSmallModel
+	}, "claude");
+	try {
+		clipboard.writeSync(command);
+		consola.success("Copied Claude Code command to clipboard!");
+	} catch {
+		consola.warn("Failed to copy to clipboard. Here is the Claude Code command:");
+		consola.log(command);
+	}
+}
 async function runServer(options) {
 	setupGracefulShutdown();
 	cleanupFunctions.push(() => {
@@ -1455,7 +1766,8 @@ async function runServer(options) {
 	state.timeoutMs = options.timeout;
 	state.connectivity.enabled = !options.disableConnectivityMonitoring;
 	await ensurePaths();
-	await cacheVSCodeVersion();
+	cacheVSCodeVersion();
+	await initializeVSCodeIdentifiers(state);
 	if (options.githubToken) {
 		state.githubToken = options.githubToken;
 		consola.info("Using provided GitHub token");
@@ -1464,53 +1776,7 @@ async function runServer(options) {
 	await cacheModels();
 	consola.info(`Available models: \n${state.models?.data.map((model) => `- ${model.id}`).join("\n")}`);
 	const serverUrl = `http://localhost:${options.port}`;
-	if (options.claudeCode) {
-		invariant(state.models, "Models should be loaded by now");
-		let selectedModel;
-		let selectedSmallModel;
-		if (options.model && options.smallModel) {
-			const availableModelIds = state.models.data.map((model) => model.id);
-			if (!availableModelIds.includes(options.model)) {
-				consola.error(`Invalid model: ${options.model}`);
-				consola.info(`Available models: \n${availableModelIds.join("\n")}`);
-				process$1.exit(1);
-			}
-			if (!availableModelIds.includes(options.smallModel)) {
-				consola.error(`Invalid small model: ${options.smallModel}`);
-				consola.info(`Available models: \n${availableModelIds.join("\n")}`);
-				process$1.exit(1);
-			}
-			selectedModel = options.model;
-			selectedSmallModel = options.smallModel;
-			consola.info(`Using model: ${selectedModel}`);
-			consola.info(`Using small model: ${selectedSmallModel}`);
-		} else if (options.model || options.smallModel) {
-			consola.error("Both --model and --small-model must be specified when using command-line model selection");
-			process$1.exit(1);
-		} else {
-			selectedModel = await consola.prompt("Select a model to use with Claude Code", {
-				type: "select",
-				options: state.models.data.map((model) => model.id)
-			});
-			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_SMALL_FAST_MODEL: selectedSmallModel
-		}, "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);
-		}
-	}
+	await setupClaudeCodeConfiguration(options, serverUrl);
 	consola.box(`🌐 Usage Viewer: https://ericc-ch.github.io/copilot-api?endpoint=${serverUrl}/usage`);
 	serve({
 		fetch: server.fetch,