copilot-api-plus 1.2.10 → 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 + HTTP/2 keepalive + proxy optimization) |
+| 🛡️ **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,11 +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, 90 seconds for retries (enough time for model thinking)
+- **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
-- **HTTP/2 keepalive**: Enables HTTP/2 protocol; PING frames traverse proxy tunnels to prevent idle disconnections
-- **TCP keepalive**: Sends TCP probes every 15s to prevent proxies/firewalls from dropping idle connections
+- **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 连接超时 + 智能重试（连接池重置 + HTTP/2 保活 + 代理穿透优化） |
+| 🛡️ **网络弹性** | 120s 连接超时 + 智能重试 + 代理隧道保活（45s 心跳防断连） |
 | ✂️ **上下文透传** | 全量透传上下文至上游 API，由客户端（如 Claude Code）自行管理压缩 |
 | 🔍 **智能模型匹配** | 自动处理模型名格式差异（日期后缀、dash/dot 版本号等） |
 | 🧠 **Thinking 思维链** | 自动为支持的模型启用深度思考（thinking/reasoning），提升代码质量 |
@@ -745,11 +745,11 @@ Anthropic 格式的模型名（如 `claude-opus-4-6`）和 Copilot 的模型列
 
 对上游 API 的请求内置了连接超时和智能重试，以最小化 Copilot 请求次数消耗：
 
-- **连接超时**：首次请求 120 秒，重试请求 90 秒（给模型足够的思考时间）
+- **连接超时**：首次请求 120 秒，重试请求 30 秒（响应头通常 3~5 秒到达）
 - **重试策略**：最多重试 2 次（共 3 次尝试），间隔 2-3 秒
 - **连接池重置**：首次网络错误后自动销毁所有连接并创建新实例，避免后续请求复用坏连接
-- **HTTP/2 保活**：启用 HTTP/2 协议，PING 帧穿透代理隧道防止空闲断连
-- **TCP 保活**：每 15 秒发送 TCP 探测包，防止代理/防火墙因空闲而断开连接
+- **代理隧道保活**：SSE 流传输期间每 45 秒发送一次轻量心跳请求，防止代理节点因空闲而杀断 CONNECT 隧道
+- **HTTP/2 支持**：启用 HTTP/2 协议，提升多路复用性能
 - 仅重试网络层错误（超时、TLS 断开、连接重置等），HTTP 错误码（如 400/500）不重试
 - SSE 流传输中断时，优雅地向客户端发送错误事件
 

package/dist/main.js

@@ -132,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 {
@@ -175,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);
@@ -1717,19 +1771,20 @@ const FETCH_TIMEOUT_MS = 12e4;
 * (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), and each retry may also be cut short by the same
-* timeout.  Keeping the delay short avoids wasting wall-clock time.
+* many proxy nodes).  Keeping the delay short avoids wasting wall-clock time.
 */
 const RETRY_DELAYS = [2e3, 3e3];
 /**
-* Timeout for retry attempts.  The first request uses the full
-* FETCH_TIMEOUT_MS (120 s) to accommodate slow models.  Retries also
-* need a generous timeout because the model restarts its thinking from
-* scratch — 20 s was too short and caused immediate failures.  90 s
-* gives the model enough time to produce a response while still failing
-* faster than the initial attempt if the network is truly down.
+* 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 = 9e4;
+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
@@ -1777,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();
 	}
 }