@dianshuv/copilot-api 0.7.9 → 0.7.10

package/dist/main.mjs

@@ -478,10 +478,128 @@ async function getGitHubUser() {
 	return await response.json();
 }
 
+//#endregion
+//#region src/lib/fetch-retry.ts
+const RETRYABLE_CAUSE_CODES = new Set([
+	"UND_ERR_SOCKET",
+	"ECONNRESET",
+	"ENOTFOUND",
+	"UND_ERR_CONNECT_TIMEOUT"
+]);
+const RETRY_DELAYS_MS = [200, 600];
+function getCauseCode(error) {
+	if (!(error instanceof Error)) return void 0;
+	const cause = error.cause;
+	if (typeof cause !== "object" || cause === null) return void 0;
+	const code = cause.code;
+	return typeof code === "string" ? code : void 0;
+}
+function isRetryable(error) {
+	const code = getCauseCode(error);
+	return code !== void 0 && RETRYABLE_CAUSE_CODES.has(code);
+}
+const RETRY_ATTEMPTS_KEY = "__copilotRetryAttempts";
+const RETRY_AUTH_REFRESHED_KEY = "__copilotRetryAuthRefreshed";
+/**
+* Read retry metadata recorded on an error or response by fetchWithRetry.
+* Returns attempts=1 (no retry) if the value is missing or malformed.
+*/
+function getRetryAttempts(target) {
+	if (typeof target !== "object" || target === null) return {
+		attempts: 1,
+		authRefreshed: false
+	};
+	const meta = target;
+	return {
+		attempts: typeof meta[RETRY_ATTEMPTS_KEY] === "number" ? meta[RETRY_ATTEMPTS_KEY] : 1,
+		authRefreshed: meta[RETRY_AUTH_REFRESHED_KEY] === true
+	};
+}
+async function fetchWithRetry(input, init, options) {
+	let currentInit = init;
+	let authRefreshed = false;
+	let networkAttempts = 0;
+	for (let attempt = 0; attempt <= RETRY_DELAYS_MS.length; attempt++) try {
+		networkAttempts++;
+		const response = await fetch(input, currentInit);
+		if (response.status === 401 && !authRefreshed && options?.onUnauthorized) {
+			const refreshed = await tryRefreshAuth(options.onUnauthorized);
+			if (refreshed) {
+				await response.body?.cancel().catch(() => {});
+				consola.warn("Got 401 from upstream; refreshed token and retrying");
+				currentInit = refreshed;
+				authRefreshed = true;
+				attempt--;
+				continue;
+			}
+		}
+		annotateRetryMeta(response, networkAttempts, authRefreshed);
+		return response;
+	} catch (error) {
+		if (attempt === RETRY_DELAYS_MS.length || !isRetryable(error)) {
+			annotateRetryMeta(error, networkAttempts, authRefreshed);
+			throw error;
+		}
+		const delay = RETRY_DELAYS_MS[attempt];
+		consola.warn(`Upstream network error (${getCauseCode(error)}); retry ${attempt + 1}/${RETRY_DELAYS_MS.length} in ${delay}ms`);
+		await new Promise((resolve) => setTimeout(resolve, delay));
+	}
+	throw new Error("fetchWithRetry exhausted attempts without resolution");
+}
+function annotateRetryMeta(target, attempts, authRefreshed) {
+	if (typeof target !== "object" || target === null) return;
+	try {
+		const meta = target;
+		meta[RETRY_ATTEMPTS_KEY] = attempts;
+		meta[RETRY_AUTH_REFRESHED_KEY] = authRefreshed;
+	} catch {}
+}
+async function tryRefreshAuth(onUnauthorized) {
+	try {
+		return await onUnauthorized();
+	} catch (error) {
+		consola.warn("onUnauthorized callback failed:", error instanceof Error ? error.message : error);
+		return null;
+	}
+}
+/**
+* Build an onUnauthorized callback that refreshes the Copilot token and
+* returns a new RequestInit with an updated Authorization header.
+*/
+function makeCopilotAuthRetry(refreshToken, init) {
+	return async () => {
+		const newToken = await refreshToken();
+		if (!newToken) return null;
+		const headers = new Headers(init.headers);
+		headers.set("Authorization", `Bearer ${newToken}`);
+		return {
+			...init,
+			headers
+		};
+	};
+}
+
+//#endregion
+//#region src/services/copilot/copilot-fetch.ts
+/**
+* Single transport seam for all upstream Copilot API calls.
+*
+* Wraps every request with:
+* - Network-error retry (UND_ERR_SOCKET, ECONNRESET, ENOTFOUND, connect timeouts)
+* - 401 → forceRefreshCopilotToken → retry once with the new bearer token
+*
+* Callers supply the path (e.g. "/chat/completions") and the usual RequestInit.
+* The host prefix and resilience wiring are applied here so every endpoint
+* gets the same treatment and adding a new endpoint is one call site.
+*/
+function copilotFetch(path, init) {
+	return fetchWithRetry(`${copilotBaseUrl(state)}${path}`, init, { onUnauthorized: makeCopilotAuthRetry(forceRefreshCopilotToken, init) });
+}
+
 //#endregion
 //#region src/services/copilot/get-models.ts
 const getModels = async () => {
-	const response = await fetch(`${copilotBaseUrl(state)}/models`, { headers: copilotHeaders(state) });
+	const response = await copilotFetch("/models", { headers: copilotHeaders(state) });
 	if (!response.ok) throw await HTTPError.fromResponse("Failed to get models", response);
 	return await response.json();
 };
@@ -586,6 +704,23 @@ async function refreshCopilotTokenWithRetry(maxRetries = 3) {
 	return null;
 }
 /**
+* Force-refresh the Copilot token on demand (e.g. after a 401 response).
+* Updates state.copilotToken on success and returns the new token, or null
+* if refresh failed. Coalesces concurrent callers so multiple in-flight 401s
+* only trigger one refresh.
+*/
+let refreshInFlight = null;
+async function forceRefreshCopilotToken() {
+	if (refreshInFlight) return refreshInFlight;
+	refreshInFlight = refreshCopilotTokenWithRetry().then((token) => {
+		if (token) state.copilotToken = token;
+		return token;
+	}).finally(() => {
+		refreshInFlight = null;
+	});
+	return refreshInFlight;
+}
+/**
 * Clear any existing token refresh timer.
 * Call this before setting up a new timer or during cleanup.
 */
@@ -1213,7 +1348,7 @@ const patchClaude = defineCommand({
 
 //#endregion
 //#region package.json
-var version = "0.7.9";
+var version = "0.7.10";
 
 //#endregion
 //#region src/lib/adaptive-rate-limiter.ts
@@ -3280,17 +3415,16 @@ const createChatCompletions = async (payload, options) => {
 	const enableVision = wire.messages.some((x) => typeof x.content !== "string" && x.content?.some((x) => x.type === "image_url"));
 	const isAgentCall = wire.messages.some((msg) => ["assistant", "tool"].includes(msg.role));
 	const modelSupportsVision = options?.resolvedModel?.capabilities?.supports?.vision !== false;
-	const headers = {
-		...copilotHeaders(state, {
-			vision: enableVision && modelSupportsVision,
-			modelRequestHeaders: options?.resolvedModel?.request_headers,
-			intent: isAgentCall ? "conversation-agent" : "conversation-panel"
-		}),
-		"X-Initiator": options?.initiator ?? (isAgentCall ? "agent" : "user")
-	};
-	const response = await fetch(`${copilotBaseUrl(state)}/chat/completions`, {
+	const response = await copilotFetch("/chat/completions", {
 		method: "POST",
-		headers,
+		headers: {
+			...copilotHeaders(state, {
+				vision: enableVision && modelSupportsVision,
+				modelRequestHeaders: options?.resolvedModel?.request_headers,
+				intent: isAgentCall ? "conversation-agent" : "conversation-panel"
+			}),
+			"X-Initiator": options?.initiator ?? (isAgentCall ? "agent" : "user")
+		},
 		body: JSON.stringify(wire)
 	});
 	if (!response.ok) {
@@ -3723,6 +3857,7 @@ function recordErrorResponse(ctx, model, error, endpoint, stream) {
 	}, Date.now() - ctx.startTime);
 	if (endpoint !== void 0) {
 		const metrics = extractErrorMetrics(error);
+		const { attempts } = getRetryAttempts(error);
 		captureRequest({
 			model,
 			inputTokens: 0,
@@ -3734,7 +3869,7 @@ function recordErrorResponse(ctx, model, error, endpoint, stream) {
 			...metrics,
 			errorPhase: stream ? "pre_stream" : "non_stream",
 			endpoint,
-			attempt: 1
+			attempt: attempts
 		});
 	}
 }
@@ -4120,7 +4255,24 @@ async function handleStreamingResponse$1(opts) {
 			endpoint: "chat_completions"
 		});
 		failTracking(ctx.trackingId, error);
-		throw error;
+		try {
+			const markerChunk = {
+				id: `error-marker-${Date.now()}`,
+				object: "chat.completion.chunk",
+				created: Math.floor(Date.now() / 1e3),
+				model: acc.model || payload.model,
+				choices: [{
+					index: 0,
+					delta: { content: `\n\n[copilot-api: upstream stream terminated. Please retry.]` },
+					finish_reason: "length",
+					logprobs: null
+				}]
+			};
+			await stream.writeSSE({
+				data: JSON.stringify(markerChunk),
+				event: "message"
+			});
+		} catch {}
 	}
 }
 function parseStreamChunk(chunk, acc, checkRepetition) {
@@ -4223,7 +4375,7 @@ completionRoutes.post("/", async (c) => {
 //#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`, {
+	const response = await copilotFetch("/embeddings", {
 		method: "POST",
 		headers: copilotHeaders(state),
 		body: JSON.stringify(payload)
@@ -4665,6 +4817,16 @@ async function handleGeminiGenerate(c, model, isStream) {
 					endpoint: "chat_completions"
 				});
 				failTracking(ctx.trackingId, error);
+				try {
+					await s.write(`data: ${JSON.stringify({ candidates: [{
+						content: {
+							role: "model",
+							parts: [{ text: `\n\n[copilot-api: upstream stream terminated. Please retry.]` }]
+						},
+						finishReason: "OTHER",
+						index: 0
+					}] })}\n\n`);
+				} catch {}
 			}
 		});
 	} catch (error) {
@@ -6912,7 +7074,7 @@ async function createAnthropicMessages(payload, options) {
 		}
 	}
 	consola.debug("Sending direct Anthropic request to Copilot /v1/messages");
-	const response = await fetch(`${copilotBaseUrl(state)}/v1/messages`, {
+	const response = await copilotFetch("/v1/messages", {
 		method: "POST",
 		headers,
 		body: JSON.stringify(filteredPayload)
@@ -8191,7 +8353,7 @@ const createResponses = async (payload, { vision, initiator, resolvedModel }) =>
 		"X-Initiator": initiator
 	};
 	payload.service_tier = null;
-	const response = await fetch(`${copilotBaseUrl(state)}/responses`, {
+	const response = await copilotFetch("/responses", {
 		method: "POST",
 		headers,
 		body: JSON.stringify(payload)
@@ -8474,6 +8636,7 @@ const handleResponses = async (c) => {
 				const idTracker = createStreamIdTracker();
 				let finalResult;
 				let streamErrorMessage;
+				let lastSequenceNumber = -1;
 				try {
 					for await (const chunk of response) {
 						consola.debug("Responses stream chunk:", JSON.stringify(chunk));
@@ -8484,6 +8647,10 @@ const handleResponses = async (c) => {
 							if ("response" in parsed) finalResult = parsed.response;
 							else if (eventType === "error" && "message" in parsed) streamErrorMessage = parsed.message;
 						} catch {}
+						try {
+							const parsed = JSON.parse(rawData);
+							if (typeof parsed.sequence_number === "number") lastSequenceNumber = parsed.sequence_number;
+						} catch {}
 						const processedData = fixStreamIds(rawData, eventType, idTracker);
 						await stream.writeSSE({
 							id: chunk.id,
@@ -8522,7 +8689,18 @@ const handleResponses = async (c) => {
 						endpoint: "responses"
 					});
 					failTracking(trackingId, error);
-					throw error;
+					try {
+						await stream.writeSSE({
+							event: "error",
+							data: JSON.stringify({
+								type: "error",
+								code: "upstream_stream_terminated",
+								message: "Upstream stream terminated mid-response. Please retry.",
+								param: null,
+								sequence_number: lastSequenceNumber + 1
+							})
+						});
+					} catch {}
 				}
 			});
 		}

package/package.json

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