copilot-api-plus 1.2.5 → 1.2.7

package/dist/main.js

@@ -120,16 +120,18 @@ async function applyProxyConfig() {
 }
 //#endregion
 //#region src/lib/proxy.ts
+const agentOptions = {
+	keepAliveTimeout: 3e4,
+	keepAliveMaxTimeout: 6e4,
+	connect: { timeout: 15e3 }
+};
+let direct;
+let proxies = /* @__PURE__ */ new Map();
 function initProxyFromEnv() {
 	if (typeof Bun !== "undefined") return;
 	try {
-		const agentOptions = {
-			keepAliveTimeout: 3e4,
-			keepAliveMaxTimeout: 6e4,
-			connect: { timeout: 15e3 }
-		};
-		const direct = new Agent(agentOptions);
-		const proxies = /* @__PURE__ */ new Map();
+		direct = new Agent(agentOptions);
+		proxies = /* @__PURE__ */ new Map();
 		setGlobalDispatcher({
 			dispatch(options, handler) {
 				try {
@@ -173,6 +175,28 @@ function initProxyFromEnv() {
 		consola.debug("Proxy setup skipped:", err);
 	}
 }
+/**
+* Destroy all pooled connections (direct + proxy agents) and replace them
+* with fresh instances.  The global dispatcher's `dispatch` method captures
+* `direct` and `proxies` by reference, so subsequent requests automatically
+* use the new agents — no need to call `setGlobalDispatcher` again.
+*
+* Call this after a network error to discard stale/half-closed sockets that
+* would otherwise cause every retry to wait ~60 s before timing out.
+*
+* Under the Bun runtime (which doesn't use undici) this is a no-op.
+*/
+function resetConnections() {
+	if (typeof Bun !== "undefined") return;
+	if (!direct) return;
+	const oldDirect = direct;
+	const oldProxies = proxies;
+	direct = new Agent(agentOptions);
+	proxies = /* @__PURE__ */ new Map();
+	oldDirect.close().catch(() => {});
+	for (const agent of oldProxies.values()) agent.close().catch(() => {});
+	consola.debug("Connection pool reset — stale sockets cleared");
+}
 //#endregion
 //#region src/account.ts
 const addAccount = defineCommand({
@@ -1684,15 +1708,12 @@ async function checkRateLimit(state) {
 */
 const FETCH_TIMEOUT_MS = 12e4;
 /**
-* Retry delays in ms (exponential back-off).
-* After a network error we wait longer before each retry to let the
-* Copilot backend recover and avoid triggering connection-level throttling.
+* Retry delays in ms.  After the first failure the connection pool is reset
+* (see `resetConnections`), so a single retry with a fresh socket is usually
+* enough.  Keeping retries minimal avoids wasting Copilot request credits
+* (billed per request).
 */
-const RETRY_DELAYS = [
-	2e3,
-	5e3,
-	1e4
-];
+const RETRY_DELAYS = [2e3];
 /**
 * Wrapper around `fetch()` that aborts if the server doesn't respond within
 * `timeoutMs`.  The timeout only covers the period until the response headers
@@ -1727,6 +1748,7 @@ async function fetchWithRetry(url, buildInit) {
 		return await fetchWithTimeout(url, buildInit());
 	} catch (error) {
 		lastError = error;
+		if (attempt === 0) 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);
@@ -1930,16 +1952,8 @@ async function handleMultiAccountHttpError(error, account, retryContext) {
 			return null;
 		default:
 			if (error.response.status >= 500) {
-				consola.warn(`Account ${account.label}: upstream ${error.response.status}, retrying in 2s...`);
-				await new Promise((r) => setTimeout(r, 2e3));
-				try {
-					const result = await doFetch(retryContext.payload, retryContext.tokenSource);
-					accountManager.markAccountSuccess(account.id);
-					return result;
-				} catch {
-					consola.warn(`Account ${account.label}: upstream ${error.response.status} persists, trying next account...`);
-					return null;
-				}
+				accountManager.markAccountStatus(account.id, "error", `HTTP ${error.response.status}`);
+				return null;
 			}
 			accountManager.markAccountStatus(account.id, "error", `HTTP ${error.response.status}`);
 			return null;