copilot-api-plus 1.2.19 → 1.2.21

package/dist/main.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { C as GITHUB_BASE_URL, D as standardHeaders, E as copilotHeaders, T as copilotBaseUrl, _ as findModel, a as getAccountDispatcher, b as sleep, c as notifyStreamStart, d as PATHS, f as ensurePaths, g as cacheVSCodeVersion, h as cacheModels, l as resetAccountConnections, m as forwardError, o as initProxyFromEnv, p as HTTPError, r as getCopilotUsage, s as notifyStreamEnd, t as accountManager, u as resetConnections, v as isNullish, w as GITHUB_CLIENT_ID, x as state, y as rootCause } from "./account-manager-BLD3jHgL.js";
-import { a as stopCopilotTokenRefresh, i as setupGitHubToken, n as refreshCopilotToken, o as pollAccessToken, r as setupCopilotToken, s as getDeviceCode, t as clearGithubToken } from "./token-V-OSvQfl.js";
+import { C as state, D as copilotBaseUrl, E as GITHUB_CLIENT_ID, O as copilotHeaders, S as sleep, T as GITHUB_BASE_URL, _ as cacheModels, a as getAccountDispatcher, b as isNullish, c as isProxyActive, d as resetAccountConnections, f as resetConnections, g as forwardError, h as HTTPError, k as standardHeaders, l as notifyStreamEnd, m as ensurePaths, o as initProxyFromEnv, p as PATHS, r as getCopilotUsage, s as isAccountProxied, t as accountManager, u as notifyStreamStart, v as cacheVSCodeVersion, x as rootCause, y as findModel } from "./account-manager-hTatSbhl.js";
+import { a as stopCopilotTokenRefresh, i as setupGitHubToken, n as refreshCopilotToken, o as pollAccessToken, r as setupCopilotToken, s as getDeviceCode, t as clearGithubToken } from "./token-DoqfK3CD.js";
 import { createRequire } from "node:module";
 import { defineCommand, runMain } from "citty";
 import consola from "consola";
@@ -1351,6 +1351,16 @@ accountRoutes.post("/", async (c) => {
 		if (!body.githubToken || !body.label) return c.json({ error: "githubToken and label are required" }, 400);
 		const account = await accountManager.addAccount(body.githubToken, body.label, body.accountType);
 		if (body.proxy) {
+			try {
+				const proxyUrl = new URL(body.proxy);
+				if (![
+					"http:",
+					"https:",
+					"socks5:"
+				].includes(proxyUrl.protocol)) return c.json({ error: "proxy must use http://, https://, or socks5:// protocol" }, 400);
+			} catch {
+				return c.json({ error: "proxy must be a valid URL" }, 400);
+			}
 			account.proxy = body.proxy;
 			await accountManager.saveAccounts();
 		}
@@ -1393,6 +1403,33 @@ accountRoutes.put("/:id/status", async (c) => {
 		return c.json({ error: "Failed to update account status" }, 500);
 	}
 });
+accountRoutes.put("/:id/proxy", async (c) => {
+	try {
+		const id = c.req.param("id");
+		const body = await c.req.json();
+		const account = accountManager.getAccountById(id);
+		if (!account) return c.json({ error: "Account not found" }, 404);
+		if (body.proxy) {
+			try {
+				const proxyUrl = new URL(body.proxy);
+				if (![
+					"http:",
+					"https:",
+					"socks5:"
+				].includes(proxyUrl.protocol)) return c.json({ error: "proxy must use http://, https://, or socks5:// protocol" }, 400);
+			} catch {
+				return c.json({ error: "proxy must be a valid URL" }, 400);
+			}
+			account.proxy = body.proxy;
+		} else account.proxy = void 0;
+		await accountManager.saveAccounts();
+		return c.json({ account: sanitiseAccount(account) });
+	} catch (error) {
+		consola.warn(`Error updating account proxy: ${rootCause(error)}`);
+		consola.debug("Error updating account proxy:", error);
+		return c.json({ error: "Failed to update account proxy" }, 500);
+	}
+});
 accountRoutes.post("/:id/refresh", async (c) => {
 	try {
 		const id = c.req.param("id");
@@ -1630,15 +1667,6 @@ async function checkRateLimit(state) {
 * ~120s to start streaming, so we give a generous timeout for headers.
 */
 const FETCH_TIMEOUT_MS = 12e4;
-/**
-* Retry delays in ms.  Empty = no retries.
-*
-* IMPORTANT: Retries are DISABLED because each attempt to Copilot consumes
-* a credit, and the caller (e.g. Claude Code) already retries at the
-* application level.  Our retry + Claude Code's retry created a request
-* cascade that caused account bans (367 requests in 52 minutes).
-*/
-const RETRY_DELAYS = [];
 /** Minimum interval (ms) between requests on the same account. */
 const MIN_SAME_ACCOUNT_INTERVAL_MS = 1e3;
 /** Random jitter range (ms) added when switching between accounts. */
@@ -1670,37 +1698,28 @@ async function fetchWithTimeout(url, init, { timeoutMs = FETCH_TIMEOUT_MS, accou
 	}
 }
 /**
-* Retry loop for fetch: retries on network errors with exponential back-off.
+* Single-attempt fetch with connection pool reset on network errors.
 *
-* Returns `{ response }` on success.
-* Throws the last network error if all retries are exhausted.
+* Retries are intentionally disabled — each Copilot request consumes a
+* credit, and the caller (e.g. Claude Code) already retries at the
+* application level.  Our retry + caller retry created a request cascade
+* that caused account bans (367 requests in 52 minutes).
+*
+* On network failure (NOT timeout), the pooled connections are destroyed
+* so that the caller's next attempt gets a fresh socket instantly.
 */
 async function fetchWithRetry(url, buildInit, { accountId, accountProxy } = {}) {
-	let lastError;
-	const maxAttempts = RETRY_DELAYS.length + 1;
-	for (let attempt = 0; attempt < maxAttempts; attempt++) try {
-		const timeout = FETCH_TIMEOUT_MS;
+	try {
 		return await fetchWithTimeout(url, buildInit(), {
-			timeoutMs: timeout,
+			timeoutMs: FETCH_TIMEOUT_MS,
 			accountId,
 			accountProxy
 		});
 	} catch (error) {
-		lastError = error;
-		const msg = error instanceof Error ? error.message : String(error);
-		if (msg.includes("timed out")) {
-			consola.warn(`Request timed out on attempt ${attempt + 1}/${maxAttempts} — not retrying (credit likely consumed):`, msg);
-			break;
-		}
-		if (attempt === 0) if (accountId) resetAccountConnections(accountId);
+		if (!(error instanceof Error ? error.message : String(error)).includes("timed out")) if (accountId) resetAccountConnections(accountId);
 		else resetConnections();
-		if (attempt < maxAttempts - 1) {
-			const delay = RETRY_DELAYS[attempt];
-			consola.warn(`Network error on attempt ${attempt + 1}/${maxAttempts}, retrying in ${delay}ms:`, error instanceof Error ? error.message : error);
-			await new Promise((r) => setTimeout(r, delay));
-		}
+		throw error;
 	}
-	throw lastError instanceof Error ? lastError : /* @__PURE__ */ new Error("Network request failed");
 }
 /**
 * Wraps an AsyncGenerator so that `releaseSlot` is called when the generator
@@ -1809,7 +1828,9 @@ const createChatCompletions = async (payload) => {
 		const result = await dispatchRequest(thinkingPayload);
 		if (Symbol.asyncIterator in result) {
 			const accountInfo = result.__accountInfo;
-			return wrapGeneratorWithRelease(result, releaseSlot, accountInfo);
+			const wrapped = wrapGeneratorWithRelease(result, releaseSlot, accountInfo);
+			wrapped.__accountInfo = accountInfo;
+			return wrapped;
 		}
 		releaseSlot();
 		return result;
@@ -1819,14 +1840,14 @@ const createChatCompletions = async (payload) => {
 			if (wasInjected && errMsg.includes("Unrecognized request argument")) {
 				reasoningUnsupportedModels.add(resolvedModel);
 				consola.info(`Model "${resolvedModel}" does not support reasoning_effort — disabled for future requests`);
-				return retryWithoutReasoning(routedPayload, releaseSlot);
+				return retryWithModifiedPayload(routedPayload, releaseSlot);
 			}
 			if (errMsg.includes("is not supported by model")) {
 				const currentEffort = thinkingPayload.reasoning_effort;
 				if (currentEffort && currentEffort !== "medium" && currentEffort !== "low") {
 					reasoningEffortCap.set(resolvedModel, "medium");
 					consola.info(`Model "${resolvedModel}" rejected reasoning_effort="${currentEffort}" — downgrading to "medium" for future requests`);
-					return retryWithDowngradedReasoning({
+					return retryWithModifiedPayload({
 						...routedPayload,
 						reasoning_effort: "medium"
 					}, releaseSlot);
@@ -1838,33 +1859,18 @@ const createChatCompletions = async (payload) => {
 	}
 };
 /**
-* Retry a request without reasoning_effort after the model rejected it.
+* Retry a request after modifying the payload (e.g. stripping or
+* downgrading reasoning_effort).
 * Handles slot release for both streaming and non-streaming responses.
 */
-async function retryWithoutReasoning(payload, releaseSlot) {
-	try {
-		const result = await dispatchRequest(payload);
-		if (Symbol.asyncIterator in result) {
-			const accountInfo = result.__accountInfo;
-			return wrapGeneratorWithRelease(result, releaseSlot, accountInfo);
-		}
-		releaseSlot();
-		return result;
-	} catch (retryError) {
-		releaseSlot();
-		throw retryError;
-	}
-}
-/**
-* Retry a request with a downgraded reasoning_effort after the model
-* rejected the higher value (e.g. "high" → "medium").
-*/
-async function retryWithDowngradedReasoning(payload, releaseSlot) {
+async function retryWithModifiedPayload(payload, releaseSlot) {
 	try {
 		const result = await dispatchRequest(payload);
 		if (Symbol.asyncIterator in result) {
 			const accountInfo = result.__accountInfo;
-			return wrapGeneratorWithRelease(result, releaseSlot, accountInfo);
+			const wrapped = wrapGeneratorWithRelease(result, releaseSlot, accountInfo);
+			wrapped.__accountInfo = accountInfo;
+			return wrapped;
 		}
 		releaseSlot();
 		return result;
@@ -1881,7 +1887,7 @@ function dispatchRequest(payload) {
 }
 async function createWithSingleAccount(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) => x.type === "image_url"));
+	const enableVision = payload.messages.some((msg) => typeof msg.content !== "string" && msg.content?.some((part) => part.type === "image_url"));
 	const isAgentCall = payload.messages.some((msg) => ["assistant", "tool"].includes(msg.role));
 	const buildHeaders = () => ({
 		...copilotHeaders(state, enableVision),
@@ -1937,7 +1943,7 @@ async function tryRefreshAndRetry(account, payload, tokenSource) {
 	try {
 		await accountManager.refreshAccountToken(account);
 		tokenSource.copilotToken = account.copilotToken;
-		const result = await doFetch(payload, tokenSource);
+		const result = await doFetch(payload, tokenSource, account.id);
 		accountManager.markAccountSuccess(account.id);
 		return result;
 	} catch {
@@ -2040,7 +2046,7 @@ async function createWithMultiAccount(payload) {
 * construction / retry / error‐surfacing logic in one place.
 */
 async function doFetch(payload, source, accountId) {
-	const enableVision = payload.messages.some((x) => typeof x.content !== "string" && x.content?.some((x) => x.type === "image_url"));
+	const enableVision = payload.messages.some((msg) => typeof msg.content !== "string" && msg.content?.some((part) => part.type === "image_url"));
 	const isAgentCall = payload.messages.some((msg) => ["assistant", "tool"].includes(msg.role));
 	const buildHeaders = () => ({
 		...copilotHeaders(source, enableVision),
@@ -2835,6 +2841,86 @@ function translateErrorToAnthropicErrorEvent() {
 }
 //#endregion
 //#region src/routes/messages/handler.ts
+/** Heartbeat interval — keeps the downstream connection alive. */
+const HEARTBEAT_PROXIED_MS = 15e3;
+const HEARTBEAT_DIRECT_MS = 3e4;
+/**
+* Upstream silence timeout — if no SSE data arrives for this long,
+* treat the upstream as dead and close the stream with an error.
+*/
+const UPSTREAM_TIMEOUT_PROXIED_MS = 9e4;
+const UPSTREAM_TIMEOUT_DIRECT_MS = 3e5;
+/** Sentinel value returned by the sleep branch of Promise.race. */
+const HEARTBEAT = Symbol("heartbeat");
+/** Simple non-cancellable sleep that resolves to a sentinel. */
+function heartbeatDelay(ms) {
+	return new Promise((resolve) => setTimeout(() => resolve(HEARTBEAT), ms));
+}
+/** Send an error event to the downstream client, ignoring write failures. */
+async function sendErrorEvent(stream) {
+	try {
+		const errorEvent = translateErrorToAnthropicErrorEvent();
+		await stream.writeSSE({
+			event: errorEvent.type,
+			data: JSON.stringify(errorEvent)
+		});
+	} catch {}
+}
+/**
+* Consume the upstream SSE async iterator with heartbeat injection.
+*
+* Uses `Promise.race` between the next upstream event and a heartbeat
+* timer.  The same `iter.next()` promise is reused across heartbeat
+* cycles to prevent data loss.
+*
+* No external requests are made — heartbeat pings are written to the
+* downstream HTTP response only.
+*/
+async function consumeStreamWithHeartbeat(response, stream, opts) {
+	const { streamState, heartbeatMs, upstreamTimeoutMs } = opts;
+	const iter = response[Symbol.asyncIterator]();
+	let pendingNext = iter.next();
+	let lastDataAt = Date.now();
+	while (true) {
+		const raceResult = await Promise.race([pendingNext.then((r) => ({
+			kind: "data",
+			result: r
+		})), heartbeatDelay(heartbeatMs)]);
+		if (raceResult === HEARTBEAT) {
+			const silenceMs = Date.now() - lastDataAt;
+			if (silenceMs >= upstreamTimeoutMs) {
+				consola.warn(`Upstream silent for ${Math.round(silenceMs / 1e3)}s (limit ${upstreamTimeoutMs / 1e3}s), closing stream`);
+				resetConnections();
+				await sendErrorEvent(stream);
+				break;
+			}
+			await stream.writeSSE({
+				event: "ping",
+				data: "{\"type\":\"ping\"}"
+			});
+			consola.debug(`SSE heartbeat ping sent (silent ${Math.round(silenceMs / 1e3)}s)`);
+			continue;
+		}
+		const { result: iterResult } = raceResult;
+		if (iterResult.done) break;
+		lastDataAt = Date.now();
+		pendingNext = iter.next();
+		const rawEvent = iterResult.value;
+		if (rawEvent.data === "[DONE]") break;
+		if (!rawEvent.data) continue;
+		let chunk;
+		try {
+			chunk = JSON.parse(rawEvent.data);
+		} catch {
+			consola.debug("Skipping malformed SSE chunk");
+			continue;
+		}
+		for (const event of translateChunkToAnthropicEvents(chunk, streamState)) await stream.writeSSE({
+			event: event.type,
+			data: JSON.stringify(event)
+		});
+	}
+}
 async function handleCompletion(c) {
 	await checkRateLimit(state);
 	const anthropicPayload = await c.req.json();
@@ -2850,10 +2936,12 @@ async function handleCompletion(c) {
 	const openAIPayload = translateToOpenAI(anthropicPayload);
 	if (state.manualApprove) await awaitApproval();
 	const response = await createChatCompletions(openAIPayload);
-	if (isNonStreaming(response)) {
-		const anthropicResponse = translateToAnthropic(response);
-		return c.json(anthropicResponse);
-	}
+	if (isNonStreaming(response)) return c.json(translateToAnthropic(response));
+	const accountInfo = response.__accountInfo;
+	const proxied = accountInfo ? isAccountProxied(accountInfo.accountProxy) : isProxyActive();
+	const heartbeatMs = proxied ? HEARTBEAT_PROXIED_MS : HEARTBEAT_DIRECT_MS;
+	const upstreamTimeoutMs = proxied ? UPSTREAM_TIMEOUT_PROXIED_MS : UPSTREAM_TIMEOUT_DIRECT_MS;
+	consola.debug(`SSE stream config: proxied=${proxied}, heartbeat=${heartbeatMs / 1e3}s, timeout=${upstreamTimeoutMs / 1e3}s`);
 	return streamSSE(c, async (stream) => {
 		const streamState = {
 			messageStartSent: false,
@@ -2864,34 +2952,16 @@ async function handleCompletion(c) {
 			thinkingRequested: Boolean(anthropicPayload.thinking)
 		};
 		try {
-			for await (const rawEvent of response) {
-				const event = rawEvent;
-				if (event.data === "[DONE]") break;
-				if (!event.data) continue;
-				let chunk;
-				try {
-					chunk = JSON.parse(event.data);
-				} catch {
-					consola.debug("Skipping malformed SSE chunk");
-					continue;
-				}
-				const events = translateChunkToAnthropicEvents(chunk, streamState);
-				for (const event of events) await stream.writeSSE({
-					event: event.type,
-					data: JSON.stringify(event)
-				});
-			}
+			await consumeStreamWithHeartbeat(response, stream, {
+				streamState,
+				heartbeatMs,
+				upstreamTimeoutMs
+			});
 		} catch (error) {
 			const message = error.message || String(error);
 			consola.warn(`SSE stream interrupted: ${message}`);
 			resetConnections();
-			try {
-				const errorEvent = translateErrorToAnthropicErrorEvent();
-				await stream.writeSSE({
-					event: errorEvent.type,
-					data: JSON.stringify(errorEvent)
-				});
-			} catch {}
+			await sendErrorEvent(stream);
 		}
 	});
 }
@@ -3085,7 +3155,7 @@ async function validateGitHubToken(token) {
 	state.githubToken = token;
 	consola.info("Using provided GitHub token");
 	try {
-		const { getGitHubUser } = await import("./get-user-BSYESgez.js");
+		const { getGitHubUser } = await import("./get-user-BuSGshPt.js");
 		const user = await getGitHubUser();
 		consola.info(`Logged in as ${user.login}`);
 	} catch (error) {
@@ -3136,10 +3206,10 @@ async function runServer(options) {
 	try {
 		await setupCopilotToken();
 	} catch (error) {
-		const { HTTPError } = await import("./error-BDOdv5Up.js");
+		const { HTTPError } = await import("./error-BZbc7idf.js");
 		if (error instanceof HTTPError && error.response.status === 401) {
 			consola.error("Failed to get Copilot token - GitHub token may be invalid or Copilot access revoked");
-			const { clearGithubToken } = await import("./token-C9gxxgzi.js");
+			const { clearGithubToken } = await import("./token-DKdhI9cl.js");
 			await clearGithubToken();
 			consola.info("Please restart to re-authenticate");
 		}