copilot-api-plus 1.2.15 → 1.2.17

package/README.en.md

@@ -49,7 +49,7 @@ English | [简体中文](README.md)
 | 🛡️ **Network Resilience** | 120s 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 (reasoning_effort) with Anthropic adaptive/enabled mode auto-translation |
+| 🧠 **Thinking Chain** | Automatically enables deep thinking for supported models, improving code quality |
 
 ---
 
@@ -583,12 +583,12 @@ 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)
-- **Retry strategy**: Up to 2 retries (3 total attempts), 2-3 second delays
+- **Retry strategy**: Up to 1 retry (2 total attempts), 2-second delay. **Timeout errors are never retried** — a timeout means the request likely reached Copilot and a credit was already consumed
 - **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
-- Only retries network-layer errors (timeout, TLS disconnect, connection reset, etc.); HTTP error codes (e.g. 400/500) are not retried
+- Only retries network-layer connection errors (TLS disconnect, connection reset, etc.); timeout and HTTP error codes (e.g. 400/500) are not retried
 - SSE stream interruptions gracefully send error events to the client
 
 ---

package/README.md

@@ -50,7 +50,7 @@
 | 🛡️ **网络弹性** | 120s 连接超时 + 智能重试 + 流中断即时恢复 + 代理隧道保活（45s 心跳） |
 | ✂️ **上下文透传** | 全量透传上下文至上游 API，由客户端（如 Claude Code）自行管理压缩 |
 | 🔍 **智能模型匹配** | 自动处理模型名格式差异（日期后缀、dash/dot 版本号等） |
-| 🧠 **Thinking 思维链** | 自动为支持的模型启用深度思考（reasoning_effort），支持 Anthropic adaptive/enabled 模式自动转换 |
+| 🧠 **Thinking 思维链** | 自动为支持的模型启用深度思考，提升代码质量 |
 
 ---
 
@@ -746,12 +746,12 @@ Anthropic 格式的模型名（如 `claude-opus-4-6`）和 Copilot 的模型列
 对上游 API 的请求内置了连接超时和智能重试，以最小化 Copilot 请求次数消耗：
 
 - **连接超时**：首次请求 120 秒，重试请求 30 秒（响应头通常 3~5 秒到达）
-- **重试策略**：最多重试 2 次（共 3 次尝试），间隔 2-3 秒
+- **重试策略**：最多重试 1 次（共 2 次尝试），间隔 2 秒，**超时错误不重试**（超时意味着请求已到达 Copilot，额度已消耗）
 - **流中断即时恢复**：SSE 流中断时立刻销毁连接池，下一个请求使用全新连接，恢复时间从 ~135 秒降至几秒
 - **连接池重置**：首次网络错误后自动销毁所有连接并创建新实例，避免后续请求复用坏连接
 - **代理隧道保活**：SSE 流传输期间每 45 秒发送一次轻量心跳请求，防止代理节点因空闲而杀断 CONNECT 隧道
 - **HTTP/2 支持**：启用 HTTP/2 协议，提升多路复用性能
-- 仅重试网络层错误（超时、TLS 断开、连接重置等），HTTP 错误码（如 400/500）不重试
+- 仅重试网络层连接错误（TLS 断开、连接重置等），超时和 HTTP 错误码（如 400/500）不重试
 - SSE 流传输中断时，优雅地向客户端发送错误事件
 
 ---

package/dist/main.js

@@ -1768,12 +1768,14 @@ 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 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.
+* (see `resetConnections`), so retries use fresh sockets.
+*
+* We only allow 1 retry (2 total attempts) to minimize credit waste.
+* Timeout errors are NOT retried at all — they indicate the request likely
+* reached Copilot (consuming a credit) and the upstream is slow or the
+* proxy killed the connection mid-flight.
 */
-const RETRY_DELAYS = [2e3, 3e3];
+const RETRY_DELAYS = [2e3];
 /**
 * Timeout for retry attempts (waiting for response headers only).
 * Response headers typically arrive within 3–5 s, even on slow models.
@@ -1820,6 +1822,11 @@ async function fetchWithRetry(url, buildInit) {
 		return await fetchWithTimeout(url, buildInit(), timeout);
 	} catch (error) {
 		lastError = error;
+		const msg = error instanceof Error ? error.message : String(error);
+		if (msg.includes("timed out")) {
+			consola.warn(`Request timed out on attempt ${attempt + 1}/${maxAttempts} — not retrying (credit likely consumed):`, msg);
+			break;
+		}
 		if (attempt === 0) resetConnections();
 		if (attempt < maxAttempts - 1) {
 			const delay = RETRY_DELAYS[attempt];
@@ -1856,6 +1863,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.
 */
@@ -1885,7 +1899,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.
@@ -1898,16 +1914,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: client-specified (reasoning_effort=${original.reasoning_effort ?? "none"} / thinking_budget=${original.thinking_budget ?? "none"})`);
+	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) => {
@@ -1927,10 +1944,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;
@@ -1952,6 +1983,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) {