copilot-api-plus 1.2.8 → 1.2.10

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 + exponential backoff retry (2s/5s/10s) |
+| 🛡️ **Network Resilience** | 120s connection timeout + smart retry (pool reset + HTTP/2 keepalive + proxy optimization) |
 | ✂️ **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 |
@@ -580,10 +580,13 @@ Each API request outputs a log line with model name, status code, and duration:
 
 ### Network Resilience
 
-Built-in connection timeout and exponential backoff retry for upstream API requests:
+Built-in connection timeout and smart retry for upstream API requests, minimizing Copilot request credit consumption:
 
-- **Connection timeout**: 120 seconds (AbortController-based)
-- **Retry strategy**: Up to 3 retries (4 total attempts), exponential backoff: 2s → 5s → 10s
+- **Connection timeout**: 120 seconds for the first attempt, 90 seconds for retries (enough time for model thinking)
+- **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
 - 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 连接超时 + 指数退避重试（2s/5s/10s） |
+| 🛡️ **网络弹性** | 120s 连接超时 + 智能重试（连接池重置 + HTTP/2 保活 + 代理穿透优化） |
 | ✂️ **上下文透传** | 全量透传上下文至上游 API，由客户端（如 Claude Code）自行管理压缩 |
 | 🔍 **智能模型匹配** | 自动处理模型名格式差异（日期后缀、dash/dot 版本号等） |
 | 🧠 **Thinking 思维链** | 自动为支持的模型启用深度思考（thinking/reasoning），提升代码质量 |
@@ -743,10 +743,13 @@ Anthropic 格式的模型名（如 `claude-opus-4-6`）和 Copilot 的模型列
 
 ### 网络弹性
 
-对上游 API 的请求内置了连接超时和指数退避重试：
+对上游 API 的请求内置了连接超时和智能重试，以最小化 Copilot 请求次数消耗：
 
-- **连接超时**：120 秒（AbortController 实现）
-- **重试策略**：最多重试 3 次（共 4 次尝试），指数退避间隔 2s → 5s → 10s
+- **连接超时**：首次请求 120 秒，重试请求 90 秒（给模型足够的思考时间）
+- **重试策略**：最多重试 2 次（共 3 次尝试），间隔 2-3 秒
+- **连接池重置**：首次网络错误后自动销毁所有连接并创建新实例，避免后续请求复用坏连接
+- **HTTP/2 保活**：启用 HTTP/2 协议，PING 帧穿透代理隧道防止空闲断连
+- **TCP 保活**：每 15 秒发送 TCP 探测包，防止代理/防火墙因空闲而断开连接
 - 仅重试网络层错误（超时、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,9 +121,14 @@ async function applyProxyConfig() {
 //#endregion
 //#region src/lib/proxy.ts
 const agentOptions = {
-	keepAliveTimeout: 3e4,
-	keepAliveMaxTimeout: 6e4,
-	connect: { timeout: 15e3 }
+	keepAliveTimeout: 3e5,
+	keepAliveMaxTimeout: 6e5,
+	allowH2: true,
+	connect: {
+		timeout: 15e3,
+		keepAlive: true,
+		keepAliveInitialDelay: 15e3
+	}
 };
 let direct;
 let proxies = /* @__PURE__ */ new Map();
@@ -1709,19 +1714,22 @@ 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), and each retry may also be cut short by the same
+* timeout.  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.  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.
 */
-const RETRY_TIMEOUT_MS = 2e4;
+const RETRY_TIMEOUT_MS = 9e4;
 /**
 * Wrapper around `fetch()` that aborts if the server doesn't respond within
 * `timeoutMs`.  The timeout only covers the period until the response headers
@@ -3090,14 +3098,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");
 		}