copilot-api-plus 1.2.16 → 1.2.17

package/dist/main.js

@@ -1863,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.
 */
@@ -1892,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.
@@ -1905,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: 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) => {
@@ -1934,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;
@@ -1959,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) {