anypick 1.0.0 → 1.1.1

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

@@ -1,1240 +0,0 @@
-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