copilot-api-plus 1.2.11 → 1.2.13

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 timeout + smart retry + proxy tunnel keepalive (45s heartbeat) |
+| 🛡️ **Network Resilience** | 60s timeout + smart retry + instant stream recovery + 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,8 +582,9 @@ 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, 30 seconds for retries (headers typically arrive in 3–5s)
+- **Connection timeout**: 60 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
+- **Instant stream recovery**: On SSE stream interruption, immediately destroys the connection pool so the next request uses fresh sockets — recovery drops from ~135s to seconds
 - **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

package/README.md

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

package/dist/main.js

@@ -1763,9 +1763,9 @@ async function checkRateLimit(state) {
 /**
 * Timeout for the initial HTTP connection + headers (not the body/stream).
 * Copilot's slow models (e.g. claude-opus) can take up to ~60s to start
-* streaming, so we give 120s for the connection phase.
+* streaming, so we give 60s for the connection phase.
 */
-const FETCH_TIMEOUT_MS = 12e4;
+const FETCH_TIMEOUT_MS = 6e4;
 /**
 * Retry delays in ms.  After the first failure the connection pool is reset
 * (see `resetConnections`), so retries use fresh sockets.  We allow up to
@@ -1836,11 +1836,16 @@ async function fetchWithRetry(url, buildInit) {
 */
 async function* wrapGeneratorWithRelease(gen, releaseSlot) {
 	notifyStreamStart();
+	let streamError = false;
 	try {
 		yield* gen;
+	} catch (error) {
+		streamError = true;
+		throw error;
 	} finally {
 		notifyStreamEnd();
 		releaseSlot();
+		if (streamError) resetConnections();
 	}
 }
 /**
@@ -1865,18 +1870,29 @@ function getThinkingBudget(model) {
 	return Math.max(upperBound, lowerBound);
 }
 /**
+* Check whether tool_choice forces tool use (not "auto" or "none").
+* Thinking/reasoning cannot be enabled when tool_choice forces a tool.
+*/
+function isToolChoiceForced(toolChoice) {
+	if (!toolChoice) return false;
+	if (toolChoice === "auto" || toolChoice === "none") return false;
+	return true;
+}
+/**
 * Inject thinking parameters into the payload based on model capabilities.
 *
 * Strategy (in priority order):
 *   1. If the client already set reasoning_effort or thinking_budget → keep as-is
-*   2. If model capabilities declare max_thinking_budget → inject thinking_budget
-*   3. Otherwise → inject reasoning_effort="high" (works on claude-*-4.6)
+*   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)
 *
 * The fallback to reasoning_effort ensures thinking works even when the
 * /models endpoint doesn't expose thinking budget fields.
 */
 function injectThinking(payload, resolvedModel) {
 	if (payload.reasoning_effort || payload.thinking_budget) return payload;
+	if (isToolChoiceForced(payload.tool_choice)) return payload;
 	const budget = getThinkingBudget(findModel(resolvedModel));
 	if (budget) return {
 		...payload,
@@ -2159,6 +2175,7 @@ async function handleCompletion$1(c) {
 		} catch (error) {
 			const message = error.message || String(error);
 			consola.warn(`SSE stream interrupted: ${message}`);
+			resetConnections();
 		}
 	});
 }
@@ -2433,6 +2450,8 @@ function mapOpenAIStopReasonToAnthropic(finishReason) {
 //#endregion
 //#region src/routes/messages/non-stream-translation.ts
 function translateToOpenAI(payload) {
+	const toolChoice = translateAnthropicToolChoiceToOpenAI(payload.tool_choice);
+	const isForced = Boolean(toolChoice) && toolChoice !== "auto" && toolChoice !== "none";
 	return {
 		model: translateModelName(payload.model),
 		messages: translateAnthropicMessagesToOpenAI(payload.messages, payload.system),
@@ -2443,10 +2462,10 @@ function translateToOpenAI(payload) {
 		top_p: payload.top_p,
 		user: payload.metadata?.user_id,
 		tools: translateAnthropicToolsToOpenAI(payload.tools),
-		tool_choice: translateAnthropicToolChoiceToOpenAI(payload.tool_choice),
-		...payload.thinking && { thinking: payload.thinking },
-		...payload.thinking?.type === "enabled" && { reasoning_effort: "high" },
-		...payload.thinking?.budget_tokens && { thinking_budget: payload.thinking.budget_tokens }
+		tool_choice: toolChoice,
+		...!isForced && payload.thinking && { thinking: payload.thinking },
+		...!isForced && payload.thinking?.type === "enabled" && { reasoning_effort: "high" },
+		...!isForced && payload.thinking?.budget_tokens && { thinking_budget: payload.thinking.budget_tokens }
 	};
 }
 function translateModelName(model) {
@@ -2914,6 +2933,7 @@ async function handleCompletion(c) {
 		} catch (error) {
 			const message = error.message || String(error);
 			consola.warn(`SSE stream interrupted: ${message}`);
+			resetConnections();
 			try {
 				const errorEvent = translateErrorToAnthropicErrorEvent();
 				await stream.writeSSE({