copilot-api-plus 1.2.18 → 1.2.20

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-COJx3i2R.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-CswtzkcP.js";
+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-B9daQhPM.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-9T4XDHX4.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,27 +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.  After the first failure the connection pool is reset
-* (see `resetConnections`), so retries use fresh sockets.
-*
-* We only allow 1 retry (2 total attempts) to minimize credit waste.
-* Timeout errors are NOT retried at all — they indicate the request likely
-* reached Copilot (consuming a credit) and the upstream is slow or the
-* proxy killed the connection mid-flight.
-*/
-const RETRY_DELAYS = [2e3];
-/**
-* Timeout for retry attempts (waiting for response headers only).
-* Response headers typically arrive within 3–5 s, even on slow models.
-* 30 s is generous enough for a fresh socket to connect and receive
-* headers, while still failing fast when the upstream is truly down.
-*
-* NOTE: This does NOT affect the SSE streaming phase — once headers
-* arrive, the timeout is cleared and the stream runs until completion
-* or interruption.
-*/
-const RETRY_TIMEOUT_MS = 3e4;
 /** 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. */
@@ -1682,45 +1698,36 @@ 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.
+*
+* 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).
 *
-* Returns `{ response }` on success.
-* Throws the last network error if all retries are exhausted.
+* 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 = attempt === 0 ? FETCH_TIMEOUT_MS : RETRY_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
 * finishes (return or throw), not when the outer function returns.
 * Also tracks active streams for the proxy-tunnel keepalive mechanism.
 */
-async function* wrapGeneratorWithRelease(gen, releaseSlot) {
-	notifyStreamStart();
+async function* wrapGeneratorWithRelease(gen, releaseSlot, accountInfo) {
+	notifyStreamStart(accountInfo);
 	let streamError = false;
 	try {
 		yield* gen;
@@ -1728,9 +1735,10 @@ async function* wrapGeneratorWithRelease(gen, releaseSlot) {
 		streamError = true;
 		throw error;
 	} finally {
-		notifyStreamEnd();
+		notifyStreamEnd(accountInfo);
 		releaseSlot();
-		if (streamError) resetConnections();
+		if (streamError) if (accountInfo?.accountId) resetAccountConnections(accountInfo.accountId);
+		else resetConnections();
 	}
 }
 /**
@@ -1818,7 +1826,10 @@ const createChatCompletions = async (payload) => {
 	const releaseSlot = await modelRouter.acquireSlot(resolvedModel);
 	try {
 		const result = await dispatchRequest(thinkingPayload);
-		if (Symbol.asyncIterator in result) return wrapGeneratorWithRelease(result, releaseSlot);
+		if (Symbol.asyncIterator in result) {
+			const accountInfo = result.__accountInfo;
+			return wrapGeneratorWithRelease(result, releaseSlot, accountInfo);
+		}
 		releaseSlot();
 		return result;
 	} catch (error) {
@@ -1827,14 +1838,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);
@@ -1846,28 +1857,17 @@ 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) {
+async function retryWithModifiedPayload(payload, releaseSlot) {
 	try {
 		const result = await dispatchRequest(payload);
-		if (Symbol.asyncIterator in result) return wrapGeneratorWithRelease(result, releaseSlot);
-		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) {
-	try {
-		const result = await dispatchRequest(payload);
-		if (Symbol.asyncIterator in result) return wrapGeneratorWithRelease(result, releaseSlot);
+		if (Symbol.asyncIterator in result) {
+			const accountInfo = result.__accountInfo;
+			return wrapGeneratorWithRelease(result, releaseSlot, accountInfo);
+		}
 		releaseSlot();
 		return result;
 	} catch (retryError) {
@@ -1883,7 +1883,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),
@@ -1939,7 +1939,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 {
@@ -2014,6 +2014,10 @@ async function createWithMultiAccount(payload) {
 			const result = await doFetch(payload, tokenSource, account.id);
 			account.lastRequestAt = Date.now();
 			accountManager.markAccountSuccess(account.id);
+			if (Symbol.asyncIterator in result) result.__accountInfo = {
+				accountId: account.id,
+				accountProxy: account.proxy
+			};
 			return result;
 		} catch (error) {
 			lastError = error;
@@ -2038,7 +2042,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),
@@ -3083,7 +3087,7 @@ async function validateGitHubToken(token) {
 	state.githubToken = token;
 	consola.info("Using provided GitHub token");
 	try {
-		const { getGitHubUser } = await import("./get-user-HaNtbtZZ.js");
+		const { getGitHubUser } = await import("./get-user-q-uqgjND.js");
 		const user = await getGitHubUser();
 		consola.info(`Logged in as ${user.login}`);
 	} catch (error) {
@@ -3134,10 +3138,10 @@ async function runServer(options) {
 	try {
 		await setupCopilotToken();
 	} catch (error) {
-		const { HTTPError } = await import("./error-Ci5sfamJ.js");
+		const { HTTPError } = await import("./error-oHPe3O3W.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-BlHBeJfE.js");
+			const { clearGithubToken } = await import("./token-byWuxeZE.js");
 			await clearGithubToken();
 			consola.info("Please restart to re-authenticate");
 		}