copilot-api-plus 1.4.8 → 1.4.9

package/dist/main.js

@@ -2763,9 +2763,19 @@ async function handleMultiAccountHttpError(error, account, retryContext) {
 			consola.warn(`Account ${account.label}: 401, refreshing token...`);
 			return tryRefreshAndRetry(account, retryContext.payload, retryContext.tokenSource);
 		case 403:
+			if (!retryContext.hasOtherAccount) {
+				consola.warn(`Account ${account.label}: 403 — only account, propagating to client without marking`);
+				error.__nonAccountError = true;
+				return null;
+			}
 			accountManager.markAccountStatus(account.id, "banned", "403 Forbidden");
 			return null;
 		case 429:
+			if (!retryContext.hasOtherAccount) {
+				consola.warn(`Account ${account.label}: 429 — only account, propagating to client without marking`);
+				error.__nonAccountError = true;
+				return null;
+			}
 			accountManager.markAccountStatus(account.id, "rate_limited", "429 Rate limited");
 			return null;
 		case 408:
@@ -2880,7 +2890,8 @@ async function createWithMultiAccount$1(payload) {
 			if (error instanceof HTTPError) {
 				const retryResult = await handleMultiAccountHttpError(error, account, {
 					payload,
-					tokenSource
+					tokenSource,
+					hasOtherAccount: hasAnotherAccountToTry(triedAccountIds)
 				});
 				if (retryResult) return retryResult;
 				if (error.__nonAccountError) throw error;
@@ -3779,9 +3790,9 @@ async function createWithMultiAccount(payload, options$1) {
 		} catch (error) {
 			lastError = error;
 			if (error instanceof HTTPError) {
-				if (error.response.status === 401) return handleMultiAccount401(ctx, account);
-				if (error.response.status >= 400 && error.response.status < 500) throw error;
-				consola.warn(`Account ${account.label}: 5xx from /v1/messages${hasAnotherAnthropicAccountToTry(triedAccountIds) ? ", trying next account" : " — no other accounts available, propagating error"}`);
+				const action = handleAnthropicHttpError(error, account, triedAccountIds);
+				if (action === "refresh401") return handleMultiAccount401(ctx, account);
+				if (action === "throw") throw error;
 				continue;
 			}
 			const errMsg = error.message || String(error);
@@ -3800,6 +3811,35 @@ async function createWithMultiAccount(payload, options$1) {
 	throw new Error("No available accounts");
 }
 /**
+* Decide what to do for an HTTP error from a multi-account request attempt.
+*
+* Returns:
+*  - "refresh401" — caller should run the 401-refresh-and-retry flow
+*  - "throw"      — caller should rethrow the error to the client
+*  - "continue"   — caller should try the next account
+*
+* Single-account guard: marking the only account as rate_limited / banned
+* would disable the proxy entirely, so 429 / 403 are propagated unchanged
+* to the client when no other account is available.
+*/
+function handleAnthropicHttpError(error, account, triedAccountIds) {
+	const status = error.response.status;
+	if (status === 401) return "refresh401";
+	if (status === 429 || status === 403) {
+		const isRateLimit = status === 429;
+		if (hasAnotherAnthropicAccountToTry(triedAccountIds)) {
+			accountManager.markAccountStatus(account.id, isRateLimit ? "rate_limited" : "banned", isRateLimit ? "429 Rate limited" : "403 Forbidden");
+			consola.warn(`Account ${account.label}: ${status} on /v1/messages, trying next account`);
+			return "continue";
+		}
+		consola.warn(`Account ${account.label}: ${status} on /v1/messages — only account, propagating to client without marking`);
+		return "throw";
+	}
+	if (status >= 400 && status < 500) return "throw";
+	consola.warn(`Account ${account.label}: 5xx from /v1/messages${hasAnotherAnthropicAccountToTry(triedAccountIds) ? ", trying next account" : " — no other accounts available, propagating error"}`);
+	return "continue";
+}
+/**
 * Peek at whether `getActiveAccount()` would return an untried account on the
 * next iteration. Used purely for honest log messaging — doesn't affect
 * routing.
@@ -4133,37 +4173,30 @@ async function handleCompletion(c) {
 	if (state.manualApprove) await awaitApproval();
 	const route = resolveAnthropicRoute(anthropicPayload.model);
 	consola.debug(`Anthropic route resolved: ${route}`);
-	if (route === "native-anthropic" && !nativeBlockedModels.has(anthropicPayload.model)) return handleNativePassthrough(c, anthropicPayload);
+	if (route === "native-anthropic") return handleNativePassthrough(c, anthropicPayload);
 	return handleTranslatedCompletion(c, anthropicPayload);
 }
-/**
-* Models whose native /v1/messages path returned an unrecoverable upstream
-* policy error (e.g. Vertex AI's `structured_outputs` GCP org policy).
-* Once added, future requests for that model skip the native path and go
-* straight to the translated /chat/completions path.
-*
-* Cleared on process restart — so a fixed Copilot routing self-heals.
-*/
-const nativeBlockedModels = /* @__PURE__ */ new Set();
-const VERTEX_STRUCTURED_OUTPUTS_PATTERN = /vertexai\.allowedPartnerModelFeatures.*?structured_outputs/i;
-function isVertexStructuredOutputsBlock(error) {
-	const message = error instanceof Error ? error.message : String(error);
-	return VERTEX_STRUCTURED_OUTPUTS_PATTERN.test(message);
-}
 async function handleNativePassthrough(c, anthropicPayload) {
 	const anthropicBeta = c.req.header("anthropic-beta");
+	const sanitized = injectIntoAnthropicPayload(stripSystemReminders(anthropicPayload));
 	let result;
 	try {
-		result = await createAnthropicMessages(injectIntoAnthropicPayload(stripSystemReminders(anthropicPayload)), { anthropicBeta });
+		result = await createAnthropicMessages(sanitized, { anthropicBeta });
 	} catch (error) {
-		if (isVertexStructuredOutputsBlock(error)) {
-			const firstHit = !nativeBlockedModels.has(anthropicPayload.model);
-			nativeBlockedModels.add(anthropicPayload.model);
-			if (firstHit) consola.debug(`Native /v1/messages blocked by Vertex GCP policy for "${anthropicPayload.model}" — falling back to translated path (cached for this process)`);
-			return handleTranslatedCompletion(c, anthropicPayload);
+		const message = error.message || String(error);
+		if (/vertexai\.allowedPartnerModelFeatures.*?structured_outputs/i.test(message)) {
+			consola.debug(`Native /v1/messages: Vertex GCP policy 400, retrying once (Copilot will likely route to Anthropic-direct)`);
+			try {
+				result = await createAnthropicMessages(sanitized, { anthropicBeta });
+			} catch (retryError) {
+				const retryMessage = retryError.message || String(retryError);
+				consola.warn(`Native /v1/messages: Vertex GCP policy 400 on both attempts, propagating to client: ${retryMessage}`);
+				throw retryError;
+			}
+		} else {
+			consola.warn(`Native /v1/messages failed: ${message}`);
+			throw error;
 		}
-		consola.warn(`Native /v1/messages failed: ${error.message || String(error)}`);
-		throw error;
 	}
 	if (!anthropicPayload.stream) return c.json(overrideAnthropicResponseModel(result, anthropicPayload.model));
 	const stream = result;