pi-antigravity-rotator 1.3.4 → 1.3.6

package/README.md

@@ -148,7 +148,7 @@ Three mechanisms trigger rotation, scoped to the specific model:
 
 1. **Quota-based** (primary) -- Polls the Google quota API every 5 minutes. When a model's remaining quota drops by `rotateOnQuotaDrop` percentage points (default: 20%), that model rotates to the next account. Other models stay on their current accounts.
 
-2. **Request-count** (fallback) -- After `requestsPerRotation` successful requests (default: 5), the rotator asks for a rotation on the model that served that request. By default this fallback is only used when quota data for that model is still unknown.
+2. **Request-count** (fallback) -- Before forwarding a request, the rotator checks how many requests the current account has already served for that specific model and rotates once it reaches `requestsPerRotation` (default: 5). By default this fallback is only used when quota data for that model is still unknown.
 
 3. **429 failover** (reactive) -- On rate limit, the account is marked exhausted with a parsed retry cooldown and the affected model immediately switches.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-antigravity-rotator",
-  "version": "1.3.4",
+  "version": "1.3.6",
   "description": "Multi-account rotation proxy for Google Antigravity with per-model routing, real-time quota tracking, and infringement detection",
   "license": "MIT",
   "type": "module",

package/src/proxy.ts

@@ -86,6 +86,23 @@ function capCooldown(ms: number): number {
 	return Math.min(ms, MAX_COOLDOWN_MS);
 }
 
+function formatError(err: unknown): string {
+	if (!(err instanceof Error)) return String(err);
+	const cause = err.cause;
+	if (cause && typeof cause === "object") {
+		const code = "code" in cause ? String(cause.code) : null;
+		const message = "message" in cause ? String(cause.message) : null;
+		if (code || message) {
+			return `${err.name}: ${err.message} (${[code, message].filter(Boolean).join(": ")})`;
+		}
+	}
+	return `${err.name}: ${err.message}`;
+}
+
+function isFetchTransportError(err: unknown): boolean {
+	return err instanceof TypeError && err.message === "fetch failed";
+}
+
 /**
  * Read the full request body from an IncomingMessage.
  */
@@ -319,8 +336,11 @@ async function handleProxyRequest(
 				}
 				return;
 			} catch (err) {
-				proxyLog(`[${label}] Request failed: ${err}`, "error");
-				rotator.markError(account, err instanceof Error ? err.message : String(err));
+				const formattedError = formatError(err);
+				proxyLog(`[${label}] Request failed: ${formattedError}`, isFetchTransportError(err) ? "warn" : "error");
+				if (!isFetchTransportError(err)) {
+					rotator.markError(account, formattedError);
+				}
 			if (res.headersSent) {
 				res.end();
 				return;

package/src/rotator.ts

@@ -78,6 +78,7 @@ export class AccountRotator {
 					this.modelState.set(model, {
 						activeAccountIndex: Math.min(idx, this.accounts.length - 1),
 						quotaAtRotationStart: -1,
+						requestsOnActiveAccount: 0,
 					});
 				}
 			}
@@ -369,6 +370,29 @@ export class AccountRotator {
 		return best;
 	}
 
+	private countModelAssignment(modelKey: string): void {
+		const state = this.modelState.get(modelKey);
+		if (state) {
+			state.requestsOnActiveAccount++;
+		}
+	}
+
+	private shouldRotateBeforeRequest(account: AccountRuntime, modelKey: string, state: ModelRotationState | null): boolean {
+		return (
+			!!state &&
+			this.shouldUseRequestCountRotation(account, modelKey) &&
+			state.requestsOnActiveAccount >= this.config.requestsPerRotation
+		);
+	}
+
+	private async rotateModelForRequest(modelKey: string, now: number = Date.now(), excludeIdx?: number): Promise<AccountRuntime | null> {
+		const account = await this.rotateModel(modelKey, now, excludeIdx);
+		if (account) {
+			this.countModelAssignment(modelKey);
+		}
+		return account;
+	}
+
 	// =========================================================================
 	// Account Selection (per-model)
 	// =========================================================================
@@ -388,12 +412,26 @@ export class AccountRotator {
 		if (current && this.isAvailable(current, now)) {
 			// Check if this account has quota for the requested model
 			if (modelKey) {
+				if (this.shouldRotateBeforeRequest(current, modelKey, state ?? null)) {
+					this.log(
+						`${current.config.label || current.config.email} [${modelKey}]: hit rotation threshold (${this.config.requestsPerRotation})`,
+					);
+					const rotated = await this.rotateModelForRequest(modelKey, now, idx);
+					if (rotated) {
+						current.requestsSinceRotation = 0;
+						return rotated;
+					}
+					this.log(
+						`${current.config.label || current.config.email} [${modelKey}]: threshold reached but no replacement is available, staying`,
+						"warn",
+					);
+				}
 				const quota = this.getModelQuota(current, modelKey);
 				if (quota === 0) {
 					this.log(
 						`${current.config.label || current.config.email} [${modelKey}]: 0% quota, skipping`,
 					);
-					return this.rotateModel(modelKey);
+					return this.rotateModelForRequest(modelKey);
 				}
 				if (!this.isFreshWindowAllowed(current, modelKey)) {
 					const label = current.config.label || current.config.email;
@@ -403,12 +441,13 @@ export class AccountRotator {
 							: `${label} [${modelKey}]: fresh window blocked by operator toggle`,
 						"warn",
 					);
-					return this.rotateModel(modelKey);
+					return this.rotateModelForRequest(modelKey);
 				}
 			}
 			this.startRequest(current);
 			try {
 				await this.ensureValidToken(current);
+				if (modelKey) this.countModelAssignment(modelKey);
 				return current;
 			} catch (err) {
 				this.finishRequest(current);
@@ -418,7 +457,7 @@ export class AccountRotator {
 
 		// Current unavailable, or no per-model assignment yet
 		if (modelKey) {
-			return this.rotateModel(modelKey, now, state ? idx : -1);
+			return this.rotateModelForRequest(modelKey, now, state ? idx : -1);
 		}
 		return this.rotateDefault();
 	}
@@ -438,6 +477,7 @@ export class AccountRotator {
 			this.modelState.set(modelKey, {
 				activeAccountIndex: newIdx,
 				quotaAtRotationStart: quota,
+				requestsOnActiveAccount: 0,
 			});
 			this.log(
 				`[${modelKey}] Rotated to ${best.config.label || best.config.email} [${timerType}] (quota: ${quota >= 0 ? quota + "%" : "unknown"})`,
@@ -540,17 +580,8 @@ export class AccountRotator {
 		account.consecutiveErrors = 0;
 		account.lastError = null;
 
-		const shouldRotate =
-			this.shouldUseRequestCountRotation(account, model) &&
-			account.requestsSinceRotation >= this.config.requestsPerRotation;
-		if (shouldRotate) {
-			account.requestsSinceRotation = 0;
-			this.log(
-				`${account.config.label || account.config.email}: hit rotation threshold (${this.config.requestsPerRotation})`,
-			);
-		}
 		this.saveState();
-		return shouldRotate;
+		return false;
 	}
 
 	// Mark an account as exhausted (429 or quota exceeded)

package/src/types.ts

@@ -117,6 +117,7 @@ export interface AccountRuntime {
 export interface ModelRotationState {
 	activeAccountIndex: number;
 	quotaAtRotationStart: number; // quota % when this account became active for this model
+	requestsOnActiveAccount: number;
 }
 
 // Persisted state across restarts