@dianshuv/copilot-api 0.14.0 → 0.15.1

package/README.md

@@ -1,7 +1,7 @@
 # Copilot API Proxy (Fork)
 
 > [!NOTE]
-> This is a fork of [@hsupu/copilot-api](https://www.npmjs.com/package/@hsupu/copilot-api), which itself is a fork of [ericc-ch/copilot-api](https://github.com/ericc-ch/copilot-api), with additional improvements and bug fixes.
+> This is a fork of [@hsupu/copilot-api](https://www.npmjs.com/package/@hsupu/copilot-api), which itself is a fork of `ericc-ch/copilot-api`, with additional improvements and bug fixes.
 
 > [!WARNING]
 > This is a reverse-engineered proxy of GitHub Copilot API. It is not supported by GitHub, and may break unexpectedly. Use at your own risk.
@@ -275,6 +275,3 @@ Create `.claude/settings.json` in your project:
 }
 ```
 
-## Upstream Project
-
-For the original project documentation, features, and updates, see: [ericc-ch/copilot-api](https://github.com/ericc-ch/copilot-api)

package/dist/main.mjs

@@ -1086,7 +1086,7 @@ const logout = defineCommand({
 
 //#endregion
 //#region package.json
-var version = "0.14.0";
+var version = "0.15.1";
 
 //#endregion
 //#region src/lib/event-loop-lag.ts
@@ -3215,6 +3215,43 @@ 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/client-abort.ts
+/**
+* Build a per-request AbortController that fires when the downstream client
+* goes away, for forwarding into the upstream Copilot `fetch`.
+*
+* Why a controller instead of passing `c.req.raw.signal` straight through:
+* the client-disconnect signal is delivered differently per runtime. Verified
+* on the runtime the published package runs under (Node/srvx): BOTH
+* `c.req.raw.signal` and Hono's `stream.onAbort` fire on disconnect. Rather
+* than trust a single source (a wrong bet here silently leaks), callers wire
+* `c.req.raw.signal` (here) AND `stream.onAbort` (in the streaming branch) into
+* the one controller, then pass `controller.signal` to the upstream fetch.
+*
+* Without this, an abandoned request keeps draining the upstream response to
+* completion — holding one of the account's scarce concurrent-request slots
+* until the proxy process dies (which is why restarting the proxy "fixes" a
+* pile-up of slow requests).
+*/
+function clientAbortController(c) {
+	const controller = new AbortController();
+	const clientSignal = c.req.raw.signal;
+	if (clientSignal.aborted) controller.abort();
+	else clientSignal.addEventListener("abort", () => controller.abort(), { once: true });
+	return controller;
+}
+/**
+* True when an error originates from an AbortSignal firing (client disconnect)
+* rather than a genuine upstream failure, so callers can treat a cancelled
+* request as a clean stop instead of recording a spurious error. Matches both
+* `Error` and `DOMException` (undici's fetch rejects with the latter, which is
+* not always an `instanceof Error`), keying only on the `name`.
+*/
+function isAbortError(error) {
+	return typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
+}
+
 //#endregion
 //#region src/lib/message-sanitizer.ts
 const startPattern = /^\s*<system-reminder>[\s\S]*?<\/system-reminder>\n*/;
@@ -3911,7 +3948,8 @@ const createChatCompletions = async (payload, options) => {
 	const response = await copilotFetch("/chat/completions", {
 		method: "POST",
 		headers,
-		body: JSON.stringify(wire)
+		body: JSON.stringify(wire),
+		signal: options?.signal
 	});
 	if (!response.ok) {
 		consola.error("Failed to create chat completions", response);
@@ -4346,13 +4384,18 @@ async function handleCompletion$1(c) {
 */
 async function executeRequest(opts) {
 	const { c, payload, selectedModel, ctx } = opts;
+	const abort = clientAbortController(c);
 	try {
-		const { result: response, queueWaitMs } = await executeWithAdaptiveRateLimit(() => createChatCompletions(payload, { resolvedModel: selectedModel }));
+		const { result: response, queueWaitMs } = await executeWithAdaptiveRateLimit(() => createChatCompletions(payload, {
+			resolvedModel: selectedModel,
+			signal: abort.signal
+		}));
 		ctx.queueWaitMs = queueWaitMs;
 		if (isNonStreaming(response)) return handleNonStreamingResponse$1(c, response, ctx, payload);
 		consola.debug("Streaming response");
 		updateTrackerStatus(ctx.trackingId, "streaming");
 		return streamSSE(c, async (stream) => {
+			stream.onAbort(() => abort.abort());
 			await handleStreamingResponse$1({
 				stream,
 				response,
@@ -4361,6 +4404,11 @@ async function executeRequest(opts) {
 			});
 		});
 	} catch (error) {
+		if (isAbortError(error)) {
+			consola.debug("[ChatCompletions] client disconnected before response; upstream aborted");
+			failTracking(ctx.trackingId, "client disconnected");
+			return new Response(null, { status: 499 });
+		}
 		if (error instanceof HTTPError && error.status === 413) await logPayloadSizeInfo(payload, selectedModel);
 		recordErrorResponse(ctx, payload.model, error, "chat_completions", payload.stream ?? false);
 		throw error;
@@ -4499,6 +4547,11 @@ async function handleStreamingResponse$1(opts) {
 			toolCount: payload.tools?.length ?? 0
 		}, ctx.timings);
 	} catch (error) {
+		if (isAbortError(error)) {
+			consola.debug("[ChatCompletions] client disconnected mid-stream; upstream aborted");
+			failTracking(ctx.trackingId, "client disconnected");
+			return;
+		}
 		recordStreamError({
 			acc,
 			fallbackModel: payload.model,
@@ -6837,7 +6890,8 @@ async function createAnthropicMessages(payload, options) {
 	const response = await copilotFetch("/v1/messages", {
 		method: "POST",
 		headers,
-		body: JSON.stringify(filteredPayload)
+		body: JSON.stringify(filteredPayload),
+		signal: options?.signal
 	});
 	if (!response.ok) {
 		consola.debug("Request failed:", {
@@ -6944,6 +6998,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. */
@@ -8227,13 +8349,15 @@ async function handleDirectAnthropicCompletion(c, anthropicPayload, ctx, initiat
 	} else if (state.autoTruncate && !selectedModel) consola.debug(`[Anthropic] Model '${anthropicPayload.model}' not found, skipping auto-truncate`);
 	if (state.manualApprove) await awaitApproval();
 	const clientAnthropicBetaHeader = c.req.header("anthropic-beta");
+	const abort = clientAbortController(c);
 	const isStreaming = anthropicPayload.stream === true;
 	try {
 		const settled = settle(executeWithAdaptiveRateLimit(() => createAnthropicMessages(effectivePayload, {
 			initiator: initiatorOverride,
 			injectContext1mBeta: needsContext1mBeta,
 			errorModelIdOverride: needsContext1mBeta ? originalModelId : void 0,
-			clientAnthropicBetaHeader
+			clientAnthropicBetaHeader,
+			signal: abort.signal
 		})));
 		const raced = isStreaming ? await raceWithGrace(settled, RATE_LIMIT_GRACE_MS) : await settled;
 		if (raced.kind === "error") throw raced.error;
@@ -8244,6 +8368,7 @@ async function handleDirectAnthropicCompletion(c, anthropicPayload, ctx, initiat
 				consola.debug("Streaming response from Copilot (direct Anthropic)");
 				updateTrackerStatus(ctx.trackingId, "streaming");
 				return streamSSE(c, async (stream) => {
+					stream.onAbort(() => abort.abort());
 					await handleDirectAnthropicStreamingResponse({
 						stream,
 						response,
@@ -8257,6 +8382,7 @@ async function handleDirectAnthropicCompletion(c, anthropicPayload, ctx, initiat
 		consola.debug("[RateLimiter] Request queued past grace; opening keepalive stream (direct Anthropic)");
 		updateTrackerStatus(ctx.trackingId, "streaming");
 		return streamSSE(c, async (stream) => {
+			stream.onAbort(() => abort.abort());
 			await runStreamWithKeepalive({
 				stream,
 				settled,
@@ -8271,6 +8397,11 @@ async function handleDirectAnthropicCompletion(c, anthropicPayload, ctx, initiat
 					});
 				},
 				onError: async (error) => {
+					if (isAbortError(error)) {
+						consola.debug("[Anthropic] client disconnected during keepalive; upstream aborted");
+						failTracking(ctx.trackingId, "client disconnected");
+						return;
+					}
 					recordStreamError({
 						acc: createAnthropicStreamAccumulator(),
 						fallbackModel: anthropicPayload.model,
@@ -8288,6 +8419,11 @@ async function handleDirectAnthropicCompletion(c, anthropicPayload, ctx, initiat
 			});
 		});
 	} catch (error) {
+		if (isAbortError(error)) {
+			consola.debug("[Anthropic] client disconnected before response; upstream aborted");
+			failTracking(ctx.trackingId, "client disconnected");
+			return new Response(null, { status: 499 });
+		}
 		if (error instanceof HTTPError && error.status === 413) logPayloadSizeInfoAnthropic(effectivePayload, selectedModel);
 		recordErrorResponse(ctx, anthropicPayload.model, error, "messages", anthropicPayload.stream ?? false);
 		throw error;
@@ -8442,6 +8578,11 @@ async function handleDirectAnthropicStreamingResponse(opts) {
 			toolCount: anthropicPayload.tools?.length ?? 0
 		}, ctx.timings);
 	} catch (error) {
+		if (isAbortError(error)) {
+			consola.debug("[Anthropic] client disconnected mid-stream; upstream aborted");
+			failTracking(ctx.trackingId, "client disconnected");
+			return;
+		}
 		consola.error("Direct Anthropic stream error:", formatError(error));
 		recordStreamError({
 			acc,
@@ -8531,13 +8672,15 @@ async function handleTranslatedCompletion(c, anthropicPayload, ctx, initiatorOve
 	if (autoTruncateConfig.tokenLimitCacheKeyOverride !== void 0) errorModelIdOverride = autoTruncateConfig.tokenLimitCacheKeyOverride;
 	else if (needsContext1mBeta && selectedModel) errorModelIdOverride = selectedModel.id;
 	else if (hasOneMillionSuffix) errorModelIdOverride = originalModelId;
+	const abort = clientAbortController(c);
 	const isStreaming = anthropicPayload.stream === true;
 	try {
 		const settled = settle(executeWithAdaptiveRateLimit(() => createChatCompletions(openAIPayload, {
 			initiator: initiatorOverride,
 			resolvedModel: selectedModel,
 			anthropicBeta,
-			errorModelIdOverride
+			errorModelIdOverride,
+			signal: abort.signal
 		})));
 		const raced = isStreaming ? await raceWithGrace(settled, RATE_LIMIT_GRACE_MS) : await settled;
 		if (raced.kind === "error") throw raced.error;
@@ -8554,6 +8697,7 @@ async function handleTranslatedCompletion(c, anthropicPayload, ctx, initiatorOve
 			consola.debug("Streaming response from Copilot");
 			updateTrackerStatus(ctx.trackingId, "streaming");
 			return streamSSE(c, async (stream) => {
+				stream.onAbort(() => abort.abort());
 				await handleStreamingResponse({
 					stream,
 					response,
@@ -8566,6 +8710,7 @@ async function handleTranslatedCompletion(c, anthropicPayload, ctx, initiatorOve
 		consola.debug("[RateLimiter] Request queued past grace; opening keepalive stream (translated)");
 		updateTrackerStatus(ctx.trackingId, "streaming");
 		return streamSSE(c, async (stream) => {
+			stream.onAbort(() => abort.abort());
 			await runStreamWithKeepalive({
 				stream,
 				settled,
@@ -8582,6 +8727,11 @@ async function handleTranslatedCompletion(c, anthropicPayload, ctx, initiatorOve
 					});
 				},
 				onError: async (error) => {
+					if (isAbortError(error)) {
+						consola.debug("[Translated] client disconnected during keepalive; upstream aborted");
+						failTracking(ctx.trackingId, "client disconnected");
+						return;
+					}
 					recordStreamError({
 						acc: createAnthropicStreamAccumulator(),
 						fallbackModel: anthropicPayload.model,
@@ -8599,6 +8749,11 @@ async function handleTranslatedCompletion(c, anthropicPayload, ctx, initiatorOve
 			});
 		});
 	} catch (error) {
+		if (isAbortError(error)) {
+			consola.debug("[Translated] client disconnected before response; upstream aborted");
+			failTracking(ctx.trackingId, "client disconnected");
+			return new Response(null, { status: 499 });
+		}
 		if (error instanceof HTTPError && error.status === 413) await logPayloadSizeInfo(openAIPayload, selectedModel);
 		recordErrorResponse(ctx, anthropicPayload.model, error, "messages", anthropicPayload.stream ?? false);
 		throw error;
@@ -8687,6 +8842,11 @@ async function handleStreamingResponse(opts) {
 			toolCount: anthropicPayload.tools?.length ?? 0
 		}, ctx.timings);
 	} catch (error) {
+		if (isAbortError(error)) {
+			consola.debug("[Translated] client disconnected mid-stream; upstream aborted");
+			failTracking(ctx.trackingId, "client disconnected");
+			return;
+		}
 		consola.error("Stream error:", formatError(error));
 		recordStreamError({
 			acc,
@@ -8805,7 +8965,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);
 }
 /**
@@ -8938,9 +9102,34 @@ 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 }) => {
+const createResponses = async (payload, { vision, initiator, resolvedModel, signal }) => {
 	if (!state.copilotToken) throw new Error("Copilot token not found");
 	const modelSupportsVision = resolvedModel?.capabilities?.supports?.vision !== false;
 	const headers = {
@@ -8954,7 +9143,8 @@ const createResponses = async (payload, { vision, initiator, resolvedModel }) =>
 	const response = await copilotFetch("/responses", {
 		method: "POST",
 		headers,
-		body: JSON.stringify(payload)
+		body: JSON.stringify(payload),
+		signal
 	});
 	if (!response.ok) {
 		consola.error("Failed to create responses", response);
@@ -9195,14 +9385,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) => {
@@ -9233,17 +9426,20 @@ const handleResponses = async (c) => {
 	}
 	const { vision, initiator } = getResponsesRequestOptions(payload);
 	if (state.manualApprove) await awaitApproval();
+	const abort = clientAbortController(c);
 	try {
 		const { result: response, queueWaitMs } = await executeWithAdaptiveRateLimit(() => createResponses(payload, {
 			vision,
 			initiator,
-			resolvedModel: selectedModel
+			resolvedModel: selectedModel,
+			signal: abort.signal
 		}));
 		ctx.queueWaitMs = queueWaitMs;
 		if (isStreamingRequested(payload) && isAsyncIterable(response)) {
 			consola.debug("Forwarding native Responses stream");
 			updateTrackerStatus(trackingId, "streaming");
 			return streamSSE(c, async (stream) => {
+				stream.onAbort(() => abort.abort());
 				const idTracker = createStreamIdTracker();
 				let finalResult;
 				let streamErrorMessage;
@@ -9292,6 +9488,11 @@ const handleResponses = async (c) => {
 						completeTracking(trackingId, 0, 0, queueWaitMs, void 0, void 0, ctx.timings);
 					} else completeTracking(trackingId, 0, 0, queueWaitMs, void 0, void 0, ctx.timings);
 				} catch (error) {
+					if (isAbortError(error)) {
+						consola.debug("[Responses] client disconnected mid-stream; upstream aborted");
+						failTracking(trackingId, "client disconnected");
+						return;
+					}
 					recordStreamError({
 						acc: { model: finalResult?.model || model },
 						fallbackModel: model,
@@ -9327,6 +9528,11 @@ const handleResponses = async (c) => {
 		consola.debug("Forwarding native Responses result:", JSON.stringify(result).slice(-400));
 		return c.json(echoResponseBody(result, ctx));
 	} catch (error) {
+		if (isAbortError(error)) {
+			consola.debug("[Responses] client disconnected before response; upstream aborted");
+			failTracking(trackingId, "client disconnected");
+			return new Response(null, { status: 499 });
+		}
 		recordErrorResponse(ctx, model, error, "responses", stream);
 		failTracking(trackingId, error);
 		throw error;

package/package.json

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