copilot-api-plus 1.0.55 → 1.0.57

package/dist/main.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import { n as ensurePaths, t as PATHS } from "./paths-BdbyVdad.js";
 import { t as state } from "./state-CRpaW-qc.js";
-import { c as githubHeaders, n as GITHUB_API_BASE_URL, o as copilotBaseUrl, s as copilotHeaders } from "./get-user-wlP5uMaW.js";
-import { n as forwardError, t as HTTPError } from "./error-BYsVGb6T.js";
-import { a as cacheModels, c as isNullish, i as setupGitHubToken, l as sleep, n as refreshCopilotToken, o as cacheVSCodeVersion, r as setupCopilotToken, s as findModel, t as clearGithubToken } from "./token-Bg5qiNBd.js";
-import { d as getValidAccessToken, g as rotateAccount, l as getCurrentProjectId, n as clearAntigravityAuth, o as getAntigravityAuthPath, r as disableCurrentAccount, s as getApiKey } from "./auth-D_mymhYC.js";
+import { c as githubHeaders, n as GITHUB_API_BASE_URL, o as copilotBaseUrl, s as copilotHeaders } from "./get-user-DOv07Myc.js";
+import { n as forwardError, t as HTTPError } from "./error-CvvAyU1E.js";
+import { a as cacheModels, c as isNullish, i as setupGitHubToken, l as sleep, n as refreshCopilotToken, o as cacheVSCodeVersion, r as setupCopilotToken, s as findModel, t as clearGithubToken } from "./token-D8U-wBLK.js";
+import { C as recordAccountFailure, _ as rotateAccount, f as getValidAccessToken, l as getCurrentAccountIndex, n as clearAntigravityAuth, o as getAntigravityAuthPath, r as disableCurrentAccount, s as getApiKey, u as getCurrentProjectId, w as recordAccountSuccess } from "./auth-C7a3n_4O.js";
 import { n as getZenAuthPath, t as clearZenAuth } from "./auth-DIDShcrD.js";
-import { n as getAntigravityUsage, r as isThinkingModel, t as getAntigravityModels } from "./get-models-DhYpjJVG.js";
+import { n as getAntigravityUsage, r as isThinkingModel, t as getAntigravityModels } from "./get-models-DmIjteNk.js";
 import { createRequire } from "node:module";
 import { defineCommand, runMain } from "citty";
 import consola from "consola";
@@ -531,7 +531,7 @@ function initProxyFromEnv() {
 * Add a new Antigravity account via OAuth
 */
 async function addAccount() {
-	const { setupAntigravity, loadAntigravityAuth } = await import("./auth-DreFwlx2.js");
+	const { setupAntigravity, loadAntigravityAuth } = await import("./auth-BfBWPtWx.js");
 	const existingAuth = await loadAntigravityAuth();
 	if (existingAuth && existingAuth.accounts.length > 0) {
 		const enabledCount = existingAuth.accounts.filter((a) => a.enable).length;
@@ -543,7 +543,7 @@ async function addAccount() {
 * List all Antigravity accounts
 */
 async function listAccounts() {
-	const { loadAntigravityAuth } = await import("./auth-DreFwlx2.js");
+	const { loadAntigravityAuth } = await import("./auth-BfBWPtWx.js");
 	const auth = await loadAntigravityAuth();
 	if (!auth || auth.accounts.length === 0) {
 		consola.info("No Antigravity accounts configured");
@@ -564,7 +564,7 @@ async function listAccounts() {
 * Remove an Antigravity account by index
 */
 async function removeAccount(index) {
-	const { loadAntigravityAuth, saveAntigravityAuth } = await import("./auth-DreFwlx2.js");
+	const { loadAntigravityAuth, saveAntigravityAuth } = await import("./auth-BfBWPtWx.js");
 	const auth = await loadAntigravityAuth();
 	if (!auth || auth.accounts.length === 0) {
 		consola.error("No Antigravity accounts configured");
@@ -583,7 +583,7 @@ async function removeAccount(index) {
 * Clear all Antigravity accounts
 */
 async function clearAccounts() {
-	const { clearAntigravityAuth } = await import("./auth-DreFwlx2.js");
+	const { clearAntigravityAuth } = await import("./auth-BfBWPtWx.js");
 	if (await consola.prompt("Are you sure you want to remove all Antigravity accounts?", {
 		type: "confirm",
 		initial: false
@@ -1225,6 +1225,214 @@ function modelLogger() {
 	};
 }
 //#endregion
+//#region src/services/antigravity/background-detection.ts
+/**
+* Antigravity Background Detection
+*
+* Detects agent/background requests and optionally downgrades
+* expensive models to cheaper alternatives to preserve quota.
+*
+* Detection uses multi-signal scoring — not a single heuristic:
+*  1. Explicit header: X-Request-Type: background (definitive)
+*  2. tool_calls / tool role pattern (strong agent signal)
+*  3. High density of assistant messages (weak signal alone)
+*
+* Controlled by env var: ANTIGRAVITY_BACKGROUND_DOWNGRADE=1
+*/
+const BACKGROUND_DOWNGRADE_ENABLED = process.env.ANTIGRAVITY_BACKGROUND_DOWNGRADE === "1";
+/**
+* Score threshold for downgrade (0–1).
+* 0.6 means we need at least one strong signal.
+*/
+const AGENT_SCORE_THRESHOLD = .6;
+/**
+* Model downgrade mapping: expensive → cheaper
+*/
+const DOWNGRADE_MAP = {
+	"claude-sonnet-4-5": "gemini-2.5-flash",
+	"claude-sonnet-4-5-thinking": "gemini-2.5-flash-thinking",
+	"claude-opus-4-5-thinking": "claude-sonnet-4-5-thinking",
+	"gemini-2.5-pro": "gemini-2.5-flash",
+	"gemini-3-pro-high": "gemini-3-flash",
+	"gemini-3-pro-low": "gemini-3-flash"
+};
+/**
+* Multi-signal agent detection.
+*
+* Scores the request on a 0–1 scale:
+*  - Explicit header "X-Request-Type: background"  → 1.0 (instant)
+*  - Any message with tool_calls field             → +0.5
+*  - Any message with role "tool"                  → +0.4
+*  - assistant messages ≥ 60% of all messages      → +0.2
+*  - More than 6 total messages                    → +0.1
+*
+* Score ≥ 0.6 → treated as agent/background request.
+*/
+function detectAgent(messages, headers) {
+	const signals = [];
+	const requestType = headers?.get("x-request-type");
+	if (requestType === "background" || requestType === "agent") return {
+		isAgent: true,
+		score: 1,
+		signals: ["explicit-header"]
+	};
+	let score = 0;
+	const total = messages.length;
+	if (total === 0) return {
+		isAgent: false,
+		score: 0,
+		signals: []
+	};
+	if (messages.some((m) => m.tool_calls !== void 0 && m.tool_calls !== null)) {
+		score += .5;
+		signals.push("tool_calls");
+	}
+	if (messages.some((m) => m.role === "tool")) {
+		score += .4;
+		signals.push("tool-role");
+	}
+	const assistantCount = messages.filter((m) => m.role === "assistant").length;
+	if (total >= 3 && assistantCount / total >= .6) {
+		score += .2;
+		signals.push("high-assistant-density");
+	}
+	if (total > 6) {
+		score += .1;
+		signals.push("long-conversation");
+	}
+	return {
+		isAgent: score >= AGENT_SCORE_THRESHOLD,
+		score: Math.min(score, 1),
+		signals
+	};
+}
+/**
+* Optionally downgrade a model for background/agent requests.
+*
+* Returns the original model if:
+* - ANTIGRAVITY_BACKGROUND_DOWNGRADE is not "1"
+* - The request is not detected as agent/background
+* - No downgrade mapping exists for the model
+*/
+function maybeDowngradeModel(model, messages, headers) {
+	if (!BACKGROUND_DOWNGRADE_ENABLED) return model;
+	const result = detectAgent(messages, headers);
+	if (!result.isAgent) return model;
+	const downgraded = DOWNGRADE_MAP[model];
+	if (!downgraded) return model;
+	consola.info(`[background-detection] agent detected (score=${result.score.toFixed(2)}, signals=[${result.signals.join(",")}]), downgrading ${model} → ${downgraded}`);
+	return downgraded;
+}
+//#endregion
+//#region src/services/antigravity/circuit-breaker.ts
+const FAILURE_THRESHOLD = 3;
+const RESET_TIMEOUT_MS = 3e4;
+const HALF_OPEN_SUCCESS_THRESHOLD = 2;
+const CircuitState = {
+	CLOSED: "CLOSED",
+	OPEN: "OPEN",
+	HALF_OPEN: "HALF_OPEN"
+};
+const breakers = /* @__PURE__ */ new Map();
+function getOrCreate(family) {
+	const existing = breakers.get(family);
+	if (existing) return existing;
+	const fresh = {
+		state: CircuitState.CLOSED,
+		failureCount: 0,
+		successCount: 0,
+		lastFailureTime: 0
+	};
+	breakers.set(family, fresh);
+	return fresh;
+}
+function getModelFamily(model) {
+	if (model.includes("claude")) return "claude";
+	if (model.includes("gemini")) return "gemini";
+	return "other";
+}
+function canExecute(family) {
+	const breaker = getOrCreate(family);
+	switch (breaker.state) {
+		case CircuitState.CLOSED: return true;
+		case CircuitState.OPEN:
+			if (Date.now() - breaker.lastFailureTime >= RESET_TIMEOUT_MS) {
+				consola.info(`[circuit-breaker] ${family}: OPEN -> HALF_OPEN`);
+				breaker.state = CircuitState.HALF_OPEN;
+				breaker.successCount = 0;
+				return true;
+			}
+			return false;
+		case CircuitState.HALF_OPEN: return true;
+		default: return true;
+	}
+}
+function recordSuccess(family) {
+	const breaker = getOrCreate(family);
+	switch (breaker.state) {
+		case CircuitState.HALF_OPEN:
+			breaker.successCount++;
+			if (breaker.successCount >= HALF_OPEN_SUCCESS_THRESHOLD) {
+				consola.info(`[circuit-breaker] ${family}: HALF_OPEN -> CLOSED`);
+				breaker.state = CircuitState.CLOSED;
+				breaker.failureCount = 0;
+				breaker.successCount = 0;
+			}
+			break;
+		case CircuitState.CLOSED:
+			breaker.failureCount = 0;
+			break;
+		default: break;
+	}
+}
+function recordFailure(family) {
+	const breaker = getOrCreate(family);
+	breaker.failureCount++;
+	breaker.lastFailureTime = Date.now();
+	switch (breaker.state) {
+		case CircuitState.CLOSED:
+			if (breaker.failureCount >= FAILURE_THRESHOLD) {
+				consola.info(`[circuit-breaker] ${family}: CLOSED -> OPEN`);
+				breaker.state = CircuitState.OPEN;
+			}
+			break;
+		case CircuitState.HALF_OPEN:
+			consola.info(`[circuit-breaker] ${family}: HALF_OPEN -> OPEN`);
+			breaker.state = CircuitState.OPEN;
+			break;
+		default: break;
+	}
+}
+function getBackoffDelay(family, baseDelay) {
+	const breaker = breakers.get(family);
+	if (!breaker || breaker.failureCount === 0) return baseDelay;
+	const delay = baseDelay * Math.pow(2, breaker.failureCount - 1);
+	return Math.min(delay, 3e4);
+}
+function parseRetryDelay$3(errorText) {
+	try {
+		const errorData = JSON.parse(errorText);
+		const details = errorData.error?.details ?? [];
+		for (const detail of details) {
+			if (detail["@type"]?.includes("RetryInfo") && detail.retryDelay) {
+				const match = /(\d+(?:\.\d+)?)s/.exec(detail.retryDelay);
+				if (match) return Math.ceil(Number.parseFloat(match[1]) * 1e3);
+			}
+			if (detail.quotaResetDelay) {
+				const match = /(\d+(?:\.\d+)?)(?:ms|s)/.exec(detail.quotaResetDelay);
+				if (match) {
+					const value = Number.parseFloat(match[1]);
+					return detail.quotaResetDelay.includes("ms") ? Math.ceil(value) : Math.ceil(value * 1e3);
+				}
+			}
+		}
+		const message = errorData.error?.message ?? "";
+		const resetMatch = /quota will reset after (\d+(?:\.\d+)?)s/i.exec(message);
+		if (resetMatch) return Math.ceil(Number.parseFloat(resetMatch[1]) * 1e3);
+	} catch {}
+	return 500;
+}
+//#endregion
 //#region src/services/antigravity/stream-parser.ts
 /**
 * Create initial stream state
@@ -1582,12 +1790,17 @@ function createErrorResponse$1(message, type, status, details) {
 * Create chat completion with Antigravity or standard Gemini API
 * Priority: API Key > OAuth
 */
-async function createAntigravityChatCompletion(request) {
+async function createAntigravityChatCompletion(request, requestHeaders) {
+	const effectiveModel = maybeDowngradeModel(request.model, request.messages, requestHeaders);
+	const effectiveRequest = effectiveModel !== request.model ? {
+		...request,
+		model: effectiveModel
+	} : request;
 	const apiKey = getApiKey();
-	if (apiKey) return await createWithApiKey(request, apiKey);
+	if (apiKey) return await createWithApiKey(effectiveRequest, apiKey);
 	const accessToken = await getValidAccessToken();
 	if (!accessToken) return createErrorResponse$1("No valid authentication available. Please set GEMINI_API_KEY environment variable or run OAuth login.", "auth_error", 401);
-	return await createWithOAuth(request, accessToken);
+	return await createWithOAuth(effectiveRequest, accessToken);
 }
 /**
 * Create chat completion using API Key (standard Gemini API)
@@ -1602,7 +1815,7 @@ async function createWithApiKey(request, apiKey) {
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify(body)
 		});
-		if (!response.ok) return await handleApiError$1(response);
+		if (!response.ok) return (await handleApiError$1(response)).response;
 		return request.stream ? transformStreamResponse$1(response, request.model) : await transformNonStreamResponse$1(response, request.model);
 	} catch (error) {
 		consola.error("Gemini API request error:", error);
@@ -1612,29 +1825,63 @@ async function createWithApiKey(request, apiKey) {
 /**
 * Create chat completion using OAuth (Antigravity private API)
 * Note: Both Gemini and Claude models use the same endpoint and Gemini-style format
+*
+* Features:
+* - Circuit breaker per model family
+* - Retry with exponential backoff on 429/503
+* - Token refresh between attempts
 */
-async function createWithOAuth(request, accessToken) {
+const MAX_RETRIES$4 = 5;
+async function createWithOAuth(request, _initialAccessToken) {
 	const endpoint = request.stream ? ANTIGRAVITY_STREAM_URL : ANTIGRAVITY_NO_STREAM_URL;
 	const body = buildAntigravityRequestBody(request);
-	consola.debug(`Antigravity request to ${endpoint} with model ${request.model}`);
-	try {
-		const response = await fetch(endpoint, {
-			method: "POST",
-			headers: {
-				Host: ANTIGRAVITY_API_HOST,
-				"User-Agent": ANTIGRAVITY_USER_AGENT$1,
-				Authorization: `Bearer ${accessToken}`,
-				"Content-Type": "application/json",
-				"Accept-Encoding": "gzip"
-			},
-			body: JSON.stringify(body)
-		});
-		if (!response.ok) return await handleApiError$1(response);
-		return request.stream ? transformStreamResponse$1(response, request.model) : await transformNonStreamResponse$1(response, request.model);
-	} catch (error) {
-		consola.error("Antigravity request error:", error);
-		return createErrorResponse$1(`Request failed: ${String(error)}`, "request_error", 500);
+	const bodyString = JSON.stringify(body);
+	for (let attempt = 0; attempt <= MAX_RETRIES$4; attempt++) {
+		const family = getModelFamily(request.model);
+		if (!canExecute(family)) {
+			consola.warn(`[circuit-breaker] ${family} circuit OPEN, waiting for reset...`);
+			await sleep(1e3);
+			continue;
+		}
+		const accessToken = await getValidAccessToken();
+		if (!accessToken) return createErrorResponse$1("No valid Antigravity access token available.", "auth_error", 401);
+		try {
+			const response = await fetch(endpoint, {
+				method: "POST",
+				headers: {
+					Host: ANTIGRAVITY_API_HOST,
+					"User-Agent": ANTIGRAVITY_USER_AGENT$1,
+					Authorization: `Bearer ${accessToken}`,
+					"Content-Type": "application/json",
+					"Accept-Encoding": "gzip"
+				},
+				body: bodyString
+			});
+			if (response.ok) {
+				recordSuccess(family);
+				recordAccountSuccess(await getCurrentAccountIndex());
+				return request.stream ? transformStreamResponse$1(response, request.model) : await transformNonStreamResponse$1(response, request.model);
+			}
+			const errorResult = await handleApiError$1(response);
+			if (errorResult.shouldRetry && attempt < MAX_RETRIES$4) {
+				recordFailure(family);
+				recordAccountFailure(await getCurrentAccountIndex());
+				const backoffDelay = getBackoffDelay(family, errorResult.retryDelayMs);
+				consola.info(`Rate limited, retrying in ${backoffDelay}ms (attempt ${attempt + 1}/${MAX_RETRIES$4})`);
+				await sleep(backoffDelay);
+				continue;
+			}
+			return errorResult.response;
+		} catch (error) {
+			consola.error("Antigravity request error:", error);
+			if (attempt < MAX_RETRIES$4) {
+				await sleep(500);
+				continue;
+			}
+			return createErrorResponse$1(`Request failed: ${String(error)}`, "request_error", 500);
+		}
 	}
+	return createErrorResponse$1("Max retries exceeded", "api_error", 429);
 }
 /**
 * Handle API error response
@@ -1643,8 +1890,19 @@ async function handleApiError$1(response) {
 	const errorText = await response.text();
 	consola.error(`Antigravity error: ${response.status} ${errorText}`);
 	if (response.status === 403) await disableCurrentAccount();
-	if (response.status === 429 || response.status === 503) await rotateAccount();
-	return createErrorResponse$1(`Antigravity API error: ${response.status}`, "api_error", response.status, errorText);
+	if (response.status === 429 || response.status === 503) {
+		await rotateAccount();
+		return {
+			shouldRetry: true,
+			retryDelayMs: parseRetryDelay$3(errorText),
+			response: createErrorResponse$1(`Antigravity API error: ${response.status}`, "api_error", response.status, errorText)
+		};
+	}
+	return {
+		shouldRetry: false,
+		retryDelayMs: 0,
+		response: createErrorResponse$1(`Antigravity API error: ${response.status}`, "api_error", response.status, errorText)
+	};
 }
 /**
 * Generate request ID
@@ -1809,7 +2067,7 @@ function extractNonStreamContent(parts) {
 const app$1 = new Hono();
 app$1.post("/", async (c) => {
 	const body = await c.req.json();
-	const response = await createAntigravityChatCompletion(body);
+	const response = await createAntigravityChatCompletion(body, c.req.raw.headers);
 	const headers = new Headers(response.headers);
 	if (body.stream) return new Response(response.body, {
 		status: response.status,
@@ -2049,31 +2307,6 @@ function rotateEndpoint() {
 	consola.info(`Rotating endpoint: ${ANTIGRAVITY_ENDPOINTS[oldIndex]} → ${ANTIGRAVITY_ENDPOINTS[currentEndpointIndex]}`);
 }
 const ANTIGRAVITY_USER_AGENT = "antigravity/1.11.3 windows/amd64";
-const rateLimitTracker = {};
-function getModelFamily(model) {
-	if (model.includes("claude")) return "claude";
-	if (model.includes("gemini")) return "gemini";
-	return "other";
-}
-function trackRateLimit(model) {
-	const family = getModelFamily(model);
-	if (!rateLimitTracker[family]) rateLimitTracker[family] = {
-		lastLimitTime: 0,
-		consecutiveErrors: 0
-	};
-	rateLimitTracker[family].lastLimitTime = Date.now();
-	rateLimitTracker[family].consecutiveErrors++;
-}
-function clearRateLimitTracker(model) {
-	const family = getModelFamily(model);
-	if (rateLimitTracker[family]) rateLimitTracker[family].consecutiveErrors = 0;
-}
-function getBackoffDelay(model, baseDelay) {
-	const info = rateLimitTracker[getModelFamily(model)];
-	if (!info) return baseDelay;
-	const multiplier = Math.min(Math.pow(2, info.consecutiveErrors - 1), 60);
-	return Math.min(baseDelay * multiplier, 3e4);
-}
 /**
 * Extract text from system content (can be string or array)
 */
@@ -2243,18 +2476,29 @@ function createErrorResponse(type, message, status) {
 *
 * Features:
 * - Endpoint fallback (daily → prod)
-* - Per-model-family rate limit tracking
+* - Circuit breaker per model family (CLOSED/OPEN/HALF_OPEN)
 * - Exponential backoff for consecutive errors
 * - Smart retry for short delays (≤5s on same endpoint)
 */
 const MAX_RETRIES$3 = 5;
 const MAX_ENDPOINT_RETRIES = 2;
-async function executeAntigravityRequest(request) {
-	const body = buildGeminiRequest(request, await getCurrentProjectId());
+async function executeAntigravityRequest(request, requestHeaders) {
+	const effectiveModel = maybeDowngradeModel(request.model, request.messages, requestHeaders);
+	const effectiveRequest = effectiveModel !== request.model ? {
+		...request,
+		model: effectiveModel
+	} : request;
+	const body = buildGeminiRequest(effectiveRequest, await getCurrentProjectId());
 	let endpointRetries = 0;
 	for (let attempt = 0; attempt <= MAX_RETRIES$3; attempt++) {
+		const family = getModelFamily(effectiveRequest.model);
+		if (!canExecute(family)) {
+			consola.warn(`[circuit-breaker] ${family} circuit OPEN, waiting for reset...`);
+			await sleep(1e3);
+			continue;
+		}
 		const host = getCurrentHost();
-		const endpoint = request.stream ? getStreamUrl(host) : getNoStreamUrl(host);
+		const endpoint = effectiveRequest.stream ? getStreamUrl(host) : getNoStreamUrl(host);
 		const accessToken = await getValidAccessToken();
 		if (!accessToken) return createErrorResponse("authentication_error", "No valid Antigravity access token available.", 401);
 		try {
@@ -2270,13 +2514,16 @@ async function executeAntigravityRequest(request) {
 				body: JSON.stringify(body)
 			});
 			if (response.ok) {
-				clearRateLimitTracker(request.model);
-				return request.stream ? transformStreamResponse(response, request.model) : await transformNonStreamResponse(response, request.model);
+				recordSuccess(getModelFamily(effectiveRequest.model));
+				recordAccountSuccess(await getCurrentAccountIndex());
+				return effectiveRequest.stream ? transformStreamResponse(response, effectiveRequest.model) : await transformNonStreamResponse(response, effectiveRequest.model);
 			}
-			const errorResult = await handleApiError(response, request.model);
+			const errorResult = await handleApiError(response, effectiveRequest.model);
 			if (errorResult.shouldRetry && attempt < MAX_RETRIES$3) {
-				trackRateLimit(request.model);
-				const backoffDelay = getBackoffDelay(request.model, errorResult.retryDelayMs);
+				const family = getModelFamily(effectiveRequest.model);
+				recordFailure(family);
+				recordAccountFailure(await getCurrentAccountIndex());
+				const backoffDelay = getBackoffDelay(family, errorResult.retryDelayMs);
 				if (backoffDelay <= 5e3 || endpointRetries >= MAX_ENDPOINT_RETRIES) {
 					consola.info(`Rate limited, retrying in ${backoffDelay}ms (attempt ${attempt + 1}/${MAX_RETRIES$3})`);
 					await sleep(backoffDelay);
@@ -2304,38 +2551,8 @@ async function executeAntigravityRequest(request) {
 	}
 	return createErrorResponse("api_error", "Max retries exceeded", 429);
 }
-async function createAntigravityMessages(request) {
-	return antigravityQueue.enqueue(() => executeAntigravityRequest(request));
-}
-/**
-* Parse retry delay from error response
-* Supports multiple formats:
-* - RetryInfo.retryDelay: "3.5s"
-* - quotaResetDelay: "3000ms" or "3s"
-* - message: "Your quota will reset after 3s"
-*/
-function parseRetryDelay$3(errorText) {
-	try {
-		const errorData = JSON.parse(errorText);
-		const details = errorData.error?.details ?? [];
-		for (const detail of details) {
-			if (detail["@type"]?.includes("RetryInfo") && detail.retryDelay) {
-				const match = /(\d+(?:\.\d+)?)s/.exec(detail.retryDelay);
-				if (match) return Math.ceil(Number.parseFloat(match[1]) * 1e3);
-			}
-			if (detail.quotaResetDelay) {
-				const match = /(\d+(?:\.\d+)?)(?:ms|s)/.exec(detail.quotaResetDelay);
-				if (match) {
-					const value = Number.parseFloat(match[1]);
-					return detail.quotaResetDelay.includes("ms") ? Math.ceil(value) : Math.ceil(value * 1e3);
-				}
-			}
-		}
-		const message = errorData.error?.message ?? "";
-		const resetMatch = /quota will reset after (\d+(?:\.\d+)?)s/i.exec(message);
-		if (resetMatch) return Math.ceil(Number.parseFloat(resetMatch[1]) * 1e3);
-	} catch {}
-	return 500;
+async function createAntigravityMessages(request, requestHeaders) {
+	return antigravityQueue.enqueue(() => executeAntigravityRequest(request, requestHeaders));
 }
 /**
 * Handle API error response
@@ -2525,7 +2742,7 @@ antigravityMessagesRoute.post("/", async (c) => {
 	try {
 		const body = await c.req.json();
 		consola.debug("Antigravity message request:", body.model);
-		const response = await createAntigravityMessages(body);
+		const response = await createAntigravityMessages(body, c.req.raw.headers);
 		if (body.stream) {
 			const headers = new Headers();
 			headers.set("Content-Type", "text/event-stream");
@@ -3874,7 +4091,7 @@ async function runServer(options) {
 	} else if (options.antigravity) {
 		consola.info("Google Antigravity mode enabled");
 		state.antigravityMode = true;
-		const { loadAntigravityAuth, setupAntigravity, getCurrentAccount, hasApiKey, getApiKey, setOAuthCredentials } = await import("./auth-DreFwlx2.js");
+		const { loadAntigravityAuth, setupAntigravity, getCurrentAccount, hasApiKey, getApiKey, setOAuthCredentials } = await import("./auth-BfBWPtWx.js");
 		if (options.antigravityClientId && options.antigravityClientSecret) {
 			setOAuthCredentials(options.antigravityClientId, options.antigravityClientSecret);
 			consola.info("Using provided OAuth credentials from CLI");
@@ -3903,7 +4120,7 @@ async function runServer(options) {
 			}
 			if (!await getCurrentAccount() && !hasApiKey()) throw new Error("No enabled Antigravity accounts available");
 		}
-		const { getAntigravityModels } = await import("./get-models-PKzVxQmq.js");
+		const { getAntigravityModels } = await import("./get-models-DIOdRXYx.js");
 		const models = await getAntigravityModels();
 		state.antigravityModels = models;
 		consola.info(`Available Antigravity models: \n${models.data.map((model) => `- ${model.id}`).join("\n")}`);
@@ -3913,7 +4130,7 @@ async function runServer(options) {
 			state.githubToken = options.githubToken;
 			consola.info("Using provided GitHub token");
 			try {
-				const { getGitHubUser } = await import("./get-user-CtEiwKow.js");
+				const { getGitHubUser } = await import("./get-user-CGhBmkXO.js");
 				const user = await getGitHubUser();
 				consola.info(`Logged in as ${user.login}`);
 			} catch (error) {
@@ -3924,10 +4141,10 @@ async function runServer(options) {
 		try {
 			await setupCopilotToken();
 		} catch (error) {
-			const { HTTPError } = await import("./error-4DW6q2Mo.js");
+			const { HTTPError } = await import("./error-Djpro28X.js");
 			if (error instanceof HTTPError && error.response.status === 401) {
 				consola.error("Failed to get Copilot token - GitHub token may be invalid or Copilot access revoked");
-				const { clearGithubToken } = await import("./token-B_0VZjlS.js");
+				const { clearGithubToken } = await import("./token-CoKq3Guw.js");
 				await clearGithubToken();
 				consola.info("Please restart to re-authenticate");
 			}