copilot-api-plus 1.2.16 → 1.2.18

package/dist/main.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { _ as GITHUB_BASE_URL, a as PATHS, b as copilotHeaders, c as forwardError, d as findModel, f as isNullish, h as state, l as cacheModels, m as sleep, o as ensurePaths, p as rootCause, r as getCopilotUsage, s as HTTPError, t as accountManager, u as cacheVSCodeVersion, v as GITHUB_CLIENT_ID, x as standardHeaders, y as copilotBaseUrl } from "./account-manager-DmXXcFBW.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-BRQK8jBj.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-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 { createRequire } from "node:module";
 import { defineCommand, runMain } from "citty";
 import consola from "consola";
@@ -8,8 +8,6 @@ import { timingSafeEqual } from "node:crypto";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { getProxyForUrl } from "proxy-from-env";
-import { Agent, ProxyAgent, setGlobalDispatcher } from "undici";
 import * as p from "@clack/prompts";
 import clipboard from "clipboardy";
 import { serve } from "srvx";
@@ -119,144 +117,6 @@ async function applyProxyConfig() {
 	return true;
 }
 //#endregion
-//#region src/lib/proxy.ts
-const agentOptions = {
-	keepAliveTimeout: 3e5,
-	keepAliveMaxTimeout: 6e5,
-	allowH2: true,
-	connect: {
-		timeout: 15e3,
-		keepAlive: true,
-		keepAliveInitialDelay: 15e3
-	}
-};
-let direct;
-let proxies = /* @__PURE__ */ new Map();
-/** Whether a proxy is actually configured and in use. */
-let proxyActive = false;
-/**
-* Many proxy nodes (especially third-party VPN/airport services) kill
-* CONNECT tunnels that are idle for ~60 s.  During long model thinking
-* phases the SSE stream carries no data, which looks "idle" to the proxy.
-*
-* This keepalive sends a tiny HEAD request to the Copilot API every 45 s
-* through the same proxy.  The encrypted packets flowing through the
-* CONNECT tunnel reset the proxy's idle timer, keeping the tunnel alive.
-*
-* The keepalive is active ONLY while there are SSE streams in flight
-* (tracked via `streamCount`).  When no streams are active it stops to
-* avoid unnecessary traffic.
-*/
-let keepaliveTimer;
-let streamCount = 0;
-const KEEPALIVE_INTERVAL_MS = 45e3;
-const KEEPALIVE_URL = "https://api.individual.githubcopilot.com/";
-function startKeepalive() {
-	if (keepaliveTimer) return;
-	keepaliveTimer = setInterval(() => {
-		fetch(KEEPALIVE_URL, { method: "HEAD" }).catch(() => {});
-		consola.debug("Proxy keepalive ping sent");
-	}, KEEPALIVE_INTERVAL_MS);
-	keepaliveTimer.unref();
-	consola.debug("Proxy keepalive started (45 s interval)");
-}
-function stopKeepalive() {
-	if (keepaliveTimer) {
-		clearInterval(keepaliveTimer);
-		keepaliveTimer = void 0;
-		consola.debug("Proxy keepalive stopped (no active streams)");
-	}
-}
-/**
-* Call when an SSE stream starts.  Activates the proxy-tunnel keepalive
-* if this is the first active stream and a proxy is configured.
-*/
-function notifyStreamStart() {
-	if (!proxyActive) return;
-	streamCount++;
-	if (streamCount === 1) startKeepalive();
-}
-/**
-* Call when an SSE stream ends (success or error).  Stops the keepalive
-* once no streams are active.
-*/
-function notifyStreamEnd() {
-	if (!proxyActive) return;
-	streamCount = Math.max(0, streamCount - 1);
-	if (streamCount === 0) stopKeepalive();
-}
-function initProxyFromEnv() {
-	if (typeof Bun !== "undefined") return;
-	try {
-		direct = new Agent(agentOptions);
-		proxies = /* @__PURE__ */ new Map();
-		setGlobalDispatcher({
-			dispatch(options, handler) {
-				try {
-					const origin = typeof options.origin === "string" ? new URL(options.origin) : options.origin;
-					const raw = getProxyForUrl(origin.toString());
-					const proxyUrl = raw && raw.length > 0 ? raw : void 0;
-					if (!proxyUrl) {
-						consola.debug(`HTTP proxy bypass: ${origin.hostname}`);
-						return direct.dispatch(options, handler);
-					}
-					let agent = proxies.get(proxyUrl);
-					if (!agent) {
-						agent = new ProxyAgent({
-							uri: proxyUrl,
-							...agentOptions
-						});
-						proxies.set(proxyUrl, agent);
-					}
-					let label = proxyUrl;
-					try {
-						const u = new URL(proxyUrl);
-						label = `${u.protocol}//${u.host}`;
-					} catch {}
-					consola.debug(`HTTP proxy route: ${origin.hostname} via ${label}`);
-					return agent.dispatch(options, handler);
-				} catch {
-					return direct.dispatch(options, handler);
-				}
-			},
-			close() {
-				for (const agent of proxies.values()) agent.close();
-				return direct.close();
-			},
-			destroy() {
-				for (const agent of proxies.values()) agent.destroy();
-				return direct.destroy();
-			}
-		});
-		proxyActive = true;
-		consola.debug("HTTP proxy configured from environment (per-URL)");
-	} catch (err) {
-		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({
 	meta: {
@@ -1490,6 +1350,10 @@ accountRoutes.post("/", async (c) => {
 		const body = await c.req.json();
 		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) {
+			account.proxy = body.proxy;
+			await accountManager.saveAccounts();
+		}
 		return c.json({ account: sanitiseAccount(account) }, 201);
 	} catch (error) {
 		consola.warn(`Error adding account: ${rootCause(error)}`);
@@ -1787,20 +1651,29 @@ const RETRY_DELAYS = [2e3];
 * 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. */
+const ACCOUNT_SWITCH_JITTER_MIN_MS = 1e3;
+const ACCOUNT_SWITCH_JITTER_MAX_MS = 5e3;
+/** Track the last-used account ID to detect account switches. */
+let lastUsedAccountId;
 /**
 * Wrapper around `fetch()` that aborts if the server doesn't respond within
 * `timeoutMs`.  The timeout only covers the period until the response headers
 * arrive – once the body starts streaming, the timeout is cleared so that
 * long SSE responses are not interrupted.
 */
-async function fetchWithTimeout(url, init, timeoutMs = FETCH_TIMEOUT_MS) {
+async function fetchWithTimeout(url, init, { timeoutMs = FETCH_TIMEOUT_MS, accountId, accountProxy } = {}) {
 	const controller = new AbortController();
 	const timer = setTimeout(() => controller.abort(), timeoutMs);
 	try {
-		return await fetch(url, {
+		const fetchOptions = {
 			...init,
 			signal: controller.signal
-		});
+		};
+		if (accountId) fetchOptions.dispatcher = getAccountDispatcher(accountId, accountProxy);
+		return await fetch(url, fetchOptions);
 	} catch (error) {
 		if (error instanceof DOMException && error.name === "AbortError") throw new Error(`Request timed out after ${timeoutMs}ms`);
 		throw error;
@@ -1814,12 +1687,16 @@ async function fetchWithTimeout(url, init, timeoutMs = FETCH_TIMEOUT_MS) {
 * Returns `{ response }` on success.
 * Throws the last network error if all retries are exhausted.
 */
-async function fetchWithRetry(url, buildInit) {
+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;
-		return await fetchWithTimeout(url, buildInit(), timeout);
+		return await fetchWithTimeout(url, buildInit(), {
+			timeoutMs: timeout,
+			accountId,
+			accountProxy
+		});
 	} catch (error) {
 		lastError = error;
 		const msg = error instanceof Error ? error.message : String(error);
@@ -1827,7 +1704,8 @@ async function fetchWithRetry(url, buildInit) {
 			consola.warn(`Request timed out on attempt ${attempt + 1}/${maxAttempts} — not retrying (credit likely consumed):`, msg);
 			break;
 		}
-		if (attempt === 0) resetConnections();
+		if (attempt === 0) 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);
@@ -1863,6 +1741,13 @@ async function* wrapGeneratorWithRelease(gen, releaseSlot) {
 */
 const reasoningUnsupportedModels = /* @__PURE__ */ new Set();
 /**
+* Models whose reasoning_effort must be capped at a lower level.
+* e.g. claude-opus-4.7 rejects "high" but accepts "medium".
+* When a model returns 400 with "is not supported by model", it is added
+* here with its maximum supported effort level.
+*/
+const reasoningEffortCap = /* @__PURE__ */ new Map();
+/**
 * Compute an appropriate thinking_budget from model capabilities.
 * Returns undefined if the model does not support thinking.
 */
@@ -1892,7 +1777,9 @@ function isToolChoiceForced(toolChoice) {
 *   1. If the client already set reasoning_effort or thinking_budget → keep as-is
 *   2. If tool_choice forces tool use → skip (API rejects the combination)
 *   3. If model capabilities declare max_thinking_budget → inject thinking_budget
-*   4. Otherwise → inject reasoning_effort="high" (works on claude-*-4.6)
+*   4. Otherwise → inject reasoning_effort at the highest level the model supports:
+*      - "high" by default (maximum thinking for most models)
+*      - Capped to "medium"/"low" if the model previously rejected "high"
 *
 * The fallback to reasoning_effort ensures thinking works even when the
 * /models endpoint doesn't expose thinking budget fields.
@@ -1905,16 +1792,17 @@ function injectThinking(payload, resolvedModel) {
 		...payload,
 		thinking_budget: budget
 	};
-	if (!reasoningUnsupportedModels.has(resolvedModel)) return {
+	if (reasoningUnsupportedModels.has(resolvedModel)) return payload;
+	const effort = reasoningEffortCap.get(resolvedModel) ?? "high";
+	return {
 		...payload,
-		reasoning_effort: "high"
+		reasoning_effort: effort
 	};
-	return payload;
 }
 function logThinkingInjection(original, injected, resolvedModel) {
 	if (original.reasoning_effort || original.thinking_budget) consola.debug(`Thinking: translated (reasoning_effort=${original.reasoning_effort ?? "none"} / thinking_budget=${original.thinking_budget ?? "none"})`);
 	else if (injected.thinking_budget && injected.thinking_budget !== original.thinking_budget) consola.debug(`Thinking: injected thinking_budget=${injected.thinking_budget} for "${resolvedModel}"`);
-	else if (injected.reasoning_effort === "high") consola.debug(`Thinking: injected reasoning_effort=high for "${resolvedModel}"`);
+	else if (injected.reasoning_effort && injected.reasoning_effort !== original.reasoning_effort) consola.debug(`Thinking: injected reasoning_effort=${injected.reasoning_effort} for "${resolvedModel}"`);
 	else if (reasoningUnsupportedModels.has(resolvedModel)) consola.debug(`Thinking: skipped — "${resolvedModel}" does not support reasoning`);
 }
 const createChatCompletions = async (payload) => {
@@ -1934,10 +1822,24 @@ const createChatCompletions = async (payload) => {
 		releaseSlot();
 		return result;
 	} catch (error) {
-		if (wasInjected && error instanceof HTTPError && error.response.status === 400 && error.message.includes("Unrecognized request argument")) {
-			reasoningUnsupportedModels.add(resolvedModel);
-			consola.info(`Model "${resolvedModel}" does not support reasoning_effort — disabled for future requests`);
-			return retryWithoutReasoning(routedPayload, releaseSlot);
+		if (error instanceof HTTPError && error.response.status === 400) {
+			const errMsg = error.message;
+			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);
+			}
+			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({
+						...routedPayload,
+						reasoning_effort: "medium"
+					}, releaseSlot);
+				}
+			}
 		}
 		releaseSlot();
 		throw error;
@@ -1959,6 +1861,21 @@ async function retryWithoutReasoning(payload, releaseSlot) {
 	}
 }
 /**
+* 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);
+		releaseSlot();
+		return result;
+	} catch (retryError) {
+		releaseSlot();
+		throw retryError;
+	}
+}
+/**
 * Dispatch request to either single-account or multi-account path.
 */
 function dispatchRequest(payload) {
@@ -2078,10 +1995,24 @@ async function createWithMultiAccount(payload) {
 			copilotApiEndpoint: account.copilotApiEndpoint,
 			accountType: account.accountType,
 			githubToken: account.githubToken,
-			vsCodeVersion: state.vsCodeVersion
+			vsCodeVersion: state.vsCodeVersion,
+			machineId: account.machineId,
+			sessionId: account.sessionId,
+			proxy: account.proxy
 		};
 		try {
-			const result = await doFetch(payload, tokenSource);
+			if (account.lastRequestAt) {
+				const elapsed = Date.now() - account.lastRequestAt;
+				if (elapsed < MIN_SAME_ACCOUNT_INTERVAL_MS) await new Promise((r) => setTimeout(r, MIN_SAME_ACCOUNT_INTERVAL_MS - elapsed));
+			}
+			if (lastUsedAccountId && lastUsedAccountId !== account.id) {
+				const jitter = ACCOUNT_SWITCH_JITTER_MIN_MS + Math.random() * (ACCOUNT_SWITCH_JITTER_MAX_MS - ACCOUNT_SWITCH_JITTER_MIN_MS);
+				consola.debug(`Account switch jitter: ${Math.round(jitter)}ms (${lastUsedAccountId.slice(0, 8)} → ${account.id.slice(0, 8)})`);
+				await new Promise((r) => setTimeout(r, jitter));
+			}
+			lastUsedAccountId = account.id;
+			const result = await doFetch(payload, tokenSource, account.id);
+			account.lastRequestAt = Date.now();
 			accountManager.markAccountSuccess(account.id);
 			return result;
 		} catch (error) {
@@ -2106,7 +2037,7 @@ async function createWithMultiAccount(payload) {
 * call it with different `TokenSource` objects while keeping all the header
 * construction / retry / error‐surfacing logic in one place.
 */
-async function doFetch(payload, source) {
+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 isAgentCall = payload.messages.some((msg) => ["assistant", "tool"].includes(msg.role));
 	const buildHeaders = () => ({
@@ -2127,7 +2058,10 @@ async function doFetch(payload, source) {
 		method: "POST",
 		headers: buildHeaders(),
 		body: bodyString
-	}));
+	}), {
+		accountId,
+		accountProxy: source.proxy
+	});
 	if (!response.ok) {
 		const errorBody = await response.text();
 		if (response.status === 400) consola.warn(`400: ${errorBody}`);
@@ -3149,7 +3083,7 @@ async function validateGitHubToken(token) {
 	state.githubToken = token;
 	consola.info("Using provided GitHub token");
 	try {
-		const { getGitHubUser } = await import("./get-user-DHr540ak.js");
+		const { getGitHubUser } = await import("./get-user-HaNtbtZZ.js");
 		const user = await getGitHubUser();
 		consola.info(`Logged in as ${user.login}`);
 	} catch (error) {
@@ -3200,10 +3134,10 @@ async function runServer(options) {
 	try {
 		await setupCopilotToken();
 	} catch (error) {
-		const { HTTPError } = await import("./error-Cc8bY0ph.js");
+		const { HTTPError } = await import("./error-Ci5sfamJ.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-M99mSdhH.js");
+			const { clearGithubToken } = await import("./token-BlHBeJfE.js");
 			await clearGithubToken();
 			consola.info("Please restart to re-authenticate");
 		}