copilot-api-plus 1.2.9 → 1.2.11

package/README.en.md

@@ -46,7 +46,7 @@ English | [简体中文](README.md)
 | 👥 **Multi-Account** | Multiple GitHub accounts with automatic failover on quota exhaustion/rate limiting/bans |
 | 🔀 **Model Routing** | Flexible model name mapping and per-model concurrency control |
 | 📱 **Visual Management** | Web dashboard for account management, model config, and runtime stats |
-| 🛡️ **Network Resilience** | 120s connection timeout + smart retry (pool reset + fast-fail) |
+| 🛡️ **Network Resilience** | 120s timeout + smart retry + proxy tunnel keepalive (45s heartbeat) |
 | ✂️ **Context Passthrough** | Full context passthrough to upstream API; clients (e.g. Claude Code) manage compression |
 | 🔍 **Smart Model Matching** | Handles model name format differences (date suffixes, dash/dot versions, etc.) |
 | 🧠 **Thinking Chain** | Automatically enables deep thinking (thinking/reasoning) for supported models, improving code quality |
@@ -582,9 +582,11 @@ Each API request outputs a log line with model name, status code, and duration:
 
 Built-in connection timeout and smart retry for upstream API requests, minimizing Copilot request credit consumption:
 
-- **Connection timeout**: 120 seconds for the first attempt, 20 seconds for retries (fail fast)
-- **Retry strategy**: Up to 1 retry (2 total attempts), 2-second delay
+- **Connection timeout**: 120 seconds for the first attempt, 30 seconds for retries (headers typically arrive in 3–5s)
+- **Retry strategy**: Up to 2 retries (3 total attempts), 2-3 second delays
 - **Connection pool reset**: Automatically destroys all pooled connections on the first network error and creates fresh instances, preventing retries from hitting stale sockets
+- **Proxy tunnel keepalive**: Sends lightweight heartbeat requests every 45s while SSE streams are active, preventing proxy nodes from killing CONNECT tunnels due to inactivity
+- **HTTP/2 support**: Enables HTTP/2 protocol for better multiplexing performance
 - Only retries network-layer errors (timeout, TLS disconnect, connection reset, etc.); HTTP error codes (e.g. 400/500) are not retried
 - SSE stream interruptions gracefully send error events to the client
 

package/README.md

@@ -47,7 +47,7 @@
 | 👥 **多账号管理** | 支持添加多个 GitHub 账号，额度耗尽/限流/封禁时自动切换下一个 |
 | 🔀 **模型路由** | 灵活的模型名映射和每模型并发控制 |
 | 📱 **可视化管理** | Web 仪表盘支持账号管理、模型管理、运行统计 |
-| 🛡️ **网络弹性** | 120s 连接超时 + 智能重试（连接池重置 + 短超时快速失败） |
+| 🛡️ **网络弹性** | 120s 连接超时 + 智能重试 + 代理隧道保活（45s 心跳防断连） |
 | ✂️ **上下文透传** | 全量透传上下文至上游 API，由客户端（如 Claude Code）自行管理压缩 |
 | 🔍 **智能模型匹配** | 自动处理模型名格式差异（日期后缀、dash/dot 版本号等） |
 | 🧠 **Thinking 思维链** | 自动为支持的模型启用深度思考（thinking/reasoning），提升代码质量 |
@@ -745,9 +745,11 @@ Anthropic 格式的模型名（如 `claude-opus-4-6`）和 Copilot 的模型列
 
 对上游 API 的请求内置了连接超时和智能重试，以最小化 Copilot 请求次数消耗：
 
-- **连接超时**：首次请求 120 秒，重试请求 20 秒（快速失败，避免白等）
-- **重试策略**：最多重试 1 次（共 2 次尝试），间隔 2 秒
+- **连接超时**：首次请求 120 秒，重试请求 30 秒（响应头通常 3~5 秒到达）
+- **重试策略**：最多重试 2 次（共 3 次尝试），间隔 2-3 秒
 - **连接池重置**：首次网络错误后自动销毁所有连接并创建新实例，避免后续请求复用坏连接
+- **代理隧道保活**：SSE 流传输期间每 45 秒发送一次轻量心跳请求，防止代理节点因空闲而杀断 CONNECT 隧道
+- **HTTP/2 支持**：启用 HTTP/2 协议，提升多路复用性能
 - 仅重试网络层错误（超时、TLS 断开、连接重置等），HTTP 错误码（如 400/500）不重试
 - SSE 流传输中断时，优雅地向客户端发送错误事件
 

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-DUSd-gxE.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 { createRequire } from "node:module";
 import { defineCommand, runMain } from "citty";
 import consola from "consola";
@@ -121,8 +121,9 @@ async function applyProxyConfig() {
 //#endregion
 //#region src/lib/proxy.ts
 const agentOptions = {
-	keepAliveTimeout: 6e4,
-	keepAliveMaxTimeout: 3e5,
+	keepAliveTimeout: 3e5,
+	keepAliveMaxTimeout: 6e5,
+	allowH2: true,
 	connect: {
 		timeout: 15e3,
 		keepAlive: true,
@@ -131,6 +132,59 @@ const agentOptions = {
 };
 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 {
@@ -174,6 +228,7 @@ function initProxyFromEnv() {
 				return direct.destroy();
 			}
 		});
+		proxyActive = true;
 		consola.debug("HTTP proxy configured from environment (per-URL)");
 	} catch (err) {
 		consola.debug("Proxy setup skipped:", err);
@@ -1713,19 +1768,23 @@ async function checkRateLimit(state) {
 const FETCH_TIMEOUT_MS = 12e4;
 /**
 * 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).
+* (see `resetConnections`), so retries use fresh sockets.  We allow up to
+* 2 retries because SSE streams through HTTP proxies are frequently
+* interrupted during long model thinking phases (~60 s idle timeout on
+* many proxy nodes).  Keeping the delay short avoids wasting wall-clock time.
 */
-const RETRY_DELAYS = [2e3];
+const RETRY_DELAYS = [2e3, 3e3];
 /**
-* Shorter timeout for retry attempts.  The first request uses the full
-* FETCH_TIMEOUT_MS (120 s) to accommodate slow models.  Retries happen
-* after a connection-pool reset, so a fresh socket should connect quickly —
-* if it doesn't respond within 20 s, the upstream is genuinely down and
-* waiting longer just burns time (and possibly credits).
+* 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 = 2e4;
+const RETRY_TIMEOUT_MS = 3e4;
 /**
 * Wrapper around `fetch()` that aborts if the server doesn't respond within
 * `timeoutMs`.  The timeout only covers the period until the response headers
@@ -1773,11 +1832,14 @@ async function fetchWithRetry(url, buildInit) {
 /**
 * 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();
 	try {
 		yield* gen;
 	} finally {
+		notifyStreamEnd();
 		releaseSlot();
 	}
 }
@@ -3094,14 +3156,19 @@ async function runServer(options) {
 	if (state.apiKeys && state.apiKeys.length > 0) consola.info(`API key authentication enabled with ${state.apiKeys.length} key(s)`);
 	await ensurePaths();
 	await cacheVSCodeVersion();
-	await (options.githubToken ? validateGitHubToken(options.githubToken) : setupGitHubToken());
+	try {
+		await (options.githubToken ? validateGitHubToken(options.githubToken) : setupGitHubToken());
+	} catch (error) {
+		consola.error(`GitHub authentication failed: ${rootCause(error)}`);
+		consola.info("The server will start, but requests may fail until connectivity is restored");
+	}
 	try {
 		await setupCopilotToken();
 	} catch (error) {
 		const { HTTPError } = await import("./error-Cc8bY0ph.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-B_m1icXz.js");
+			const { clearGithubToken } = await import("./token-M99mSdhH.js");
 			await clearGithubToken();
 			consola.info("Please restart to re-authenticate");
 		}