@dianshuv/copilot-api 0.13.1 → 0.15.0

package/README.md

@@ -16,6 +16,7 @@
 - **Stream repetition detection**: Detects when models get stuck in repetitive output loops using KMP-based pattern matching and logs a warning.
 - **Stale request reaping**: Automatically force-fails requests that exceed a configurable maximum age (default 600s) to prevent resource leaks.
 - **PostHog analytics**: Optional PostHog Cloud integration (`--posthog-key`) sends per-request token usage events for long-term trend analysis. Free tier (1M events/month) is more than sufficient for individual use.
+- **GitHub Copilot CLI emulation**: All upstream requests to GitHub — device-flow `login`, Copilot token exchange, and model calls — carry the official GitHub Copilot CLI's (`@github/copilot`) identity: its `copilot-integration-id` (`copilot-developer-cli`), `editor-version`/`user-agent` (`copilot/<version>`), `x-github-api-version`, and a persistent `x-client-machine-id` (stored at `~/.local/share/copilot-api/machine_id`). The `login` flow uses the CLI's own OAuth app, so **new** logins request the `read:user`, `read:org`, `repo`, and `gist` scopes; existing tokens keep working without re-authentication.
 
 ## Quick Start
 

package/dist/main.mjs

@@ -3,10 +3,10 @@ import { defineCommand, runMain } from "citty";
 import consola from "consola";
 import fs from "node:fs/promises";
 import os from "node:os";
+import { createHash, randomUUID, timingSafeEqual } from "node:crypto";
 import path from "node:path";
 import { getProxyForUrl } from "proxy-from-env";
 import { Agent, ProxyAgent, setGlobalDispatcher } from "undici";
-import { createHash, randomUUID, timingSafeEqual } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { serve } from "srvx";
 import { PostHog } from "posthog-node";
@@ -19,14 +19,31 @@ 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 MACHINE_ID_PATH = path.join(APP_DIR, "machine_id");
 const PATHS = {
 	APP_DIR,
-	GITHUB_TOKEN_PATH
+	GITHUB_TOKEN_PATH,
+	MACHINE_ID_PATH
 };
 async function ensurePaths() {
 	await fs.mkdir(PATHS.APP_DIR, { recursive: true });
 	await ensureFile(PATHS.GITHUB_TOKEN_PATH);
 }
+/**
+* Returns a stable-per-machine UUID for the `x-client-machine-id` header,
+* mirroring the GitHub Copilot CLI which keeps a persistent machine identifier.
+* Self-contained: reads the persisted value, generating and storing one on first
+* use. A missing, unreadable, or corrupted file self-heals by regenerating,
+* so startup can't crash and a bad value can't be sent upstream forever.
+*/
+async function getOrCreateMachineId() {
+	const existing = await fs.readFile(PATHS.MACHINE_ID_PATH, "utf8").then((content) => content.trim()).catch(() => "");
+	if (MACHINE_ID_PATTERN.test(existing)) return existing;
+	const machineId = randomUUID();
+	await fs.writeFile(PATHS.MACHINE_ID_PATH, machineId, { mode: 384 });
+	return machineId;
+}
+const MACHINE_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 async function ensureFile(filePath) {
 	const isWindows = process.platform === "win32";
 	try {
@@ -142,10 +159,12 @@ 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 CLI_VERSION_FALLBACK = "1.0.67";
+const API_VERSION = "2026-07-01";
+const COPILOT_INTEGRATION_ID = "copilot-developer-cli";
+const cliVersion = (state) => state.copilotCliVersion ?? CLI_VERSION_FALLBACK;
+const editorVersion = (state) => `copilot/${cliVersion(state)}`;
+const userAgent = (state) => `copilot/${cliVersion(state)} (${process.platform} ${process.version}) term/${process.env.TERM_PROGRAM ?? "unknown"}`;
 const copilotBaseUrl = (state) => state.accountType === "individual" ? "https://api.githubcopilot.com" : `https://api.${state.accountType}.githubcopilot.com`;
 function hasHeaderKey(headers, key) {
 	const lowerKey = key.toLowerCase();
@@ -157,15 +176,15 @@ function copilotHeaders(state, visionOrOptions) {
 	const options = typeof visionOrOptions === "boolean" ? { vision: visionOrOptions } : visionOrOptions ?? {};
 	const headers = {
 		Authorization: `Bearer ${state.copilotToken}`,
+		accept: standardHeaders().accept,
 		"content-type": standardHeaders()["content-type"],
-		"copilot-integration-id": "vscode-chat",
-		"editor-version": `vscode/${state.vsCodeVersion}`,
-		"editor-plugin-version": EDITOR_PLUGIN_VERSION,
-		"user-agent": USER_AGENT,
-		"openai-intent": options.intent ?? "conversation-panel",
+		"copilot-integration-id": COPILOT_INTEGRATION_ID,
+		"editor-version": editorVersion(state),
+		"user-agent": userAgent(state),
+		"openai-intent": options.intent ?? "conversation-agent",
 		"x-github-api-version": API_VERSION,
-		"x-request-id": randomUUID(),
-		"x-vscode-user-agent-library-version": "electron-fetch"
+		"x-interaction-id": randomUUID(),
+		"x-client-machine-id": state.machineId ?? ""
 	};
 	for (const [key, value] of Object.entries(options.modelRequestHeaders ?? {})) if (!hasHeaderKey(headers, key)) headers[key] = value;
 	if (options.vision) headers["copilot-vision-request"] = "true";
@@ -173,17 +192,22 @@ function copilotHeaders(state, visionOrOptions) {
 }
 const GITHUB_API_BASE_URL = "https://api.github.com";
 const githubHeaders = (state) => ({
+	accept: standardHeaders().accept,
+	authorization: `Bearer ${state.githubToken}`,
+	"user-agent": userAgent(state)
+});
+const githubOAuthHeaders = (state) => ({
 	...standardHeaders(),
-	authorization: `token ${state.githubToken}`,
-	"editor-version": `vscode/${state.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"
+	"user-agent": userAgent(state)
 });
 const GITHUB_BASE_URL = "https://github.com";
-const GITHUB_CLIENT_ID = "Iv1.b507a08c87ecfe98";
-const GITHUB_APP_SCOPES = ["read:user"].join(" ");
+const GITHUB_CLIENT_ID = "Ov23ctDVkRmgkPke0Mmm";
+const GITHUB_APP_SCOPES = [
+	"read:user",
+	"read:org",
+	"repo",
+	"gist"
+].join(" ");
 
 //#endregion
 //#region src/lib/auto-truncate-common.ts
@@ -454,7 +478,7 @@ const getCopilotToken = async () => {
 async function getDeviceCode() {
 	const response = await fetch(`${GITHUB_BASE_URL}/login/device/code`, {
 		method: "POST",
-		headers: standardHeaders(),
+		headers: githubOAuthHeaders(state),
 		body: JSON.stringify({
 			client_id: GITHUB_CLIENT_ID,
 			scope: GITHUB_APP_SCOPES
@@ -467,10 +491,7 @@ async function getDeviceCode() {
 //#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()
-	} });
+	const response = await fetch(`${GITHUB_API_BASE_URL}/user`, { headers: githubHeaders(state) });
 	if (!response.ok) throw await HTTPError.fromResponse("Failed to get GitHub user", response);
 	return await response.json();
 }
@@ -655,28 +676,33 @@ const getModels = async () => {
 };
 
 //#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() {
+//#region src/services/get-copilot-cli-version.ts
+const NPM_REGISTRY_URL = "https://registry.npmjs.org/@github/copilot/latest";
+/**
+* Fetches the latest published version of the GitHub Copilot CLI (@github/copilot)
+* from the npm registry, so the impersonated `editor-version` / `user-agent`
+* headers track a current CLI release. Falls back to a pinned version on any
+* failure (offline, timeout, malformed response).
+*/
+async function getCopilotCliVersion() {
 	const controller = new AbortController();
 	const timeout = setTimeout(() => {
 		controller.abort();
 	}, 5e3);
 	try {
-		const response = await fetch(GITHUB_API_URL, {
+		const response = await fetch(NPM_REGISTRY_URL, {
 			signal: controller.signal,
 			headers: {
-				Accept: "application/vnd.github.v3+json",
+				Accept: "application/json",
 				"User-Agent": "copilot-api"
 			}
 		});
-		if (!response.ok) return FALLBACK;
-		const version = (await response.json()).tag_name;
+		if (!response.ok) return CLI_VERSION_FALLBACK;
+		const version = (await response.json()).version;
 		if (version && /^\d+\.\d+\.\d+$/.test(version)) return version;
-		return FALLBACK;
+		return CLI_VERSION_FALLBACK;
 	} catch {
-		return FALLBACK;
+		return CLI_VERSION_FALLBACK;
 	} finally {
 		clearTimeout(timeout);
 	}
@@ -694,10 +720,21 @@ function findModelById(modelId) {
 async function cacheModels() {
 	state.models = await getModels();
 }
-const cacheVSCodeVersion = async () => {
-	const response = await getVSCodeVersion();
-	state.vsCodeVersion = response;
-	consola.info(`Using VSCode version: ${response}`);
+const cacheCopilotCliVersion = async () => {
+	const response = await getCopilotCliVersion();
+	state.copilotCliVersion = response;
+	consola.info(`Using Copilot CLI version: ${response}`);
+};
+/**
+* Initializes the GitHub Copilot CLI emulation identity — the persistent
+* machine id and the live CLI version that feed the impersonated headers.
+* Shared by every entrypoint that talks to GitHub (server, login, debug) so no
+* entrypoint can forget a piece of the identity and send a degraded fingerprint.
+* Must run after ensurePaths() and before any request-building call.
+*/
+const initCopilotIdentity = async () => {
+	state.machineId = await getOrCreateMachineId();
+	await cacheCopilotCliVersion();
 };
 
 //#endregion
@@ -709,7 +746,7 @@ async function pollAccessToken(deviceCode) {
 	while (Date.now() < expiresAt) {
 		const response = await fetch(`${GITHUB_BASE_URL}/login/oauth/access_token`, {
 			method: "POST",
-			headers: standardHeaders(),
+			headers: githubOAuthHeaders(state),
 			body: JSON.stringify({
 				client_id: GITHUB_CLIENT_ID,
 				device_code: deviceCode.device_code,
@@ -960,6 +997,7 @@ const debugModels = defineCommand({
 		state.accountType = args["account-type"];
 		initProxyFromEnv();
 		await ensurePaths();
+		await initCopilotIdentity();
 		if (args["github-token"]) {
 			state.githubToken = args["github-token"];
 			consola.info("Using provided GitHub token");
@@ -992,6 +1030,7 @@ async function runLogin(options) {
 	state.showToken = options.showToken;
 	initProxyFromEnv();
 	await ensurePaths();
+	await initCopilotIdentity();
 	await setupGitHubToken({ force: true });
 	consola.success("GitHub token written to", PATHS.GITHUB_TOKEN_PATH);
 }
@@ -1047,7 +1086,7 @@ const logout = defineCommand({
 
 //#endregion
 //#region package.json
-var version = "0.13.1";
+var version = "0.15.0";
 
 //#endregion
 //#region src/lib/event-loop-lag.ts
@@ -3860,8 +3899,7 @@ const createChatCompletions = async (payload, options) => {
 	const headers = {
 		...copilotHeaders(state, {
 			vision: enableVision && modelSupportsVision,
-			modelRequestHeaders: options?.resolvedModel?.request_headers,
-			intent: isAgentCall ? "conversation-agent" : "conversation-panel"
+			modelRequestHeaders: options?.resolvedModel?.request_headers
 		}),
 		"X-Initiator": options?.initiator ?? (isAgentCall ? "agent" : "user")
 	};
@@ -6777,7 +6815,6 @@ async function createAnthropicMessages(payload, options) {
 	const headers = {
 		...copilotHeaders(state, {
 			vision: enableVision,
-			intent: isAgentCall ? "conversation-agent" : "conversation-panel",
 			modelRequestHeaders: resolvedModel?.request_headers
 		}),
 		"X-Initiator": options?.initiator ?? (isAgentCall ? "agent" : "user"),
@@ -6907,6 +6944,74 @@ function supportsDirectAnthropicApi(modelId) {
 	return resolveAnthropicModelForDirectPath(modelId) !== void 0;
 }
 
+//#endregion
+//#region src/routes/messages/cache-control-injector.ts
+function blockHasCacheControl(block) {
+	if (typeof block !== "object" || block === null) return false;
+	if (!("cache_control" in block)) return false;
+	const cc = block.cache_control;
+	return cc !== void 0 && cc !== null;
+}
+function toolsHaveCacheControl(tools) {
+	if (!Array.isArray(tools)) return false;
+	return tools.some((t) => blockHasCacheControl(t));
+}
+function toolResultInnerHasCacheControl(block) {
+	if (!Array.isArray(block.content)) return false;
+	return block.content.some((inner) => blockHasCacheControl(inner));
+}
+function messagesHaveCacheControl(messages) {
+	if (!Array.isArray(messages)) return false;
+	for (const message of messages) {
+		if (!Array.isArray(message.content)) continue;
+		for (const block of message.content) {
+			if (blockHasCacheControl(block)) return true;
+			if (block.type === "tool_result" && toolResultInnerHasCacheControl(block)) return true;
+		}
+	}
+	return false;
+}
+function systemHasCacheControl(system) {
+	if (!Array.isArray(system)) return false;
+	return system.some((b) => blockHasCacheControl(b));
+}
+function hasAnyCacheControl(payload) {
+	return systemHasCacheControl(payload.system) || toolsHaveCacheControl(payload.tools) || messagesHaveCacheControl(payload.messages);
+}
+function injectSystemCacheControl(payload) {
+	if (hasAnyCacheControl(payload)) return;
+	if (payload.system === void 0 || payload.system === null) return;
+	if (typeof payload.system === "string") {
+		if (payload.system.length === 0) return;
+		payload.system = [{
+			type: "text",
+			text: payload.system,
+			cache_control: { type: "ephemeral" }
+		}];
+		return;
+	}
+	if (payload.system.length === 0) return;
+	const tail = payload.system.at(-1);
+	if (!tail) return;
+	tail.cache_control = { type: "ephemeral" };
+}
+
+//#endregion
+//#region src/routes/messages/date-normalizer.ts
+const dateTrackingRegex = /(# currentDate\r?\n)Today['’ʼʹ]s date is (\d{4})[/-](\d{2})[/-](\d{2})\.(\r?\n|$)/g;
+function normalizeClaudeCodeDate(text) {
+	return text.replaceAll(dateTrackingRegex, "$1Today's date is $2-$3-$4.$5");
+}
+function normalizeSystemPromptDate(payload) {
+	if (typeof payload.system === "string") {
+		payload.system = normalizeClaudeCodeDate(payload.system);
+		return;
+	}
+	if (Array.isArray(payload.system)) {
+		for (const block of payload.system) if (typeof block.text === "string") block.text = normalizeClaudeCodeDate(block.text);
+	}
+}
+
 //#endregion
 //#region src/lib/stream-keepalive.ts
 /** SSE comment line used as a keepalive heartbeat. */
@@ -8768,7 +8873,11 @@ async function handleCompletion(c) {
 	const subagentMarker = parseSubagentMarkerFromFirstUser(sanitizedPayload);
 	const initiatorOverride = subagentMarker ? "agent" : void 0;
 	if (subagentMarker) consola.debug("Detected Subagent marker:", JSON.stringify(subagentMarker));
-	if (supportsDirectAnthropicApi(sanitizedPayload.model)) return handleDirectAnthropicCompletion(c, sanitizedPayload, ctx, initiatorOverride);
+	if (supportsDirectAnthropicApi(sanitizedPayload.model)) {
+		normalizeSystemPromptDate(sanitizedPayload);
+		injectSystemCacheControl(sanitizedPayload);
+		return handleDirectAnthropicCompletion(c, sanitizedPayload, ctx, initiatorOverride);
+	}
 	return handleTranslatedCompletion(c, sanitizedPayload, ctx, initiatorOverride);
 }
 /**
@@ -8901,6 +9010,31 @@ modelRoutes.get("/", async (c) => {
 	}
 });
 
+//#endregion
+//#region src/lib/prompt-cache-key.ts
+const CLIENT_NAME_PATTERNS = [
+	[/^claude[-_]?(?:code|cli)$/i, "claude-code"],
+	[/^codex$/i, "codex"],
+	[/^cursor$/i, "cursor"],
+	[/^aider$/i, "aider"],
+	[/^copilot$/i, "copilot"]
+];
+const UA_MAIN_TOKEN = /^([\w.-]+)/;
+function extractClientName(userAgent) {
+	if (!userAgent) return "unknown";
+	const mainToken = UA_MAIN_TOKEN.exec(userAgent)?.[1]?.toLowerCase();
+	if (!mainToken) return "unknown";
+	for (const [pattern, name] of CLIENT_NAME_PATTERNS) if (pattern.test(mainToken)) return name;
+	return mainToken.slice(0, 32);
+}
+function buildPromptCacheKey(clientName) {
+	return `copilot-api:${clientName}`;
+}
+function injectPromptCacheKey(payload, clientName) {
+	if (payload.prompt_cache_key !== void 0 && payload.prompt_cache_key !== null && payload.prompt_cache_key !== "") return;
+	payload.prompt_cache_key = buildPromptCacheKey(clientName);
+}
+
 //#endregion
 //#region src/services/copilot/create-responses.ts
 const createResponses = async (payload, { vision, initiator, resolvedModel }) => {
@@ -9158,14 +9292,17 @@ const TERMINAL_EVENTS = new Set([
 	"error"
 ]);
 const handleResponses = async (c) => {
+	const rawPayload = await c.req.json();
+	const clientName = extractClientName(c.req.header("user-agent"));
 	const { ctx, payload } = createEntryContext({
 		c,
-		rawPayload: await c.req.json(),
+		rawPayload,
 		endpoint: "openai",
 		normalizePayload: (p) => {
 			const np = state.normalizeResponsesCallIds ? normalizeCallIds(p) : p;
 			useFunctionApplyPatch(np);
 			filterUnsupportedBuiltins(np);
+			injectPromptCacheKey(np, clientName);
 			return np;
 		},
 		buildHistoryRequest: (p) => {
@@ -9467,7 +9604,7 @@ async function runServer(options) {
 	initTui({ enabled: true });
 	initRequestContextManager(state.staleRequestMaxAge).startReaper();
 	await ensurePaths();
-	await cacheVSCodeVersion();
+	await initCopilotIdentity();
 	if (options.githubToken) {
 		state.githubToken = options.githubToken;
 		consola.info("Using provided GitHub token");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dianshuv/copilot-api",
-  "version": "0.13.1",
+  "version": "0.15.0",
   "description": "Turn GitHub Copilot into OpenAI/Anthropic API compatible server. Usable with Claude Code!",
   "author": "dianshuv",
   "type": "module",