anypick 1.0.0

package/dist/providers/gemini-proxy/server.js

@@ -0,0 +1,1240 @@
+import { writeJsonFile } from "../../utils/fs.js";
+import { assertLoopbackHost } from "../../utils/network.js";
+import { withFileLock } from "../../utils/lock.js";
+import { QuotaGuard } from "../quota-guard.js";
+import { readGeminiApiKeyFromEnvFile } from "../gemini-env.js";
+import { loadAntigravityOAuthCredentials } from "../gemini-antigravity-oauth.js";
+import { compareGeminiModelIds, resolveGeminiModel } from "../protocol/gemini/translate-models.js";
+import { reasoningFromAnthropic, reasoningFromOpenAI } from "../reasoning.js";
+import { geminiToOpenAI, openAIToGemini } from "../protocol/gemini/translate-chat.js";
+import { geminiToOpenAIResponses, openAIResponsesToGemini } from "../protocol/gemini/translate-responses.js";
+import { anthropicToGemini, geminiToAnthropic } from "../protocol/gemini/translate-anthropic.js";
+import { normalizeLocalApiUrl, readBody, requireProxyAuth } from "../proxy-shared.js";
+import { CooldownRegistry, classifyUpstreamFailure, isCredentialQuotaFailure } from "../upstream-policy.js";
+import "../gemini.js";
+import { join } from "node:path";
+import { readFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { createServer } from "node:http";
+//#region src/providers/gemini-proxy/server.ts
+/**
+* Dual-protocol reverse proxy: OpenAI + Anthropic → Google Gemini API.
+*
+*   Codex  OPENAI_BASE_URL     → POST /v1/responses (and chat/completions)
+*   Claude ANTHROPIC_BASE_URL  → POST /v1/messages
+*
+* Auth: GEMINI_API_KEY (or GOOGLE_API_KEY) from snapshot .env / live path.
+* Upstream: generativelanguage.googleapis.com (generateContent).
+*/
+var COMPAT_LABEL = "OpenAI + Anthropic → Gemini API";
+var DEFAULT_UPSTREAM = "https://generativelanguage.googleapis.com";
+var CODE_ASSIST_UPSTREAM = "https://cloudcode-pa.googleapis.com";
+var ANTIGRAVITY_CODE_ASSIST_UPSTREAM = "https://daily-cloudcode-pa.googleapis.com";
+var OAUTH_CLIENT_ID = "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com";
+var OAUTH_CLIENT_SECRET = "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";
+var ANTIGRAVITY_OAUTH_CLIENT_ID = "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com";
+var ANTIGRAVITY_OAUTH_CLIENT_SECRET = "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";
+var MODEL_CATALOG_TTL_MS = 10 * 6e4;
+var MODEL_CATALOG_FAILURE_TTL_MS = 6e4;
+function isAuthEntitlementRejection(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return /(?:HTTP\s*)?\b(?:401|403)\b|unauthorized|forbidden|permission denied/i.test(message);
+}
+function reasoningIntentToModelEffort(intent) {
+	if (intent.budgetTokens != null) return;
+	if (intent.enabled === false) return "minimal";
+	return intent.effort ?? (intent.enabled === true ? "medium" : void 0);
+}
+function createGeminiProxyServer(opts) {
+	assertLoopbackHost(opts.host);
+	const upstream = (opts.upstream ?? DEFAULT_UPSTREAM).replace(/\/$/, "");
+	const oauthSource = opts.oauthSource ?? "auto";
+	const proxyToken = opts.token ?? process.env.ANYPICK_PROXY_TOKEN ?? "";
+	const oauthProfile = (source) => source === "antigravity" ? {
+		clientId: process.env.ANTIGRAVITY_OAUTH_CLIENT_ID?.trim() || ANTIGRAVITY_OAUTH_CLIENT_ID,
+		clientSecret: process.env.ANTIGRAVITY_OAUTH_CLIENT_SECRET?.trim() || ANTIGRAVITY_OAUTH_CLIENT_SECRET,
+		ideType: "ANTIGRAVITY",
+		userAgent: "antigravity/hub/2.3.1 (aidev_client)"
+	} : {
+		clientId: OAUTH_CLIENT_ID,
+		clientSecret: OAUTH_CLIENT_SECRET,
+		ideType: "GEMINI_CLI"
+	};
+	const codeAssistBase = (source) => (opts.codeAssistUpstream ?? (source === "antigravity" ? ANTIGRAVITY_CODE_ASSIST_UPSTREAM : CODE_ASSIST_UPSTREAM)).replace(/\/$/, "");
+	const log = opts.log ?? (opts.quiet ? () => {} : (line) => process.stderr.write(`${line}\n`));
+	/** Ordered API keys; Quota Guard may promote a healthy pool account. */
+	let keyRing = [];
+	const oauthStates = /* @__PURE__ */ new Map();
+	const oauthRefreshInflight = /* @__PURE__ */ new Map();
+	const modelCatalogs = /* @__PURE__ */ new Map();
+	const modelCatalogInflight = /* @__PURE__ */ new Map();
+	const modelCatalogFailures = /* @__PURE__ */ new Map();
+	/**
+	* Keep a proven auto-auth route sticky for this process. Without this, every
+	* model-list poll starts at Gemini CLI again even after its account returned
+	* 401/403 and Antigravity served the request successfully.
+	*/
+	let autoActiveRoute;
+	const proxySessionId = randomUUID();
+	const cooldowns = new CooldownRegistry();
+	const quotaGuard = new QuotaGuard(opts.quotaGuard ?? {
+		enabled: false,
+		cooldownMs: 60 * 6e4
+	});
+	const server = createServer((req, res) => {
+		handle(req, res);
+	});
+	async function loadKeyRing() {
+		if (opts.apiKey?.trim()) return [{ key: opts.apiKey.trim() }];
+		if (keyRing.length) return keyRing;
+		const dirs = opts.authDirs && opts.authDirs.length > 0 ? opts.authDirs : [opts.authDir];
+		const keys = [];
+		for (const [index, dir] of dirs.entries()) {
+			const k = await readGeminiApiKeyFromEnvFile(dir.endsWith(".env") ? dir : join(dir, ".env"));
+			if (k && !keys.some((candidate) => candidate.key === k)) keys.push({
+				key: k,
+				accountName: opts.authAccountNames?.[index]
+			});
+		}
+		if (keys.length === 0) {
+			const envKey = process.env.GEMINI_API_KEY?.trim() || process.env.GOOGLE_API_KEY?.trim();
+			if (envKey) keys.push({ key: envKey });
+		}
+		if (keys.length === 0) throw new Error(`No GEMINI_API_KEY in auth dir(s). Save an API-key Gemini login, or set GEMINI_API_KEY.`);
+		keyRing = keys;
+		return keys;
+	}
+	async function currentKey() {
+		const keys = await loadKeyRing();
+		return (await quotaGuard.ordered(keys))[0] ?? keys[0];
+	}
+	function oauthState(source) {
+		const existing = oauthStates.get(source);
+		if (existing) return existing;
+		const created = { project: opts.oauthProject };
+		oauthStates.set(source, created);
+		return created;
+	}
+	async function loadOAuthCredentials(source) {
+		const state = oauthState(source);
+		if (state.credentials !== void 0) return state.credentials;
+		if (source === "antigravity") {
+			state.credentials = await loadAntigravityOAuthCredentials(opts.antigravityOAuthFile);
+			return state.credentials;
+		}
+		const file = join(opts.authDir, "oauth_creds.json");
+		try {
+			const parsed = JSON.parse(await readFile(file, "utf8"));
+			state.credentials = parsed.refresh_token || parsed.access_token ? parsed : null;
+		} catch {
+			state.credentials = null;
+		}
+		return state.credentials;
+	}
+	/** Respect the Gemini CLI's selected auth mode; a stale .env must not beat OAuth. */
+	async function geminiCliRoute() {
+		const credentials = await loadOAuthCredentials("gemini-cli");
+		if (credentials && !opts.apiKey) try {
+			const raw = await readFile(join(opts.authDir, "auth-settings.json"), "utf8");
+			if (JSON.parse(raw).security?.auth?.selectedType === "oauth-personal") return "gemini-cli";
+		} catch {
+			return "gemini-cli";
+		}
+		try {
+			await currentKey();
+			return "api-key";
+		} catch {
+			if (credentials) return "gemini-cli";
+			throw new Error("No usable Gemini CLI OAuth or API-key credential was found.");
+		}
+	}
+	function activateAutoRoute(route, reason) {
+		if (oauthSource !== "auto" || autoActiveRoute === route) return;
+		autoActiveRoute = route;
+		log(`  auth auto: active route=${route} (${reason})`);
+	}
+	function resetAutoRoute(route, reason) {
+		if (oauthSource !== "auto" || autoActiveRoute !== route) return;
+		autoActiveRoute = void 0;
+		log(`  auth auto: reset route=${route} (${reason})`);
+	}
+	async function authRoutes(includeAntigravity) {
+		if (oauthSource === "gemini-cli") return [await geminiCliRoute()];
+		if (oauthSource === "antigravity") {
+			if (!await loadOAuthCredentials("antigravity")) throw new Error("No Antigravity OAuth credentials found in the OS keychain.");
+			return ["antigravity"];
+		}
+		if (autoActiveRoute === "antigravity") try {
+			if (await loadOAuthCredentials("antigravity")) return ["antigravity"];
+			resetAutoRoute("antigravity", "credentials unavailable");
+		} catch (err) {
+			resetAutoRoute("antigravity", err instanceof Error ? err.message : "credentials unavailable");
+		}
+		const routes = [];
+		try {
+			routes.push(await geminiCliRoute());
+		} catch (err) {
+			log(`  auth auto: Gemini CLI unavailable (${err instanceof Error ? err.message : String(err)})`);
+		}
+		if (includeAntigravity) {
+			if (opts.codeAssistUpstream && !opts.antigravityOAuthFile) {
+				if (routes.length === 0) throw new Error("Antigravity auto-discovery is disabled for a custom Code Assist endpoint; provide antigravityOAuthFile.");
+				return [...new Set(routes)];
+			}
+			try {
+				if (await loadOAuthCredentials("antigravity")) routes.push("antigravity");
+			} catch (err) {
+				log(`  auth auto: Antigravity unavailable (${err instanceof Error ? err.message : String(err)})`);
+			}
+		}
+		if (routes.length === 0 && !includeAntigravity) return authRoutes(true);
+		if (routes.length === 0) throw new Error("No usable Gemini CLI or Antigravity credential was found.");
+		return [...new Set(routes)];
+	}
+	async function currentOAuthToken(source) {
+		const credentials = await loadOAuthCredentials(source);
+		if (!credentials) throw new Error(source === "antigravity" ? "No Antigravity OAuth credentials found in the OS keychain." : "No Gemini OAuth credentials found in oauth_creds.json.");
+		if (!(!credentials.expiry_date || credentials.expiry_date < Date.now() + 6e4) && credentials.access_token) return credentials.access_token;
+		if (!credentials.refresh_token) throw new Error("Gemini OAuth access token expired and no refresh token is available.");
+		const existing = oauthRefreshInflight.get(source);
+		if (existing) return existing;
+		const refresh = refreshOAuthToken(source, credentials).finally(() => {
+			oauthRefreshInflight.delete(source);
+		});
+		oauthRefreshInflight.set(source, refresh);
+		return refresh;
+	}
+	async function refreshOAuthToken(source, initial) {
+		const refresh = async (credentials) => {
+			if (!credentials.refresh_token) throw new Error("Gemini OAuth access token expired and no refresh token is available.");
+			const state = oauthState(source);
+			const response = await fetch("https://oauth2.googleapis.com/token", {
+				method: "POST",
+				headers: { "content-type": "application/x-www-form-urlencoded" },
+				body: new URLSearchParams({
+					client_id: oauthProfile(source).clientId,
+					client_secret: oauthProfile(source).clientSecret,
+					refresh_token: credentials.refresh_token,
+					grant_type: "refresh_token"
+				}),
+				signal: AbortSignal.timeout(3e4)
+			});
+			const body = await response.json().catch(() => ({}));
+			if (!response.ok || !body.access_token) throw new GeminiUpstreamError(response.status || 401, response.headers, body.error_description || body.error || "Gemini OAuth refresh failed");
+			const refreshed = {
+				...credentials,
+				access_token: body.access_token,
+				token_type: body.token_type ?? credentials.token_type ?? "Bearer",
+				expiry_date: Date.now() + (body.expires_in ?? 3600) * 1e3
+			};
+			state.credentials = refreshed;
+			if (source === "gemini-cli") await writeJsonFile(join(opts.authDir, "oauth_creds.json"), refreshed, 384);
+			return refreshed.access_token;
+		};
+		if (source !== "gemini-cli") return refresh(initial);
+		const authPath = join(opts.authDir, "oauth_creds.json");
+		return withFileLock(`${authPath}.refresh.lock`, async () => {
+			const state = oauthState(source);
+			state.credentials = void 0;
+			const latest = await loadOAuthCredentials(source);
+			if (!latest) throw new Error("No Gemini OAuth credentials found in oauth_creds.json.");
+			if (!(!latest.expiry_date || latest.expiry_date < Date.now() + 6e4) && latest.access_token) return latest.access_token;
+			if (!latest.refresh_token) throw new Error("Gemini OAuth access token expired and no refresh token is available.");
+			return refresh(latest);
+		}, { resource: `Gemini OAuth refresh ${authPath}` });
+	}
+	async function resolveOAuthProject(source, token) {
+		const state = oauthState(source);
+		const profile = oauthProfile(source);
+		if (state.project) return state.project;
+		const response = await fetch(`${codeAssistBase(source)}/v1internal:loadCodeAssist`, {
+			method: "POST",
+			headers: {
+				authorization: `Bearer ${token}`,
+				"content-type": "application/json",
+				...profile.userAgent ? { "user-agent": profile.userAgent } : {}
+			},
+			body: JSON.stringify({ metadata: profile.ideType === "ANTIGRAVITY" ? { ideType: profile.ideType } : {
+				ideType: profile.ideType,
+				platform: process.platform === "darwin" ? "DARWIN_ARM64" : "PLATFORM_UNSPECIFIED",
+				pluginType: "GEMINI"
+			} }),
+			signal: AbortSignal.timeout(3e4)
+		});
+		const body = await response.json().catch(() => ({}));
+		if (!response.ok) throw new GeminiUpstreamError(response.status, response.headers, body.error?.message ?? `Code Assist loadCodeAssist HTTP ${response.status}`);
+		state.project = body.cloudaicompanionProject || void 0;
+		log(`  OAuth ${source} tier=${body.currentTier?.id ?? "unknown"} project=${state.project ?? "managed"}`);
+		return state.project;
+	}
+	async function refreshModelCatalog(route) {
+		const existing = modelCatalogInflight.get(route);
+		if (existing) return existing;
+		const inflight = (async () => {
+			let catalog;
+			if (route !== "api-key") {
+				const token = await currentOAuthToken(route);
+				const project = await resolveOAuthProject(route, token);
+				const profile = oauthProfile(route);
+				catalog = await listGeminiModelsFromCodeAssist(codeAssistBase(route), token, project, log, profile.userAgent);
+			} else catalog = { models: (await listGeminiModelsFromGoogle(upstream, (await currentKey()).key, log)).map((id) => ({ id })) };
+			catalog = {
+				...catalog,
+				models: catalog.models.toSorted((a, b) => compareGeminiModelIds(a.id, b.id))
+			};
+			modelCatalogs.set(route, {
+				value: catalog,
+				fetchedAt: Date.now()
+			});
+			modelCatalogFailures.delete(route);
+			log(`  list models ← ${catalog.models.length} auth=${route}`);
+			return catalog;
+		})().catch((error) => {
+			modelCatalogFailures.set(route, {
+				error,
+				fetchedAt: Date.now()
+			});
+			resetAutoRoute(route, "model catalog unavailable");
+			throw error;
+		}).finally(() => {
+			modelCatalogInflight.delete(route);
+		});
+		modelCatalogInflight.set(route, inflight);
+		return inflight;
+	}
+	async function liveModelCatalog(route) {
+		const cached = modelCatalogs.get(route);
+		if (cached && Date.now() - cached.fetchedAt < MODEL_CATALOG_TTL_MS) return cached.value;
+		const failed = modelCatalogFailures.get(route);
+		if (failed && Date.now() - failed.fetchedAt < MODEL_CATALOG_FAILURE_TTL_MS) throw failed.error;
+		return refreshModelCatalog(route);
+	}
+	async function resolveRequestModel(requested, effort) {
+		const primaryRoutes = await authRoutes(false);
+		let passthrough;
+		let lastError;
+		let primaryEntitlementRejected = false;
+		for (const route of primaryRoutes) try {
+			const catalog = await liveModelCatalog(route);
+			const resolution = resolveGeminiModel(requested, catalog, effort);
+			if (isCatalogResolution(resolution, catalog)) return {
+				...resolution,
+				route
+			};
+			passthrough ??= {
+				...resolution,
+				route
+			};
+		} catch (err) {
+			lastError = err;
+			if (route !== "antigravity" && isAuthEntitlementRejection(err)) primaryEntitlementRejected = true;
+			const resolution = resolveGeminiModel(requested, [], effort);
+			if (resolution.id) passthrough ??= {
+				...resolution,
+				route
+			};
+		}
+		if (oauthSource === "auto" && !opts.apiKey) {
+			const fallbackRoutes = (await authRoutes(true)).filter((route) => !primaryRoutes.includes(route));
+			for (const route of fallbackRoutes) try {
+				const catalog = await liveModelCatalog(route);
+				const resolution = resolveGeminiModel(requested, catalog, effort);
+				if (route === "antigravity" && primaryEntitlementRejected) activateAutoRoute(route, "Gemini CLI entitlement rejected");
+				if (isCatalogResolution(resolution, catalog)) {
+					log(`  auth auto: ${requested ?? "(default)"} resolved via ${route}`);
+					return {
+						...resolution,
+						route
+					};
+				}
+				if (primaryEntitlementRejected && resolution.id) passthrough = {
+					...resolution,
+					route
+				};
+				else passthrough ??= {
+					...resolution,
+					route
+				};
+			} catch (err) {
+				lastError = err;
+			}
+		}
+		if (passthrough?.id) {
+			if (lastError) log(`  model catalog unavailable; forwarding ${passthrough.id} unchanged (${lastError instanceof Error ? lastError.message : String(lastError)})`);
+			return passthrough;
+		}
+		throw lastError ?? /* @__PURE__ */ new Error("No model could be discovered for the available credentials.");
+	}
+	async function handle(req, res) {
+		const path = normalizeLocalApiUrl(req.url ?? "/").split("?")[0] ?? "/";
+		const method = req.method ?? "GET";
+		if (!checkCors(req, res)) return;
+		if (method === "OPTIONS") {
+			res.writeHead(204);
+			res.end();
+			return;
+		}
+		if ((method === "GET" || method === "HEAD") && (path === "/" || path === "/health")) {
+			json(res, 200, {
+				ok: true,
+				service: "anypick-gemini-proxy",
+				compatibility: COMPAT_LABEL,
+				instanceId: process.env.ANYPICK_INSTANCE_ID ?? null,
+				auth: "ok",
+				clients: {
+					codex: "OPENAI_BASE_URL → /v1/responses",
+					claude: "ANTHROPIC_BASE_URL → /v1/messages"
+				},
+				endpoints: {
+					openai: [
+						"/v1/chat/completions",
+						"/v1/responses",
+						"/v1/models"
+					],
+					anthropic: ["/v1/messages"]
+				},
+				oauthSource,
+				upstream
+			});
+			return;
+		}
+		if (method === "GET" && path === "/v1/models") {
+			if (!requireProxyAuth(req, res, proxyToken)) return;
+			await handleListModels(res);
+			return;
+		}
+		if (method === "POST" && path === "/v1/chat/completions") {
+			if (!requireProxyAuth(req, res, proxyToken)) return;
+			await handleOpenAI(req, res);
+			return;
+		}
+		if (method === "POST" && path === "/v1/responses") {
+			if (!requireProxyAuth(req, res, proxyToken)) return;
+			await handleResponses(req, res);
+			return;
+		}
+		if (method === "POST" && path === "/v1/messages") {
+			if (!requireProxyAuth(req, res, proxyToken)) return;
+			await handleAnthropic(req, res);
+			return;
+		}
+		json(res, 404, { error: {
+			message: `Not found: ${path}. Codex: /v1/responses · Claude: /v1/messages`,
+			type: "not_found_error"
+		} });
+	}
+	/** List only models discovered for the active API-key/OAuth account. */
+	async function handleListModels(res) {
+		try {
+			const routes = await authRoutes(oauthSource === "auto" && !opts.apiKey);
+			const discovered = [];
+			let lastError;
+			let primaryEntitlementRejected = false;
+			for (const route of routes) try {
+				const catalog = await liveModelCatalog(route);
+				discovered.push({
+					route,
+					catalog
+				});
+				if (route === "antigravity" && primaryEntitlementRejected) activateAutoRoute(route, "Gemini CLI entitlement rejected");
+			} catch (err) {
+				lastError = err;
+				if (route !== "antigravity" && isAuthEntitlementRejection(err)) primaryEntitlementRejected = true;
+				log(`  list models auth=${route} failed; trying next source`);
+			}
+			if (discovered.length === 0) throw lastError ?? /* @__PURE__ */ new Error("No auth source returned a Gemini model catalog.");
+			const models = /* @__PURE__ */ new Map();
+			for (const { route, catalog } of discovered) for (const descriptor of catalog.models) if (!models.has(descriptor.id)) models.set(descriptor.id, {
+				descriptor,
+				route
+			});
+			json(res, 200, {
+				object: "list",
+				data: [...models.values()].map(({ descriptor, route }) => {
+					const value = {
+						id: descriptor.id,
+						object: "model",
+						owned_by: route === "api-key" ? "google" : "google-code-assist"
+					};
+					if (descriptor.displayName) value.display_name = descriptor.displayName;
+					return value;
+				})
+			});
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			log(`  list models ✗ ${msg}`);
+			json(res, 502, { error: {
+				message: `Failed to list Gemini models from Google: ${msg}`,
+				type: "proxy_error"
+			} });
+		}
+	}
+	async function handleOpenAI(req, res) {
+		log("POST /v1/chat/completions → Gemini");
+		try {
+			const raw = await readBody(req);
+			let body;
+			try {
+				body = JSON.parse(raw.toString("utf8") || "{}");
+			} catch {
+				json(res, 400, { error: {
+					message: "Invalid JSON body",
+					type: "invalid_request_error"
+				} });
+				return;
+			}
+			const modelEffort = reasoningIntentToModelEffort(reasoningFromOpenAI(body));
+			const resolution = await resolveRequestModel(body.model, modelEffort);
+			if (!resolution.id) {
+				json(res, 400, { error: {
+					message: "model is required and no model could be discovered for this account",
+					type: "invalid_request_error"
+				} });
+				return;
+			}
+			const model = resolution.id;
+			if (resolution.remapped) log(`  model ${body.model ?? "(empty)"} → ${model} (${resolution.reason ?? "catalog"}${modelEffort ? `, effort=${modelEffort}` : ""})`);
+			const geminiBody = openAIToGemini(body, model);
+			if (body.stream) {
+				const result = await callGeminiWithAutoFallback(body.model, resolution, geminiBody, false, modelEffort);
+				const responseModel = result.resolution.id;
+				const openai = geminiToOpenAI(result.response, responseModel);
+				if (openai.error) {
+					json(res, 502, openai);
+					return;
+				}
+				res.writeHead(200, {
+					"content-type": "text/event-stream; charset=utf-8",
+					"cache-control": "no-cache",
+					connection: "keep-alive"
+				});
+				const content = openai.choices?.[0]?.message?.content ?? "";
+				const reasoning = openai.choices?.[0]?.message?.reasoning_content ?? "";
+				if (reasoning) res.write(`data: ${JSON.stringify({
+					id: openai.id,
+					object: "chat.completion.chunk",
+					model: responseModel,
+					choices: [{
+						index: 0,
+						delta: {
+							role: "assistant",
+							reasoning_content: reasoning
+						},
+						finish_reason: null
+					}]
+				})}\n\n`);
+				res.write(`data: ${JSON.stringify({
+					id: openai.id,
+					object: "chat.completion.chunk",
+					model: responseModel,
+					choices: [{
+						index: 0,
+						delta: {
+							role: "assistant",
+							content
+						},
+						finish_reason: null
+					}]
+				})}\n\n`);
+				res.write(`data: ${JSON.stringify({
+					id: openai.id,
+					object: "chat.completion.chunk",
+					model: responseModel,
+					choices: [{
+						index: 0,
+						delta: {},
+						finish_reason: "stop"
+					}]
+				})}\n\n`);
+				res.write("data: [DONE]\n\n");
+				res.end();
+				return;
+			}
+			const result = await callGeminiWithAutoFallback(body.model, resolution, geminiBody, false, modelEffort);
+			const openai = geminiToOpenAI(result.response, result.resolution.id);
+			if (openai.error) {
+				json(res, 502, openai);
+				return;
+			}
+			json(res, 200, openai);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			log(`  ✗ ${msg}`);
+			writeGeminiError(res, err, msg);
+		}
+	}
+	async function handleAnthropic(req, res) {
+		log("POST /v1/messages → Gemini");
+		try {
+			const raw = await readBody(req);
+			let body;
+			try {
+				body = JSON.parse(raw.toString("utf8") || "{}");
+			} catch {
+				json(res, 400, {
+					type: "error",
+					error: {
+						type: "invalid_request_error",
+						message: "Invalid JSON body"
+					}
+				});
+				return;
+			}
+			if (!body.model) {
+				json(res, 400, {
+					type: "error",
+					error: {
+						type: "invalid_request_error",
+						message: "model is required"
+					}
+				});
+				return;
+			}
+			if (body.max_tokens == null) body.max_tokens = 4096;
+			const modelEffort = reasoningIntentToModelEffort(reasoningFromAnthropic(body));
+			const resolution = await resolveRequestModel(body.model, modelEffort);
+			if (!resolution.id) {
+				json(res, 400, {
+					type: "error",
+					error: {
+						type: "invalid_request_error",
+						message: "No matching Gemini model is available for this account."
+					}
+				});
+				return;
+			}
+			if (resolution.remapped) log(`  model ${body.model} → ${resolution.id} (${resolution.reason ?? "catalog"}${modelEffort ? `, effort=${modelEffort}` : ""})`);
+			const { gemini } = anthropicToGemini(body, resolution.id);
+			const result = await callGeminiWithAutoFallback(body.model, resolution, gemini, false, modelEffort);
+			const responseModel = result.resolution.id;
+			const anthropic = geminiToAnthropic(result.response, responseModel);
+			if ("type" in anthropic && anthropic.type === "error") {
+				json(res, 502, anthropic);
+				return;
+			}
+			if (body.stream) {
+				const msg = anthropic;
+				res.writeHead(200, {
+					"content-type": "text/event-stream; charset=utf-8",
+					"cache-control": "no-cache",
+					connection: "keep-alive"
+				});
+				writeSse(res, "message_start", {
+					type: "message_start",
+					message: {
+						id: msg.id ?? `msg_${Date.now()}`,
+						type: "message",
+						role: "assistant",
+						model: responseModel,
+						content: [],
+						stop_reason: null,
+						stop_sequence: null,
+						usage: {
+							input_tokens: msg.usage?.input_tokens ?? 0,
+							output_tokens: 0
+						}
+					}
+				});
+				msg.content.forEach((block, index) => {
+					if (block.type === "thinking") {
+						writeSse(res, "content_block_start", {
+							type: "content_block_start",
+							index,
+							content_block: {
+								type: "thinking",
+								thinking: "",
+								signature: ""
+							}
+						});
+						if (block.thinking) writeSse(res, "content_block_delta", {
+							type: "content_block_delta",
+							index,
+							delta: {
+								type: "thinking_delta",
+								thinking: block.thinking
+							}
+						});
+						if (block.signature) writeSse(res, "content_block_delta", {
+							type: "content_block_delta",
+							index,
+							delta: {
+								type: "signature_delta",
+								signature: block.signature
+							}
+						});
+					} else if (block.type === "tool_use") {
+						writeSse(res, "content_block_start", {
+							type: "content_block_start",
+							index,
+							content_block: {
+								type: "tool_use",
+								id: block.id,
+								name: block.name,
+								input: {},
+								...block.thought_signature ? { thought_signature: block.thought_signature } : {}
+							}
+						});
+						writeSse(res, "content_block_delta", {
+							type: "content_block_delta",
+							index,
+							delta: {
+								type: "input_json_delta",
+								partial_json: JSON.stringify(block.input ?? {})
+							}
+						});
+					} else if (block.type === "redacted_thinking") writeSse(res, "content_block_start", {
+						type: "content_block_start",
+						index,
+						content_block: block
+					});
+					else {
+						writeSse(res, "content_block_start", {
+							type: "content_block_start",
+							index,
+							content_block: {
+								type: "text",
+								text: ""
+							}
+						});
+						if (block.text) writeSse(res, "content_block_delta", {
+							type: "content_block_delta",
+							index,
+							delta: {
+								type: "text_delta",
+								text: block.text
+							}
+						});
+					}
+					writeSse(res, "content_block_stop", {
+						type: "content_block_stop",
+						index
+					});
+				});
+				writeSse(res, "message_delta", {
+					type: "message_delta",
+					delta: {
+						stop_reason: msg.stop_reason,
+						stop_sequence: msg.stop_sequence
+					},
+					usage: { output_tokens: msg.usage?.output_tokens ?? 0 }
+				});
+				writeSse(res, "message_stop", { type: "message_stop" });
+				res.end();
+				return;
+			}
+			json(res, 200, anthropic);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			log(`  ✗ ${msg}`);
+			writeGeminiError(res, err, msg, true);
+		}
+	}
+	async function handleResponses(req, res) {
+		log("POST /v1/responses → Gemini");
+		try {
+			const raw = await readBody(req);
+			let body;
+			try {
+				body = JSON.parse(raw.toString("utf8") || "{}");
+			} catch {
+				json(res, 400, { error: {
+					message: "Invalid JSON body",
+					type: "invalid_request_error"
+				} });
+				return;
+			}
+			const modelEffort = reasoningIntentToModelEffort(reasoningFromOpenAI(body));
+			const resolution = await resolveRequestModel(body.model, modelEffort);
+			if (!resolution.id) {
+				json(res, 400, { error: {
+					message: "model is required and no model could be discovered for this account",
+					type: "invalid_request_error"
+				} });
+				return;
+			}
+			if (resolution.remapped) log(`  model ${body.model ?? "(empty)"} → ${resolution.id} (${resolution.reason ?? "catalog"}${modelEffort ? `, effort=${modelEffort}` : ""})`);
+			const geminiBody = openAIResponsesToGemini(body, resolution.id);
+			const result = await callGeminiWithAutoFallback(body.model, resolution, geminiBody, false, modelEffort);
+			const response = geminiToOpenAIResponses(result.response, result.resolution.id);
+			if (body.stream) {
+				writeOpenAIResponsesStream(res, response);
+				return;
+			}
+			json(res, 200, response);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			log(`  ✗ ${msg}`);
+			writeGeminiError(res, err, msg);
+		}
+	}
+	async function callGeminiWithAutoFallback(requested, resolution, body, stream, effort) {
+		try {
+			return {
+				response: await callGemini(resolution.route, resolution.id, body, stream),
+				resolution
+			};
+		} catch (err) {
+			if (resolution.route === "antigravity" && err instanceof GeminiUpstreamError && [
+				401,
+				403,
+				404
+			].includes(err.status)) resetAutoRoute("antigravity", `upstream returned ${err.status}`);
+			if (!(oauthSource === "auto" && !opts.apiKey && resolution.route !== "antigravity" && err instanceof GeminiUpstreamError && [
+				401,
+				403,
+				404
+			].includes(err.status))) throw err;
+			if (!(await authRoutes(true)).includes("antigravity")) throw err;
+			let fallback;
+			try {
+				fallback = {
+					...resolveGeminiModel(requested, await liveModelCatalog("antigravity"), effort),
+					route: "antigravity"
+				};
+			} catch {
+				fallback = {
+					...resolveGeminiModel(requested, [], effort),
+					route: "antigravity"
+				};
+			}
+			if (!fallback.id) throw err;
+			log(`  auth auto: ${resolution.route} returned ${err.status}; retrying ${requested ?? resolution.id} via antigravity as ${fallback.id}`);
+			const response = await callGemini(fallback.route, fallback.id, body, stream);
+			if ([401, 403].includes(err.status)) activateAutoRoute("antigravity", `Gemini CLI returned ${err.status}`);
+			return {
+				response,
+				resolution: fallback
+			};
+		}
+	}
+	async function callGemini(route, model, body, stream) {
+		const action = stream ? "streamGenerateContent" : "generateContent";
+		const keyMode = route === "api-key";
+		const upstreamModel = model;
+		const apiKeyCandidates = keyMode ? await quotaGuard.ordered(await loadKeyRing()) : [];
+		const oauthToken = keyMode ? void 0 : await currentOAuthToken(route);
+		const target = keyMode ? `${upstream}/v1beta/models/${encodeURIComponent(upstreamModel)}:${action}` : `${codeAssistBase(route)}/v1internal:${action}`;
+		const routeKey = `gemini:${route}:${upstreamModel}`;
+		const cooling = cooldowns.remainingMs(routeKey);
+		if (cooling > 0) throw new GeminiUpstreamError(429, new Headers({ "retry-after": String(Math.ceil(cooling / 1e3)) }), "Gemini route is cooling down after a rate limit.");
+		const thinking = body.generationConfig?.thinkingConfig;
+		const thinkingLog = thinking?.thinkingLevel ? ` thinking=${thinking.thinkingLevel.toLowerCase()}` : thinking?.thinkingBudget != null ? ` thinkingBudget=${thinking.thinkingBudget}` : "";
+		log(`  → Gemini ${upstreamModel} ${action} auth=${route}${thinkingLog}`);
+		const requestBody = keyMode ? body : {
+			model: upstreamModel,
+			project: await resolveOAuthProject(route, oauthToken),
+			user_prompt_id: randomUUID(),
+			request: {
+				...body,
+				session_id: proxySessionId
+			}
+		};
+		const candidates = keyMode ? apiKeyCandidates : [void 0];
+		let lastQuotaError;
+		for (const [index, candidate] of candidates.entries()) {
+			const token = candidate?.key ?? oauthToken;
+			let upstreamRes;
+			try {
+				upstreamRes = await fetch(target, {
+					method: "POST",
+					headers: {
+						"content-type": "application/json",
+						...keyMode ? { "x-goog-api-key": token } : {
+							authorization: `Bearer ${token}`,
+							...oauthProfile(route).userAgent ? { "user-agent": oauthProfile(route).userAgent } : {}
+						}
+					},
+					body: JSON.stringify(requestBody),
+					signal: AbortSignal.timeout(6e5),
+					redirect: "manual"
+				});
+			} catch (err) {
+				throw new GeminiUpstreamError(502, void 0, `Gemini network error: ${err instanceof Error ? err.message : String(err)}`);
+			}
+			const text = await upstreamRes.text();
+			log(`  ← ${upstreamRes.status}`);
+			if (!upstreamRes.ok) {
+				const failure = classifyUpstreamFailure(upstreamRes.status, upstreamRes.headers, text);
+				const credentialQuota = isCredentialQuotaFailure(upstreamRes.status, upstreamRes.headers, text);
+				if (failure.retryAfterMs && !credentialQuota) cooldowns.set(routeKey, failure.retryAfterMs);
+				const upstreamError = new GeminiUpstreamError(upstreamRes.status, upstreamRes.headers, extractGeminiErrorMessage(text, upstreamRes.status), text);
+				const next = candidates[index + 1];
+				if (keyMode && quotaGuard.enabled && next && credentialQuota) {
+					await quotaGuard.exhausted(candidate?.accountName, next.accountName, failure.retryAfterMs);
+					log(`  quota guard: ${candidate?.accountName ?? "current key"} cooling; retrying pool member`);
+					lastQuotaError = upstreamError;
+					continue;
+				}
+				if (!keyMode && upstreamRes.status === 404) {
+					modelCatalogs.delete(route);
+					modelCatalogFailures.delete(route);
+				}
+				throw upstreamError;
+			}
+			await quotaGuard.activate(candidate?.accountName);
+			try {
+				const parsed = JSON.parse(text);
+				return keyMode ? parsed : parsed.response ?? parsed;
+			} catch {
+				throw new GeminiUpstreamError(502, upstreamRes.headers, `Gemini returned non-JSON response: ${text.slice(0, 300)}`, text);
+			}
+		}
+		throw lastQuotaError ?? new GeminiUpstreamError(503, void 0, "No eligible pool account.");
+	}
+	return server;
+}
+async function listenGeminiProxy(opts) {
+	const server = createGeminiProxyServer(opts);
+	await new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(opts.port, opts.host, () => resolve());
+	});
+	const addr = server.address();
+	const port = addr && typeof addr === "object" ? addr.port : opts.port;
+	return {
+		endpoint: `http://${opts.host}:${port}`,
+		server
+	};
+}
+function checkCors(req, res) {
+	const origin = req.headers.origin;
+	if (origin) try {
+		const parsed = new URL(origin);
+		if (!((parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "[::1]") && (parsed.protocol === "http:" || parsed.protocol === "https:"))) {
+			json(res, 403, { error: {
+				type: "forbidden_origin",
+				message: "Only loopback browser origins are allowed."
+			} });
+			return false;
+		}
+		res.setHeader("access-control-allow-origin", origin);
+		res.setHeader("vary", "Origin");
+	} catch {
+		json(res, 403, { error: {
+			type: "forbidden_origin",
+			message: "Invalid browser origin."
+		} });
+		return false;
+	}
+	res.setHeader("access-control-allow-methods", "GET,POST,OPTIONS");
+	res.setHeader("access-control-allow-headers", "content-type,authorization,x-api-key,anthropic-version,anthropic-beta");
+	return true;
+}
+function json(res, status, body) {
+	const payload = Buffer.from(JSON.stringify(body), "utf8");
+	res.writeHead(status, {
+		"content-type": "application/json; charset=utf-8",
+		"content-length": payload.byteLength
+	});
+	res.end(payload);
+}
+function writeSse(res, event, data) {
+	res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+}
+/** Emit the minimal complete Responses SSE lifecycle consumed by Codex. */
+function writeOpenAIResponsesStream(res, response) {
+	res.writeHead(200, {
+		"content-type": "text/event-stream; charset=utf-8",
+		"cache-control": "no-cache, no-transform",
+		connection: "keep-alive"
+	});
+	let sequence = 0;
+	const emit = (type, payload) => {
+		writeSse(res, type, {
+			type,
+			sequence_number: sequence++,
+			...payload
+		});
+	};
+	const inProgressResponse = {
+		...response,
+		status: "in_progress",
+		output: [],
+		usage: null
+	};
+	emit("response.created", { response: inProgressResponse });
+	emit("response.in_progress", { response: inProgressResponse });
+	response.output.forEach((item, outputIndex) => {
+		const addedItem = {
+			...item,
+			status: "in_progress"
+		};
+		if (item.type === "reasoning") addedItem.summary = [];
+		else if (item.type === "message") addedItem.content = [];
+		else if (item.type === "function_call") addedItem.arguments = "";
+		emit("response.output_item.added", {
+			output_index: outputIndex,
+			item: addedItem
+		});
+		if (item.type === "reasoning") (item.summary ?? []).forEach((part, summaryIndex) => {
+			emit("response.reasoning_summary_part.added", {
+				item_id: item.id,
+				output_index: outputIndex,
+				summary_index: summaryIndex,
+				part: {
+					type: "summary_text",
+					text: ""
+				}
+			});
+			if (part.text) emit("response.reasoning_summary_text.delta", {
+				item_id: item.id,
+				output_index: outputIndex,
+				summary_index: summaryIndex,
+				delta: part.text
+			});
+			emit("response.reasoning_summary_text.done", {
+				item_id: item.id,
+				output_index: outputIndex,
+				summary_index: summaryIndex,
+				text: part.text
+			});
+			emit("response.reasoning_summary_part.done", {
+				item_id: item.id,
+				output_index: outputIndex,
+				summary_index: summaryIndex,
+				part
+			});
+		});
+		else if (item.type === "message") (item.content ?? []).forEach((part, contentIndex) => {
+			const emptyPart = {
+				...part,
+				text: ""
+			};
+			emit("response.content_part.added", {
+				item_id: item.id,
+				output_index: outputIndex,
+				content_index: contentIndex,
+				part: emptyPart
+			});
+			if (part.text) emit("response.output_text.delta", {
+				item_id: item.id,
+				output_index: outputIndex,
+				content_index: contentIndex,
+				delta: part.text,
+				logprobs: []
+			});
+			emit("response.output_text.done", {
+				item_id: item.id,
+				output_index: outputIndex,
+				content_index: contentIndex,
+				text: part.text,
+				logprobs: []
+			});
+			emit("response.content_part.done", {
+				item_id: item.id,
+				output_index: outputIndex,
+				content_index: contentIndex,
+				part
+			});
+		});
+		else if (item.type === "function_call") {
+			if (item.arguments) emit("response.function_call_arguments.delta", {
+				item_id: item.id,
+				output_index: outputIndex,
+				delta: item.arguments
+			});
+			emit("response.function_call_arguments.done", {
+				item_id: item.id,
+				output_index: outputIndex,
+				arguments: item.arguments ?? ""
+			});
+		}
+		emit("response.output_item.done", {
+			output_index: outputIndex,
+			item
+		});
+	});
+	emit("response.completed", { response });
+	res.end();
+}
+var GeminiUpstreamError = class extends Error {
+	status;
+	headers;
+	body;
+	constructor(status, headers, message = "Gemini upstream error", body) {
+		super(message);
+		this.status = status;
+		this.headers = headers;
+		this.body = body;
+		this.name = "GeminiUpstreamError";
+	}
+};
+function extractGeminiErrorMessage(body, status) {
+	try {
+		const parsed = JSON.parse(body);
+		return parsed.error?.message ?? parsed.message ?? `Gemini upstream returned HTTP ${status}`;
+	} catch {
+		return body.slice(0, 500) || `Gemini upstream returned HTTP ${status}`;
+	}
+}
+function writeGeminiError(res, err, fallback, anthropic = false) {
+	if (err instanceof GeminiUpstreamError) {
+		const retryAfter = err.headers?.get("retry-after");
+		const body = anthropic ? {
+			type: "error",
+			error: {
+				type: err.status === 429 ? "rate_limit_error" : "api_error",
+				message: err.message
+			}
+		} : { error: {
+			type: err.status === 429 ? "rate_limit_error" : "api_error",
+			message: err.message
+		} };
+		const payload = JSON.stringify(body);
+		res.writeHead(err.status, {
+			"content-type": "application/json; charset=utf-8",
+			"content-length": Buffer.byteLength(payload),
+			...retryAfter ? { "retry-after": retryAfter } : {}
+		});
+		res.end(payload);
+		return;
+	}
+	json(res, 502, anthropic ? {
+		type: "error",
+		error: {
+			message: fallback,
+			type: "proxy_error"
+		}
+	} : { error: {
+		message: fallback,
+		type: "proxy_error"
+	} });
+}
+/**
+* Page through Google Generative Language ListModels.
+* Returns bare ids (no `models/` prefix) that support generateContent.
+*/
+async function listGeminiModelsFromGoogle(upstream, apiKey, log = () => {}) {
+	const base = upstream.replace(/\/$/, "");
+	const ids = [];
+	const seen = /* @__PURE__ */ new Set();
+	let pageToken;
+	let pages = 0;
+	const maxPages = 20;
+	do {
+		const url = new URL(`${base}/v1beta/models`);
+		url.searchParams.set("key", apiKey);
+		url.searchParams.set("pageSize", "100");
+		if (pageToken) url.searchParams.set("pageToken", pageToken);
+		const upstreamRes = await fetch(url.toString(), {
+			method: "GET",
+			headers: {
+				"x-goog-api-key": apiKey,
+				accept: "application/json"
+			},
+			signal: AbortSignal.timeout(12e3)
+		});
+		if (!upstreamRes.ok) {
+			const text = await upstreamRes.text().catch(() => "");
+			throw new Error(`Google ListModels HTTP ${upstreamRes.status}${text ? `: ${text.slice(0, 200)}` : ""}`);
+		}
+		const body = await upstreamRes.json();
+		for (const m of body.models ?? []) {
+			const name = m.name ?? "";
+			const id = name.startsWith("models/") ? name.slice(7) : name;
+			if (!id) continue;
+			const methods = m.supportedGenerationMethods ?? [];
+			if (methods.length && !methods.includes("generateContent")) continue;
+			if (seen.has(id)) continue;
+			seen.add(id);
+			ids.push(id);
+		}
+		pageToken = body.nextPageToken?.trim() || void 0;
+		pages += 1;
+	} while (pageToken && pages < maxPages);
+	if (pages > 1) log(`  list models pages=${pages}`);
+	return ids;
+}
+/** Discover the account-scoped catalog exposed by Code Assist. */
+async function listGeminiModelsFromCodeAssist(upstream, accessToken, project, log = () => {}, userAgent) {
+	const base = upstream.replace(/\/$/, "");
+	const headers = {
+		authorization: `Bearer ${accessToken}`,
+		"content-type": "application/json",
+		accept: "application/json",
+		...userAgent ? { "user-agent": userAgent } : {}
+	};
+	const response = await fetch(`${base}/v1internal:fetchAvailableModels`, {
+		method: "POST",
+		headers,
+		body: JSON.stringify({ project: project ?? "" }),
+		signal: AbortSignal.timeout(3e4)
+	});
+	const text = await response.text();
+	if (response.ok) {
+		let body;
+		try {
+			body = JSON.parse(text);
+		} catch {
+			throw new Error(`Code Assist returned non-JSON model metadata: ${text.slice(0, 200)}`);
+		}
+		const catalog = parseCodeAssistModelCatalog(body);
+		log(`  Code Assist fetchAvailableModels models=${catalog.models.length}`);
+		return catalog;
+	}
+	log(`  Code Assist fetchAvailableModels HTTP ${response.status}; using quota metadata`);
+	return listGeminiModelsFromCodeAssistQuota(base, project, headers, text);
+}
+function parseCodeAssistModelCatalog(body) {
+	const models = [];
+	for (const [rawId, details] of Object.entries(body.models ?? {})) {
+		const id = bareModelId(rawId);
+		if (!id || details.disabled === true) continue;
+		const knownNonGeminiProvider = typeof details.apiProvider === "string" && details.apiProvider !== "API_PROVIDER_GOOGLE_GEMINI";
+		const knownNonGoogleModel = typeof details.modelProvider === "string" && details.modelProvider !== "MODEL_PROVIDER_GOOGLE";
+		if (knownNonGeminiProvider || knownNonGoogleModel) continue;
+		models.push({
+			id,
+			...typeof details.displayName === "string" ? { displayName: details.displayName } : {},
+			...details.recommended === true ? { recommended: true } : {}
+		});
+	}
+	const available = new Set(models.map((model) => model.id));
+	const preferredModelIds = (body.agentModelSorts ?? []).flatMap((sort) => sort.groups ?? []).flatMap((group) => group.modelIds ?? []).filter((id) => typeof id === "string").map(bareModelId).filter((id) => available.has(id));
+	const defaultModelId = typeof body.defaultAgentModelId === "string" ? bareModelId(body.defaultAgentModelId) : void 0;
+	return {
+		models,
+		...defaultModelId && available.has(defaultModelId) ? { defaultModelId } : {},
+		...preferredModelIds.length ? { preferredModelIds: [...new Set(preferredModelIds)] } : {}
+	};
+}
+async function listGeminiModelsFromCodeAssistQuota(base, project, headers, catalogError) {
+	const response = await fetch(`${base}/v1internal:retrieveUserQuota`, {
+		method: "POST",
+		headers,
+		body: JSON.stringify({
+			project: project ?? "",
+			userAgent: "anypick-gemini-proxy"
+		}),
+		signal: AbortSignal.timeout(3e4)
+	});
+	const text = await response.text();
+	if (!response.ok) throw new Error(`Code Assist model discovery failed: fetchAvailableModels ${catalogError.slice(0, 120)}; retrieveUserQuota HTTP ${response.status}${text ? `: ${text.slice(0, 200)}` : ""}`);
+	let body;
+	try {
+		body = JSON.parse(text);
+	} catch {
+		throw new Error(`Code Assist returned non-JSON model metadata: ${text.slice(0, 200)}`);
+	}
+	const models = [];
+	const add = (value) => {
+		if (typeof value !== "string") return;
+		const id = bareModelId(value);
+		if (id && !models.some((model) => model.id === id)) models.push({ id });
+	};
+	for (const bucket of body.buckets ?? []) add(bucket.modelId);
+	for (const model of body.models ?? []) if (typeof model === "string") add(model);
+	else add(model.id ?? model.name);
+	return { models };
+}
+function bareModelId(value) {
+	const trimmed = value.trim();
+	return trimmed.startsWith("models/") ? trimmed.slice(7) : trimmed;
+}
+function isCatalogResolution(resolution, catalog) {
+	return Boolean(resolution.id && catalog.models.some((model) => model.id === resolution.id));
+}
+//#endregion
+export { createGeminiProxyServer, listGeminiModelsFromCodeAssist, listGeminiModelsFromGoogle, listenGeminiProxy };
+
+//# sourceMappingURL=server.js.map