copilot-api-plus 1.0.8 → 1.0.10

package/dist/main.js

@@ -1,14 +1,18 @@
 #!/usr/bin/env node
 import { PATHS, ensurePaths } from "./paths-Ch0ixSo2.js";
-import { state } from "./state-DAw5jMjc.js";
-import { GITHUB_API_BASE_URL, copilotBaseUrl, copilotHeaders, githubHeaders } from "./get-user-DgPgvnrS.js";
+import { state } from "./state-CcLGr8VN.js";
+import { GITHUB_API_BASE_URL, copilotBaseUrl, copilotHeaders, githubHeaders } from "./get-user-BFf5xJXg.js";
 import { HTTPError, forwardError } from "./error-CvU5otz-.js";
-import { cacheModels, cacheVSCodeVersion, clearGithubToken, isNullish, setupCopilotToken, setupGitHubToken, sleep } from "./token-DYeOMeid.js";
-import { clearZenAuth, getZenAuthPath } from "./auth-C5zV8JbW.js";
+import { cacheModels, cacheVSCodeVersion, clearGithubToken, isNullish, setupCopilotToken, setupGitHubToken, sleep } from "./token-B8crDDoA.js";
+import { clearAntigravityAuth, disableCurrentAccount, getAntigravityAuthPath, getValidAccessToken, rotateAccount } from "./auth-Cm_0h9bp.js";
+import { clearZenAuth, getZenAuthPath } from "./auth-Cua-c0dq.js";
+import { getAntigravityModels, isThinkingModel } from "./get-models-Bbb8B5jI.js";
 import { defineCommand, runMain } from "citty";
 import consola from "consola";
 import fs from "node:fs/promises";
 import os from "node:os";
+import path from "node:path";
+import * as p from "@clack/prompts";
 import clipboard from "clipboardy";
 import { serve } from "srvx";
 import invariant from "tiny-invariant";
@@ -185,9 +189,11 @@ async function runLogout(options) {
 	if (options.all) {
 		await clearGithubToken();
 		await clearZenAuth();
+		await clearAntigravityAuth();
 		consola.success("Logged out from all services");
 		consola.info(`GitHub token: ${PATHS.GITHUB_TOKEN_PATH}`);
 		consola.info(`Zen API key: ${getZenAuthPath()}`);
+		consola.info(`Antigravity accounts: ${getAntigravityAuthPath()}`);
 		return;
 	}
 	if (options.zen) {
@@ -196,26 +202,42 @@ async function runLogout(options) {
 		consola.info(`Zen API key location: ${getZenAuthPath()}`);
 		return;
 	}
-	const choice = await consola.prompt("Which credentials do you want to clear?", {
+	if (options.antigravity) {
+		await clearAntigravityAuth();
+		consola.success("Logged out from Google Antigravity");
+		consola.info(`Antigravity accounts location: ${getAntigravityAuthPath()}`);
+		return;
+	}
+	switch (await consola.prompt("Which credentials do you want to clear?", {
 		type: "select",
 		options: [
 			"GitHub Copilot token",
 			"OpenCode Zen API key",
-			"Both (all credentials)"
+			"Google Antigravity accounts",
+			"All credentials"
 		]
-	});
-	if (choice === "GitHub Copilot token") {
-		await clearGithubToken();
-		consola.success("Logged out from GitHub Copilot");
-		consola.info(`Token file location: ${PATHS.GITHUB_TOKEN_PATH}`);
-	} else if (choice === "OpenCode Zen API key") {
-		await clearZenAuth();
-		consola.success("Logged out from OpenCode Zen");
-		consola.info(`Zen API key location: ${getZenAuthPath()}`);
-	} else if (choice === "Both (all credentials)") {
-		await clearGithubToken();
-		await clearZenAuth();
-		consola.success("Logged out from all services");
+	})) {
+		case "GitHub Copilot token":
+			await clearGithubToken();
+			consola.success("Logged out from GitHub Copilot");
+			consola.info(`Token file location: ${PATHS.GITHUB_TOKEN_PATH}`);
+			break;
+		case "OpenCode Zen API key":
+			await clearZenAuth();
+			consola.success("Logged out from OpenCode Zen");
+			consola.info(`Zen API key location: ${getZenAuthPath()}`);
+			break;
+		case "Google Antigravity accounts":
+			await clearAntigravityAuth();
+			consola.success("Logged out from Google Antigravity");
+			consola.info(`Antigravity accounts location: ${getAntigravityAuthPath()}`);
+			break;
+		case "All credentials":
+			await clearGithubToken();
+			await clearZenAuth();
+			await clearAntigravityAuth();
+			consola.success("Logged out from all services");
+			break;
 	}
 }
 const logout = defineCommand({
@@ -230,21 +252,259 @@ const logout = defineCommand({
 			default: false,
 			description: "Clear only OpenCode Zen API key"
 		},
+		antigravity: {
+			type: "boolean",
+			default: false,
+			description: "Clear only Google Antigravity accounts"
+		},
 		all: {
 			alias: "a",
 			type: "boolean",
 			default: false,
-			description: "Clear all credentials (GitHub and Zen)"
+			description: "Clear all credentials (GitHub, Zen, and Antigravity)"
 		}
 	},
 	run({ args }) {
 		return runLogout({
 			zen: args.zen,
+			antigravity: args.antigravity,
 			all: args.all
 		});
 	}
 });
 
+//#endregion
+//#region src/lib/config.ts
+const CONFIG_FILENAME = "config.json";
+/**
+* Get the path to the config file
+*/
+function getConfigPath() {
+	return path.join(PATHS.DATA_DIR, CONFIG_FILENAME);
+}
+/**
+* Load configuration from file
+*/
+async function loadConfig() {
+	try {
+		const configPath = getConfigPath();
+		const content = await fs.readFile(configPath, "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return {};
+	}
+}
+/**
+* Save configuration to file
+*/
+async function saveConfig(config) {
+	const configPath = getConfigPath();
+	await fs.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
+	consola.debug(`Configuration saved to ${configPath}`);
+}
+/**
+* Get proxy configuration
+*/
+async function getProxyConfig() {
+	return (await loadConfig()).proxy;
+}
+/**
+* Save proxy configuration
+*/
+async function saveProxyConfig(proxyConfig) {
+	const config = await loadConfig();
+	config.proxy = proxyConfig;
+	await saveConfig(config);
+}
+/**
+* Clear proxy configuration
+*/
+async function clearProxyConfig() {
+	const config = await loadConfig();
+	delete config.proxy;
+	await saveConfig(config);
+}
+/**
+* Apply saved proxy configuration to environment variables
+* This should be called at startup to restore proxy settings
+*/
+async function applyProxyConfig() {
+	const proxyConfig = await getProxyConfig();
+	if (!proxyConfig || !proxyConfig.enabled) return false;
+	if (proxyConfig.httpProxy) {
+		process.env.HTTP_PROXY = proxyConfig.httpProxy;
+		process.env.http_proxy = proxyConfig.httpProxy;
+	}
+	if (proxyConfig.httpsProxy) {
+		process.env.HTTPS_PROXY = proxyConfig.httpsProxy;
+		process.env.https_proxy = proxyConfig.httpsProxy;
+	}
+	if (proxyConfig.noProxy) {
+		process.env.NO_PROXY = proxyConfig.noProxy;
+		process.env.no_proxy = proxyConfig.noProxy;
+	}
+	consola.info("Proxy configuration loaded from saved settings");
+	if (proxyConfig.httpProxy) consola.info(`  HTTP_PROXY: ${proxyConfig.httpProxy}`);
+	if (proxyConfig.httpsProxy) consola.info(`  HTTPS_PROXY: ${proxyConfig.httpsProxy}`);
+	if (proxyConfig.noProxy) consola.info(`  NO_PROXY: ${proxyConfig.noProxy}`);
+	return true;
+}
+
+//#endregion
+//#region src/proxy-config.ts
+const proxy = defineCommand({
+	meta: {
+		name: "proxy",
+		description: "Configure proxy settings (persistent)"
+	},
+	args: {
+		set: {
+			type: "boolean",
+			default: false,
+			description: "Set proxy configuration interactively"
+		},
+		enable: {
+			type: "boolean",
+			default: false,
+			description: "Enable saved proxy configuration"
+		},
+		disable: {
+			type: "boolean",
+			default: false,
+			description: "Disable proxy (keep settings)"
+		},
+		clear: {
+			type: "boolean",
+			default: false,
+			description: "Clear all proxy settings"
+		},
+		show: {
+			type: "boolean",
+			default: false,
+			description: "Show current proxy configuration"
+		},
+		"http-proxy": {
+			type: "string",
+			description: "HTTP proxy URL (e.g., http://proxy:8080)"
+		},
+		"https-proxy": {
+			type: "string",
+			description: "HTTPS proxy URL (e.g., http://proxy:8080)"
+		},
+		"no-proxy": {
+			type: "string",
+			description: "Comma-separated list of hosts to bypass proxy"
+		}
+	},
+	async run({ args }) {
+		await ensurePaths();
+		if (args.show || !args.set && !args.enable && !args.disable && !args.clear && !args["http-proxy"] && !args["https-proxy"]) {
+			const config = await getProxyConfig();
+			if (!config) {
+				consola.info("No proxy configuration saved.");
+				consola.info("");
+				consola.info("To configure proxy, use one of:");
+				consola.info("  copilot-api-plus proxy --set                    # Interactive setup");
+				consola.info("  copilot-api-plus proxy --http-proxy http://proxy:8080  # Direct set");
+				return;
+			}
+			consola.info("Current proxy configuration:");
+			consola.info(`  Status: ${config.enabled ? "✅ Enabled" : "❌ Disabled"}`);
+			if (config.httpProxy) consola.info(`  HTTP_PROXY: ${config.httpProxy}`);
+			if (config.httpsProxy) consola.info(`  HTTPS_PROXY: ${config.httpsProxy}`);
+			if (config.noProxy) consola.info(`  NO_PROXY: ${config.noProxy}`);
+			return;
+		}
+		if (args.clear) {
+			await clearProxyConfig();
+			consola.success("Proxy configuration cleared.");
+			return;
+		}
+		if (args.enable) {
+			const config = await getProxyConfig();
+			if (!config) {
+				consola.error("No proxy configuration saved. Use --set to configure first.");
+				return;
+			}
+			config.enabled = true;
+			await saveProxyConfig(config);
+			consola.success("Proxy enabled. It will be used on next server start.");
+			return;
+		}
+		if (args.disable) {
+			const config = await getProxyConfig();
+			if (!config) {
+				consola.info("No proxy configuration to disable.");
+				return;
+			}
+			config.enabled = false;
+			await saveProxyConfig(config);
+			consola.success("Proxy disabled. Settings are preserved.");
+			return;
+		}
+		if (args["http-proxy"] || args["https-proxy"]) {
+			const newConfig = {
+				enabled: true,
+				httpProxy: args["http-proxy"],
+				httpsProxy: args["https-proxy"] || args["http-proxy"],
+				noProxy: args["no-proxy"]
+			};
+			await saveProxyConfig(newConfig);
+			consola.success("Proxy configuration saved and enabled.");
+			consola.info(`  HTTP_PROXY: ${newConfig.httpProxy || "(not set)"}`);
+			consola.info(`  HTTPS_PROXY: ${newConfig.httpsProxy || "(not set)"}`);
+			if (newConfig.noProxy) consola.info(`  NO_PROXY: ${newConfig.noProxy}`);
+			return;
+		}
+		if (args.set) {
+			p.intro("Proxy Configuration");
+			const existingConfig = await getProxyConfig();
+			const httpProxy = await p.text({
+				message: "HTTP Proxy URL",
+				placeholder: "http://proxy:8080",
+				initialValue: existingConfig?.httpProxy || ""
+			});
+			if (p.isCancel(httpProxy)) {
+				p.cancel("Configuration cancelled.");
+				return;
+			}
+			const httpsProxy = await p.text({
+				message: "HTTPS Proxy URL (leave empty to use HTTP proxy)",
+				placeholder: "http://proxy:8080",
+				initialValue: existingConfig?.httpsProxy || ""
+			});
+			if (p.isCancel(httpsProxy)) {
+				p.cancel("Configuration cancelled.");
+				return;
+			}
+			const noProxy = await p.text({
+				message: "No Proxy (comma-separated hosts to bypass)",
+				placeholder: "localhost,127.0.0.1,.local",
+				initialValue: existingConfig?.noProxy || ""
+			});
+			if (p.isCancel(noProxy)) {
+				p.cancel("Configuration cancelled.");
+				return;
+			}
+			const enable = await p.confirm({
+				message: "Enable proxy now?",
+				initialValue: true
+			});
+			if (p.isCancel(enable)) {
+				p.cancel("Configuration cancelled.");
+				return;
+			}
+			await saveProxyConfig({
+				enabled: enable,
+				httpProxy: httpProxy || void 0,
+				httpsProxy: httpsProxy || httpProxy || void 0,
+				noProxy: noProxy || void 0
+			});
+			p.outro(`Proxy configuration saved${enable ? " and enabled" : ""}.`);
+		}
+	}
+});
+
 //#endregion
 //#region src/lib/proxy.ts
 function initProxyFromEnv() {
@@ -376,6 +636,700 @@ const apiKeyAuthMiddleware = async (c, next) => {
 	await next();
 };
 
+//#endregion
+//#region src/services/antigravity/create-chat-completions.ts
+const ANTIGRAVITY_API_HOST$1 = "daily-cloudcode-pa.sandbox.googleapis.com";
+const ANTIGRAVITY_STREAM_URL$1 = `https://${ANTIGRAVITY_API_HOST$1}/v1internal:streamGenerateContent?alt=sse`;
+const ANTIGRAVITY_NO_STREAM_URL$1 = `https://${ANTIGRAVITY_API_HOST$1}/v1internal:generateContent`;
+const ANTIGRAVITY_USER_AGENT$1 = "antigravity/1.11.3 windows/amd64";
+/**
+* Convert OpenAI format messages to Antigravity format
+*/
+function convertMessages$1(messages) {
+	const contents = [];
+	let systemInstruction = void 0;
+	for (const message of messages) {
+		if (message.role === "system") {
+			systemInstruction = {
+				role: "user",
+				parts: [{ text: typeof message.content === "string" ? message.content : message.content.map((c) => c.text || "").join("") }]
+			};
+			continue;
+		}
+		const role = message.role === "assistant" ? "model" : "user";
+		if (typeof message.content === "string") contents.push({
+			role,
+			parts: [{ text: message.content }]
+		});
+		else {
+			const parts = [];
+			for (const part of message.content) if (part.type === "text") parts.push({ text: part.text });
+			else if (part.type === "image_url" && part.image_url?.url) {
+				const url = part.image_url.url;
+				if (url.startsWith("data:")) {
+					const match = url.match(/^data:([^;]+);base64,(.+)$/);
+					if (match) parts.push({ inlineData: {
+						mimeType: match[1],
+						data: match[2]
+					} });
+				}
+			}
+			contents.push({
+				role,
+				parts
+			});
+		}
+	}
+	return {
+		contents,
+		systemInstruction
+	};
+}
+/**
+* Convert tools to Antigravity format
+*/
+function convertTools$1(tools) {
+	if (!tools || tools.length === 0) return;
+	return tools.map((tool) => {
+		const t = tool;
+		if (t.type === "function" && t.function) return { functionDeclarations: [{
+			name: t.function.name,
+			description: t.function.description || "",
+			parameters: t.function.parameters || {}
+		}] };
+		return tool;
+	});
+}
+/**
+* Create chat completion with Antigravity
+*/
+async function createAntigravityChatCompletion(request) {
+	const accessToken = await getValidAccessToken();
+	if (!accessToken) return new Response(JSON.stringify({ error: {
+		message: "No valid Antigravity access token available. Please run login first.",
+		type: "auth_error"
+	} }), {
+		status: 401,
+		headers: { "Content-Type": "application/json" }
+	});
+	const { contents, systemInstruction } = convertMessages$1(request.messages);
+	const tools = convertTools$1(request.tools);
+	const antigravityRequest = {
+		model: request.model,
+		contents,
+		generationConfig: {
+			temperature: request.temperature ?? 1,
+			topP: request.top_p ?? .85,
+			topK: request.top_k ?? 50,
+			maxOutputTokens: request.max_tokens ?? 8096
+		}
+	};
+	if (systemInstruction) antigravityRequest.systemInstruction = systemInstruction;
+	if (tools) antigravityRequest.tools = tools;
+	if (isThinkingModel(request.model)) antigravityRequest.generationConfig = {
+		...antigravityRequest.generationConfig,
+		thinkingConfig: { includeThoughts: true }
+	};
+	const endpoint = request.stream ? ANTIGRAVITY_STREAM_URL$1 : ANTIGRAVITY_NO_STREAM_URL$1;
+	consola.debug(`Antigravity request to ${endpoint} with model ${request.model}`);
+	try {
+		const response = await fetch(endpoint, {
+			method: "POST",
+			headers: {
+				Host: ANTIGRAVITY_API_HOST$1,
+				"User-Agent": ANTIGRAVITY_USER_AGENT$1,
+				Authorization: `Bearer ${accessToken}`,
+				"Content-Type": "application/json",
+				"Accept-Encoding": "gzip"
+			},
+			body: JSON.stringify(antigravityRequest)
+		});
+		if (!response.ok) {
+			const errorText = await response.text();
+			consola.error(`Antigravity error: ${response.status} ${errorText}`);
+			if (response.status === 403) await disableCurrentAccount();
+			if (response.status === 429 || response.status === 503) await rotateAccount();
+			return new Response(JSON.stringify({ error: {
+				message: `Antigravity API error: ${response.status}`,
+				type: "api_error",
+				details: errorText
+			} }), {
+				status: response.status,
+				headers: { "Content-Type": "application/json" }
+			});
+		}
+		if (request.stream) return transformStreamResponse(response, request.model);
+		else return transformNonStreamResponse(response, request.model);
+	} catch (error) {
+		consola.error("Antigravity request error:", error);
+		return new Response(JSON.stringify({ error: {
+			message: `Request failed: ${error}`,
+			type: "request_error"
+		} }), {
+			status: 500,
+			headers: { "Content-Type": "application/json" }
+		});
+	}
+}
+/**
+* Transform Antigravity stream response to OpenAI format
+*/
+function transformStreamResponse(response, model) {
+	const reader = response.body?.getReader();
+	if (!reader) return new Response("No response body", { status: 500 });
+	const encoder = new TextEncoder();
+	const decoder = new TextDecoder();
+	const stream = new ReadableStream({ async start(controller) {
+		let buffer = "";
+		const requestId = `chatcmpl-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) {
+					controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+					controller.close();
+					break;
+				}
+				buffer += decoder.decode(value, { stream: true });
+				const lines = buffer.split("\n");
+				buffer = lines.pop() || "";
+				for (const line of lines) if (line.startsWith("data: ")) {
+					const data = line.slice(6).trim();
+					if (data === "[DONE]" || data === "") continue;
+					try {
+						const parsed = JSON.parse(data);
+						const candidate = (parsed.response?.candidates || parsed.candidates)?.[0];
+						const parts = candidate?.content?.parts || [];
+						for (const part of parts) {
+							if (part.thought && part.text) {
+								const chunk = {
+									id: requestId,
+									object: "chat.completion.chunk",
+									created: Math.floor(Date.now() / 1e3),
+									model,
+									choices: [{
+										index: 0,
+										delta: { reasoning_content: part.text },
+										finish_reason: null
+									}]
+								};
+								controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}\n\n`));
+								continue;
+							}
+							if (part.text) {
+								const chunk = {
+									id: requestId,
+									object: "chat.completion.chunk",
+									created: Math.floor(Date.now() / 1e3),
+									model,
+									choices: [{
+										index: 0,
+										delta: { content: part.text },
+										finish_reason: candidate?.finishReason === "STOP" ? "stop" : null
+									}]
+								};
+								controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}\n\n`));
+							}
+							if (part.functionCall) {
+								const chunk = {
+									id: requestId,
+									object: "chat.completion.chunk",
+									created: Math.floor(Date.now() / 1e3),
+									model,
+									choices: [{
+										index: 0,
+										delta: { tool_calls: [{
+											index: 0,
+											id: `call_${Date.now()}`,
+											type: "function",
+											function: {
+												name: part.functionCall.name,
+												arguments: JSON.stringify(part.functionCall.args)
+											}
+										}] },
+										finish_reason: null
+									}]
+								};
+								controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}\n\n`));
+							}
+						}
+					} catch {}
+				}
+			}
+		} catch (error) {
+			consola.error("Stream transform error:", error);
+			controller.error(error);
+		}
+	} });
+	return new Response(stream, { headers: {
+		"Content-Type": "text/event-stream",
+		"Cache-Control": "no-cache",
+		Connection: "keep-alive"
+	} });
+}
+/**
+* Transform Antigravity non-stream response to OpenAI format
+*/
+async function transformNonStreamResponse(response, model) {
+	const data = await response.json();
+	const candidate = data.candidates?.[0];
+	const parts = candidate?.content?.parts || [];
+	let content = "";
+	let reasoningContent = "";
+	const toolCalls = [];
+	for (const part of parts) {
+		if (part.thought && part.text) reasoningContent += part.text;
+		else if (part.text) content += part.text;
+		if (part.functionCall) toolCalls.push({
+			id: `call_${Date.now()}`,
+			type: "function",
+			function: {
+				name: part.functionCall.name,
+				arguments: JSON.stringify(part.functionCall.args)
+			}
+		});
+	}
+	const message = {
+		role: "assistant",
+		content: content || null
+	};
+	if (reasoningContent) message.reasoning_content = reasoningContent;
+	if (toolCalls.length > 0) message.tool_calls = toolCalls;
+	const openaiResponse = {
+		id: `chatcmpl-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+		object: "chat.completion",
+		created: Math.floor(Date.now() / 1e3),
+		model,
+		choices: [{
+			index: 0,
+			message,
+			finish_reason: candidate?.finishReason === "STOP" ? "stop" : "stop"
+		}],
+		usage: {
+			prompt_tokens: data.usageMetadata?.promptTokenCount || 0,
+			completion_tokens: data.usageMetadata?.candidatesTokenCount || 0,
+			total_tokens: data.usageMetadata?.totalTokenCount || 0
+		}
+	};
+	return new Response(JSON.stringify(openaiResponse), { headers: { "Content-Type": "application/json" } });
+}
+
+//#endregion
+//#region src/routes/antigravity/chat-completions/route.ts
+const app$1 = new Hono();
+app$1.post("/", async (c) => {
+	const body = await c.req.json();
+	const response = await createAntigravityChatCompletion(body);
+	const headers = new Headers(response.headers);
+	if (body.stream) return new Response(response.body, {
+		status: response.status,
+		headers
+	});
+	return new Response(await response.text(), {
+		status: response.status,
+		headers
+	});
+});
+const antigravityChatCompletionsRoute = app$1;
+
+//#endregion
+//#region src/services/antigravity/create-messages.ts
+const ANTIGRAVITY_API_HOST = "daily-cloudcode-pa.sandbox.googleapis.com";
+const ANTIGRAVITY_STREAM_URL = `https://${ANTIGRAVITY_API_HOST}/v1internal:streamGenerateContent?alt=sse`;
+const ANTIGRAVITY_NO_STREAM_URL = `https://${ANTIGRAVITY_API_HOST}/v1internal:generateContent`;
+const ANTIGRAVITY_USER_AGENT = "antigravity/1.11.3 windows/amd64";
+/**
+* Convert Anthropic messages to Antigravity format
+*/
+function convertMessages(messages, system) {
+	const contents = [];
+	let systemInstruction = void 0;
+	if (system) systemInstruction = {
+		role: "user",
+		parts: [{ text: system }]
+	};
+	for (const message of messages) {
+		const role = message.role === "assistant" ? "model" : "user";
+		if (typeof message.content === "string") contents.push({
+			role,
+			parts: [{ text: message.content }]
+		});
+		else {
+			const parts = [];
+			for (const block of message.content) if (block.type === "text" && block.text) parts.push({ text: block.text });
+			else if (block.type === "image" && block.source) parts.push({ inlineData: {
+				mimeType: block.source.media_type,
+				data: block.source.data
+			} });
+			if (parts.length > 0) contents.push({
+				role,
+				parts
+			});
+		}
+	}
+	return {
+		contents,
+		systemInstruction
+	};
+}
+/**
+* Convert tools to Antigravity format
+*/
+function convertTools(tools) {
+	if (!tools || tools.length === 0) return;
+	return tools.map((tool) => {
+		const t = tool;
+		return { functionDeclarations: [{
+			name: t.name,
+			description: t.description || "",
+			parameters: t.input_schema || {}
+		}] };
+	});
+}
+/**
+* Create Anthropic-compatible message response using Antigravity
+*/
+async function createAntigravityMessages(request) {
+	const accessToken = await getValidAccessToken();
+	if (!accessToken) return new Response(JSON.stringify({
+		type: "error",
+		error: {
+			type: "authentication_error",
+			message: "No valid Antigravity access token available. Please run login first."
+		}
+	}), {
+		status: 401,
+		headers: { "Content-Type": "application/json" }
+	});
+	const { contents, systemInstruction } = convertMessages(request.messages, request.system);
+	const tools = convertTools(request.tools);
+	const antigravityRequest = {
+		model: request.model,
+		contents,
+		generationConfig: {
+			temperature: request.temperature ?? 1,
+			topP: request.top_p ?? .85,
+			topK: request.top_k ?? 50,
+			maxOutputTokens: request.max_tokens ?? 8096
+		}
+	};
+	if (systemInstruction) antigravityRequest.systemInstruction = systemInstruction;
+	if (tools) antigravityRequest.tools = tools;
+	if (isThinkingModel(request.model)) antigravityRequest.generationConfig = {
+		...antigravityRequest.generationConfig,
+		thinkingConfig: { includeThoughts: true }
+	};
+	const endpoint = request.stream ? ANTIGRAVITY_STREAM_URL : ANTIGRAVITY_NO_STREAM_URL;
+	consola.debug(`Antigravity messages request to ${endpoint} with model ${request.model}`);
+	try {
+		const response = await fetch(endpoint, {
+			method: "POST",
+			headers: {
+				Host: ANTIGRAVITY_API_HOST,
+				"User-Agent": ANTIGRAVITY_USER_AGENT,
+				Authorization: `Bearer ${accessToken}`,
+				"Content-Type": "application/json",
+				"Accept-Encoding": "gzip"
+			},
+			body: JSON.stringify(antigravityRequest)
+		});
+		if (!response.ok) {
+			const errorText = await response.text();
+			consola.error(`Antigravity error: ${response.status} ${errorText}`);
+			if (response.status === 403) await disableCurrentAccount();
+			if (response.status === 429 || response.status === 503) await rotateAccount();
+			return new Response(JSON.stringify({
+				type: "error",
+				error: {
+					type: "api_error",
+					message: `Antigravity API error: ${response.status}`
+				}
+			}), {
+				status: response.status,
+				headers: { "Content-Type": "application/json" }
+			});
+		}
+		if (request.stream) return transformStreamToAnthropic(response, request.model);
+		else return transformNonStreamToAnthropic(response, request.model);
+	} catch (error) {
+		consola.error("Antigravity messages request error:", error);
+		return new Response(JSON.stringify({
+			type: "error",
+			error: {
+				type: "api_error",
+				message: `Request failed: ${error}`
+			}
+		}), {
+			status: 500,
+			headers: { "Content-Type": "application/json" }
+		});
+	}
+}
+/**
+* Transform Antigravity stream response to Anthropic format
+*/
+function transformStreamToAnthropic(response, model) {
+	const reader = response.body?.getReader();
+	if (!reader) return new Response("No response body", { status: 500 });
+	const encoder = new TextEncoder();
+	const decoder = new TextDecoder();
+	const stream = new ReadableStream({ async start(controller) {
+		let buffer = "";
+		const messageId = `msg_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+		let inputTokens = 0;
+		let outputTokens = 0;
+		let contentBlockIndex = 0;
+		let thinkingBlockStarted = false;
+		let textBlockStarted = false;
+		const messageStart = {
+			type: "message_start",
+			message: {
+				id: messageId,
+				type: "message",
+				role: "assistant",
+				content: [],
+				model,
+				stop_reason: null,
+				stop_sequence: null,
+				usage: {
+					input_tokens: 0,
+					output_tokens: 0
+				}
+			}
+		};
+		controller.enqueue(encoder.encode(`event: message_start\ndata: ${JSON.stringify(messageStart)}\n\n`));
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) {
+					controller.enqueue(encoder.encode(`event: message_stop\ndata: ${JSON.stringify({ type: "message_stop" })}\n\n`));
+					controller.close();
+					break;
+				}
+				buffer += decoder.decode(value, { stream: true });
+				const lines = buffer.split("\n");
+				buffer = lines.pop() || "";
+				for (const line of lines) if (line.startsWith("data: ")) {
+					const data = line.slice(6).trim();
+					if (data === "[DONE]" || data === "") continue;
+					try {
+						const parsed = JSON.parse(data);
+						const candidate = (parsed.response?.candidates || parsed.candidates)?.[0];
+						const parts = candidate?.content?.parts || [];
+						const usage = parsed.response?.usageMetadata || parsed.usageMetadata;
+						if (usage) {
+							inputTokens = usage.promptTokenCount || inputTokens;
+							outputTokens = usage.candidatesTokenCount || outputTokens;
+						}
+						for (const part of parts) {
+							if (part.thought && part.text) {
+								if (!thinkingBlockStarted) {
+									const blockStart = {
+										type: "content_block_start",
+										index: contentBlockIndex,
+										content_block: {
+											type: "thinking",
+											thinking: ""
+										}
+									};
+									controller.enqueue(encoder.encode(`event: content_block_start\ndata: ${JSON.stringify(blockStart)}\n\n`));
+									thinkingBlockStarted = true;
+								}
+								const thinkingDelta = {
+									type: "content_block_delta",
+									index: contentBlockIndex,
+									delta: {
+										type: "thinking_delta",
+										thinking: part.text
+									}
+								};
+								controller.enqueue(encoder.encode(`event: content_block_delta\ndata: ${JSON.stringify(thinkingDelta)}\n\n`));
+								continue;
+							}
+							if (part.text && !part.thought) {
+								if (thinkingBlockStarted && !textBlockStarted) {
+									const blockStop = {
+										type: "content_block_stop",
+										index: contentBlockIndex
+									};
+									controller.enqueue(encoder.encode(`event: content_block_stop\ndata: ${JSON.stringify(blockStop)}\n\n`));
+									contentBlockIndex++;
+								}
+								if (!textBlockStarted) {
+									const blockStart = {
+										type: "content_block_start",
+										index: contentBlockIndex,
+										content_block: {
+											type: "text",
+											text: ""
+										}
+									};
+									controller.enqueue(encoder.encode(`event: content_block_start\ndata: ${JSON.stringify(blockStart)}\n\n`));
+									textBlockStarted = true;
+								}
+								const textDelta = {
+									type: "content_block_delta",
+									index: contentBlockIndex,
+									delta: {
+										type: "text_delta",
+										text: part.text
+									}
+								};
+								controller.enqueue(encoder.encode(`event: content_block_delta\ndata: ${JSON.stringify(textDelta)}\n\n`));
+							}
+							if (part.functionCall) {
+								if (textBlockStarted || thinkingBlockStarted) {
+									const blockStop = {
+										type: "content_block_stop",
+										index: contentBlockIndex
+									};
+									controller.enqueue(encoder.encode(`event: content_block_stop\ndata: ${JSON.stringify(blockStop)}\n\n`));
+									contentBlockIndex++;
+									textBlockStarted = false;
+									thinkingBlockStarted = false;
+								}
+								const toolBlockStart = {
+									type: "content_block_start",
+									index: contentBlockIndex,
+									content_block: {
+										type: "tool_use",
+										id: `toolu_${Date.now()}`,
+										name: part.functionCall.name,
+										input: {}
+									}
+								};
+								controller.enqueue(encoder.encode(`event: content_block_start\ndata: ${JSON.stringify(toolBlockStart)}\n\n`));
+								const toolDelta = {
+									type: "content_block_delta",
+									index: contentBlockIndex,
+									delta: {
+										type: "input_json_delta",
+										partial_json: JSON.stringify(part.functionCall.args)
+									}
+								};
+								controller.enqueue(encoder.encode(`event: content_block_delta\ndata: ${JSON.stringify(toolDelta)}\n\n`));
+								const toolBlockStop = {
+									type: "content_block_stop",
+									index: contentBlockIndex
+								};
+								controller.enqueue(encoder.encode(`event: content_block_stop\ndata: ${JSON.stringify(toolBlockStop)}\n\n`));
+								contentBlockIndex++;
+							}
+						}
+						if (candidate?.finishReason === "STOP") {
+							if (textBlockStarted || thinkingBlockStarted) {
+								const blockStop = {
+									type: "content_block_stop",
+									index: contentBlockIndex
+								};
+								controller.enqueue(encoder.encode(`event: content_block_stop\ndata: ${JSON.stringify(blockStop)}\n\n`));
+							}
+							const messageDelta = {
+								type: "message_delta",
+								delta: {
+									stop_reason: "end_turn",
+									stop_sequence: null
+								},
+								usage: { output_tokens: outputTokens }
+							};
+							controller.enqueue(encoder.encode(`event: message_delta\ndata: ${JSON.stringify(messageDelta)}\n\n`));
+						}
+					} catch {}
+				}
+			}
+		} catch (error) {
+			consola.error("Stream transform error:", error);
+			controller.error(error);
+		}
+	} });
+	return new Response(stream, { headers: {
+		"Content-Type": "text/event-stream",
+		"Cache-Control": "no-cache",
+		Connection: "keep-alive"
+	} });
+}
+/**
+* Transform Antigravity non-stream response to Anthropic format
+*/
+async function transformNonStreamToAnthropic(response, model) {
+	const data = await response.json();
+	const candidate = data.candidates?.[0];
+	const parts = candidate?.content?.parts || [];
+	const content = [];
+	for (const part of parts) {
+		if (part.thought && part.text) content.push({
+			type: "thinking",
+			thinking: part.text
+		});
+		else if (part.text) content.push({
+			type: "text",
+			text: part.text
+		});
+		if (part.functionCall) content.push({
+			type: "tool_use",
+			id: `toolu_${Date.now()}`,
+			name: part.functionCall.name,
+			input: part.functionCall.args
+		});
+	}
+	const anthropicResponse = {
+		id: `msg_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
+		type: "message",
+		role: "assistant",
+		content,
+		model,
+		stop_reason: candidate?.finishReason === "STOP" ? "end_turn" : "end_turn",
+		stop_sequence: null,
+		usage: {
+			input_tokens: data.usageMetadata?.promptTokenCount || 0,
+			output_tokens: data.usageMetadata?.candidatesTokenCount || 0
+		}
+	};
+	return new Response(JSON.stringify(anthropicResponse), { headers: { "Content-Type": "application/json" } });
+}
+
+//#endregion
+//#region src/routes/antigravity/messages/route.ts
+const antigravityMessagesRoute = new Hono();
+antigravityMessagesRoute.post("/", async (c) => {
+	if (!state.antigravityMode) return c.json({ error: "Antigravity mode is not enabled. Start with --antigravity flag." }, 400);
+	try {
+		const body = await c.req.json();
+		consola.debug("Antigravity message request:", body.model);
+		const response = await createAntigravityMessages(body);
+		if (body.stream) {
+			const headers = new Headers();
+			headers.set("Content-Type", "text/event-stream");
+			headers.set("Cache-Control", "no-cache");
+			headers.set("Connection", "keep-alive");
+			return new Response(response.body, {
+				status: response.status,
+				headers
+			});
+		}
+		const data = await response.json();
+		return c.json(data);
+	} catch (error) {
+		consola.error("Antigravity message error:", error);
+		return c.json({
+			type: "error",
+			error: {
+				type: "antigravity_error",
+				message: error instanceof Error ? error.message : "Unknown error"
+			}
+		}, 500);
+	}
+});
+
+//#endregion
+//#region src/routes/antigravity/models/route.ts
+const app = new Hono();
+app.get("/", async (c) => {
+	const models = await getAntigravityModels();
+	return c.json(models);
+});
+const antigravityModelsRoute = app;
+
 //#endregion
 //#region src/lib/approval.ts
 const awaitApproval = async () => {
@@ -1312,7 +2266,7 @@ zenModelRoutes.get("/", async (c) => {
 	if (!state.zenMode || !state.zenApiKey) return c.json({ error: "Zen mode is not enabled. Start with --zen flag." }, 400);
 	try {
 		if (state.zenModels) return c.json(state.zenModels);
-		const { getZenModels } = await import("./get-models-Hlxa1hWY.js");
+		const { getZenModels } = await import("./get-models-DJfPj_Rg.js");
 		const models = await getZenModels();
 		state.zenModels = models;
 		return c.json(models);
@@ -1332,33 +2286,41 @@ server.use(logger());
 server.use(cors());
 server.use(apiKeyAuthMiddleware);
 server.get("/", (c) => c.text("Server running"));
-server.route("/chat/completions", new Hono().all("/*", async (c, next) => {
+server.route("/chat/completions", new Hono().all("/*", async (c, _next) => {
 	if (state.zenMode) return zenCompletionRoutes.fetch(c.req.raw, c.env);
+	if (state.antigravityMode) return antigravityChatCompletionsRoute.fetch(c.req.raw, c.env);
 	return completionRoutes.fetch(c.req.raw, c.env);
 }));
-server.route("/models", new Hono().all("/*", async (c, next) => {
+server.route("/models", new Hono().all("/*", async (c, _next) => {
 	if (state.zenMode) return zenModelRoutes.fetch(c.req.raw, c.env);
+	if (state.antigravityMode) return antigravityModelsRoute.fetch(c.req.raw, c.env);
 	return modelRoutes.fetch(c.req.raw, c.env);
 }));
 server.route("/embeddings", embeddingRoutes);
 server.route("/usage", usageRoute);
 server.route("/token", tokenRoute);
-server.route("/v1/chat/completions", new Hono().all("/*", async (c, next) => {
+server.route("/v1/chat/completions", new Hono().all("/*", async (c, _next) => {
 	if (state.zenMode) return zenCompletionRoutes.fetch(c.req.raw, c.env);
+	if (state.antigravityMode) return antigravityChatCompletionsRoute.fetch(c.req.raw, c.env);
 	return completionRoutes.fetch(c.req.raw, c.env);
 }));
-server.route("/v1/models", new Hono().all("/*", async (c, next) => {
+server.route("/v1/models", new Hono().all("/*", async (c, _next) => {
 	if (state.zenMode) return zenModelRoutes.fetch(c.req.raw, c.env);
+	if (state.antigravityMode) return antigravityModelsRoute.fetch(c.req.raw, c.env);
 	return modelRoutes.fetch(c.req.raw, c.env);
 }));
 server.route("/v1/embeddings", embeddingRoutes);
-server.route("/v1/messages", new Hono().all("/*", async (c, next) => {
+server.route("/v1/messages", new Hono().all("/*", async (c, _next) => {
 	if (state.zenMode) return zenMessageRoutes.fetch(c.req.raw, c.env);
+	if (state.antigravityMode) return antigravityMessagesRoute.fetch(c.req.raw, c.env);
 	return messageRoutes.fetch(c.req.raw, c.env);
 }));
 server.route("/zen/v1/chat/completions", zenCompletionRoutes);
 server.route("/zen/v1/models", zenModelRoutes);
 server.route("/zen/v1/messages", zenMessageRoutes);
+server.route("/antigravity/v1/chat/completions", antigravityChatCompletionsRoute);
+server.route("/antigravity/v1/models", antigravityModelsRoute);
+server.route("/antigravity/v1/messages", antigravityMessagesRoute);
 
 //#endregion
 //#region src/start.ts
@@ -1386,7 +2348,9 @@ server.route("/zen/v1/messages", zenMessageRoutes);
 *   - zenApiKey: OpenCode Zen API key (optional; if omitted will prompt for setup)
 */
 async function runServer(options) {
+	const savedProxyApplied = await applyProxyConfig();
 	if (options.proxyEnv) initProxyFromEnv();
+	else if (savedProxyApplied) initProxyFromEnv();
 	if (options.verbose) {
 		consola.level = 5;
 		consola.info("Verbose logging enabled");
@@ -1407,23 +2371,40 @@ async function runServer(options) {
 			state.zenApiKey = options.zenApiKey;
 			consola.info("Using provided Zen API key");
 		} else {
-			const { setupZenApiKey, loadZenAuth } = await import("./auth-KlL1W4gV.js");
+			const { setupZenApiKey, loadZenAuth } = await import("./auth-BO-mwvoU.js");
 			const existingAuth = await loadZenAuth();
 			if (existingAuth) {
 				state.zenApiKey = existingAuth.apiKey;
 				consola.info("Using existing Zen API key");
 			} else state.zenApiKey = await setupZenApiKey();
 		}
-		const { cacheZenModels } = await import("./get-models-Hlxa1hWY.js");
+		const { cacheZenModels } = await import("./get-models-DJfPj_Rg.js");
 		await cacheZenModels();
 		consola.info(`Available Zen models: \n${state.zenModels?.data.map((model) => `- ${model.id}`).join("\n")}`);
+	} else if (options.antigravity) {
+		consola.info("Google Antigravity mode enabled");
+		state.antigravityMode = true;
+		const { loadAntigravityAuth, setupAntigravity, getCurrentAccount } = await import("./auth-D2wtETTq.js");
+		const existingAuth = await loadAntigravityAuth();
+		if (!existingAuth || existingAuth.accounts.length === 0) {
+			consola.warn("No Antigravity accounts found");
+			await setupAntigravity();
+		} else {
+			const enabledCount = existingAuth.accounts.filter((a) => a.enable).length;
+			consola.info(`Found ${existingAuth.accounts.length} Antigravity accounts (${enabledCount} enabled)`);
+		}
+		if (!await getCurrentAccount()) throw new Error("No enabled Antigravity accounts available");
+		const { getAntigravityModels: getAntigravityModels$1 } = await import("./get-models-Dq2ZDU9m.js");
+		const models = await getAntigravityModels$1();
+		state.antigravityModels = models;
+		consola.info(`Available Antigravity models: \n${models.data.map((model) => `- ${model.id}`).join("\n")}`);
 	} else {
 		await cacheVSCodeVersion();
 		if (options.githubToken) {
 			state.githubToken = options.githubToken;
 			consola.info("Using provided GitHub token");
 			try {
-				const { getGitHubUser } = await import("./get-user-M3sQS0U8.js");
+				const { getGitHubUser } = await import("./get-user-hpkh0FzZ.js");
 				const user = await getGitHubUser();
 				consola.info(`Logged in as ${user.login}`);
 			} catch (error) {
@@ -1437,7 +2418,7 @@ async function runServer(options) {
 			const { HTTPError: HTTPError$1 } = await import("./error-CsShqJjE.js");
 			if (error instanceof HTTPError$1 && error.response.status === 401) {
 				consola.error("Failed to get Copilot token - GitHub token may be invalid or Copilot access revoked");
-				const { clearGithubToken: clearGithubToken$1 } = await import("./token-BssxOyqn.js");
+				const { clearGithubToken: clearGithubToken$1 } = await import("./token-DS09XjQ5.js");
 				await clearGithubToken$1();
 				consola.info("Please restart to re-authenticate");
 			}
@@ -1448,7 +2429,7 @@ async function runServer(options) {
 	}
 	const serverUrl = `http://localhost:${options.port}`;
 	if (options.claudeCode) {
-		const models = state.zenMode ? state.zenModels : state.models;
+		const models = state.zenMode ? state.zenModels : state.antigravityMode ? state.antigravityModels : state.models;
 		invariant(models, "Models should be loaded by now");
 		const selectedModel = await consola.prompt("Select a model to use with Claude Code", {
 			type: "select",
@@ -1556,6 +2537,11 @@ const start = defineCommand({
 		"zen-api-key": {
 			type: "string",
 			description: "OpenCode Zen API key (get from https://opencode.ai/zen)"
+		},
+		antigravity: {
+			type: "boolean",
+			default: false,
+			description: "Enable Google Antigravity mode (proxy to Antigravity instead of GitHub Copilot)"
 		}
 	},
 	run({ args }) {
@@ -1577,7 +2563,8 @@ const start = defineCommand({
 			proxyEnv: args["proxy-env"],
 			apiKeys,
 			zen: args.zen,
-			zenApiKey: args["zen-api-key"]
+			zenApiKey: args["zen-api-key"],
+			antigravity: args.antigravity
 		});
 	}
 });
@@ -1594,7 +2581,8 @@ const main = defineCommand({
 		start,
 		"check-usage": checkUsage,
 		debug,
-		logout
+		logout,
+		proxy
 	}
 });
 await runMain(main);