copilot-api-plus 1.3.0 → 1.3.2

package/dist/main.js

@@ -3209,6 +3209,39 @@ function normalizeAdaptiveThinkingForCopilot(payload) {
 	}
 }
 /**
+* If the client did not specify a `thinking` field, inject the maximum
+* thinking budget the model supports — pulled from Copilot's `/models`
+* capabilities. Mutates in place.
+*
+*   - Models with `adaptive_thinking: true` (claude-opus-4.7,
+*     claude-sonnet-4.6) get `{ type: "adaptive" }` so the model
+*     decides depth dynamically — recommended by Anthropic for
+*     these models.
+*   - Other thinking-capable models get
+*     `{ type: "enabled", budget_tokens: max_thinking_budget }`.
+*   - Models without thinking capability are left untouched.
+*
+* Skipped if the client already specified `thinking` (any value) — we
+* always defer to explicit client intent.
+*/
+function injectMaxThinkingBudget(payload) {
+	if (payload.thinking !== void 0) return;
+	const supports = findModel(payload.model)?.capabilities.supports;
+	if (!supports) return;
+	const maxBudget = supports.max_thinking_budget;
+	if (!maxBudget || maxBudget <= 0) return;
+	if (supports.adaptive_thinking === true) {
+		payload.thinking = { type: "adaptive" };
+		consola.debug(`Injected adaptive thinking for ${payload.model} (no client preference)`);
+		return;
+	}
+	payload.thinking = {
+		type: "enabled",
+		budget_tokens: maxBudget
+	};
+	consola.debug(`Injected enabled thinking budget=${maxBudget} for ${payload.model} (no client preference)`);
+}
+/**
 * Remove all `thinking` and `redacted_thinking` blocks from assistant
 * messages, and drop any assistant turns left empty as a result.
 *
@@ -3253,6 +3286,7 @@ function stripAssistantThinkingBlocks(payload) {
 /** Detect the upstream "invalid thinking signature" 400 to trigger retry. */
 async function isInvalidThinkingSignatureError(error) {
 	if (!(error instanceof HTTPError) || error.response.status !== 400) return false;
+	if (INVALID_THINKING_SIGNATURE_PATTERN.test(error.message)) return true;
 	const message = await readUpstreamErrorMessage(error.response);
 	return typeof message === "string" && INVALID_THINKING_SIGNATURE_PATTERN.test(message);
 }
@@ -3315,12 +3349,21 @@ function looksLikeClaudeModel(model) {
 /** Per-process cache of the routing decision keyed by model id. */
 const routeCache = /* @__PURE__ */ new Map();
 /**
+* Endpoint identifiers that mean "native Anthropic /v1/messages".
+*
+* Copilot's `/models` response uses the literal `/v1/messages` path,
+* but jer-y/copilot-proxy and earlier Copilot betas used the symbolic
+* name `anthropic-messages`. Accept both so we are forward- and
+* backward-compatible with whichever wire format Copilot returns.
+*/
+const NATIVE_ANTHROPIC_ENDPOINT_IDS = new Set(["/v1/messages", "anthropic-messages"]);
+/**
 * Resolve the upstream route for an Anthropic /v1/messages payload.
 *
 * Order of precedence:
 *   1. User force-disabled native passthrough — always translate.
-*   2. Model advertises `anthropic-messages` in supported_endpoints → native.
-*   3. Model advertises supported_endpoints WITHOUT anthropic-messages → translate.
+*   2. Model advertises a native Anthropic endpoint → native.
+*   3. Model advertises supported_endpoints WITHOUT a native one → translate.
 *   4. Capability missing → fall back to name heuristic (claude-* → native).
 */
 function resolveAnthropicRoute(model) {
@@ -3333,7 +3376,7 @@ function resolveAnthropicRoute(model) {
 }
 function decideRoute(model) {
 	const endpoints = findModel(model)?.supported_endpoints;
-	if (Array.isArray(endpoints) && endpoints.length > 0) return endpoints.includes("anthropic-messages") ? "native-anthropic" : "translate-openai";
+	if (Array.isArray(endpoints) && endpoints.length > 0) return endpoints.some((ep) => NATIVE_ANTHROPIC_ENDPOINT_IDS.has(ep)) ? "native-anthropic" : "translate-openai";
 	return looksLikeClaudeModel(model) ? "native-anthropic" : "translate-openai";
 }
 
@@ -3384,13 +3427,20 @@ function buildAnthropicHeaders(payload, source, options$1) {
 	};
 }
 async function createAnthropicMessages(payload, options$1) {
-	sanitizeForCopilotBackend(payload);
-	normalizeAdaptiveThinkingForCopilot(payload);
+	injectMaxThinkingBudget(payload);
+	const preStripped = stripAssistantThinkingBlocks(payload);
+	let workingPayload = payload;
+	if (preStripped.stripped) {
+		consola.debug(`Pre-stripped ${preStripped.strippedBlocks} assistant thinking block(s) from history (Copilot/Vertex does not accept replay)`);
+		workingPayload = preStripped.payload;
+	}
+	sanitizeForCopilotBackend(workingPayload);
+	normalizeAdaptiveThinkingForCopilot(workingPayload);
 	try {
-		return await dispatchAnthropicRequest(payload, options$1);
+		return await dispatchAnthropicRequest(workingPayload, options$1);
 	} catch (error) {
 		if (!await isInvalidThinkingSignatureError(error)) throw error;
-		const stripped = stripAssistantThinkingBlocks(payload);
+		const stripped = stripAssistantThinkingBlocks(workingPayload);
 		if (!stripped.stripped) throw error;
 		const droppedSuffix = stripped.droppedAssistantMessages > 0 ? ` and dropping ${stripped.droppedAssistantMessages} thinking-only assistant turn(s)` : "";
 		consola.warn(`Native /v1/messages signature retry: stripped ${stripped.strippedBlocks} thinking block(s)${droppedSuffix}`);