pi-ui-extend 0.1.1

package/external/pi-tools-suite/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "pi-tools-suite-local",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "description": "Local all-in-one Pi extension package for ast-grep, async subagents, LSP, model tools, and todos.",
+  "keywords": [
+    "pi-package",
+    "pi-extension"
+  ],
+  "module": "./src/index.ts",
+  "files": [
+    "index.ts",
+    "src",
+    "docs",
+    "licenses",
+    "README.md"
+  ],
+  "scripts": {
+    "smoke:explicit": "PI_OFFLINE=1 pi --extension ./index.ts --no-session --no-tools -p \"ping\"",
+    "smoke:auto": "PI_OFFLINE=1 pi --no-session --no-tools -p \"ping\"",
+    "smoke:tools": "PI_OFFLINE=1 pi --no-session -p \"ping\"",
+    "smoke": "npm run smoke:explicit && npm run smoke:auto && npm run smoke:tools",
+    "test": "bun test test",
+    "test:async-subagents-e2e": "ASYNC_SUBAGENTS_E2E=1 ASYNC_SUBAGENTS_MODEL=zai/glm-5-turbo bun test --concurrent --max-concurrency=30 test/async-subagents",
+    "test:async-subagents-selection-e2e": "ASYNC_SUBAGENTS_SELECTION_E2E=1 ASYNC_SUBAGENTS_MODEL=zai/glm-5-turbo bun test --concurrent --max-concurrency=30 test/async-subagents/selection-e2e.test.ts",
+    "bench:locate": "PI_LOCATE_BENCH_ITERATIONS=5 PI_LOCATE_BENCH_FAKE_IDX=0 PI_LOCATE_BENCH_MODEL=zai/glm-5-turbo PI_LOCATE_BENCH_MODES=direct-read-grep,ast-structural,repo-search-hybrid,repo-discovery,subagent-search,unrestricted-suite node test/fixtures/hard-to-find-project/benchmark/run-locate-benchmark.mjs",
+    "bench:locate:analyze": "node test/fixtures/hard-to-find-project/benchmark/analyze-locate-benchmark.mjs",
+    "test:locate-benchmark-e2e": "PI_LOCATE_BENCH_E2E=1 PI_LOCATE_BENCH_MODEL=zai/glm-5-turbo bun test test/locate-benchmark-e2e.test.ts",
+    "test:tool-selection-e2e": "TOOL_SELECTION_E2E=1 TOOL_SELECTION_E2E_MODEL=zai/glm-5-turbo bun test --concurrent --max-concurrency=30 test/tool-selection-e2e.test.ts",
+    "test:e2e": "TOOL_SELECTION_E2E=1 TOOL_SELECTION_E2E_MODEL=zai/glm-5-turbo ASYNC_SUBAGENTS_E2E=1 ASYNC_SUBAGENTS_MODEL=zai/glm-5-turbo bun test --concurrent --max-concurrency=5 test/tool-selection-e2e.test.ts test/async-subagents/e2e.test.ts test/async-subagents/selection-e2e.test.ts test/todo-persistence-e2e.test.ts",
+    "typecheck:async-subagents": "bash scripts/typecheck-source.sh",
+    "check": "npm run smoke"
+  },
+  "dependencies": {
+    "jsonc-parser": "^3.3.1",
+    "vscode-jsonrpc": "^8.2.1",
+    "vscode-languageserver-protocol": "^3.17.5"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "@mariozechner/pi-ai": "*",
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-tui": "*",
+    "typebox": "*"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5"
+  }
+}

package/external/pi-tools-suite/src/antigravity-auth/auth-store.ts

@@ -0,0 +1,194 @@
+import { promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { DEFAULT_PROJECT_ID, PROVIDER_ID } from "./constants";
+import type { OpencodeAntigravityAccount, OpencodeAntigravityImportResult, OpencodeAntigravityStorage, PiAuthCredential, PiAuthData } from "./types";
+
+export function splitRefresh(refresh: string): { refreshToken: string; projectId?: string; managedProjectId?: string } {
+	const [refreshToken = "", projectId = "", managedProjectId = ""] = refresh.split("|");
+	return {
+		refreshToken: refreshToken || refresh,
+		projectId: projectId || undefined,
+		managedProjectId: managedProjectId || undefined,
+	};
+}
+
+export function joinRefresh(refreshToken: string, projectId?: string, managedProjectId?: string): string {
+	const base = `${refreshToken}|${projectId ?? ""}`;
+	return managedProjectId ? `${base}|${managedProjectId}` : base;
+}
+
+export function getEffectiveProjectId(refresh: string): string | undefined {
+	const { projectId, managedProjectId } = splitRefresh(refresh);
+	return projectId || managedProjectId;
+}
+
+export function encodeApiKey(access: string, projectId?: string): string {
+	return projectId ? `${access}|${projectId}` : access;
+}
+
+export function decodeApiKey(apiKey: string): { access: string; projectId?: string } {
+	const [access = apiKey, projectId = ""] = apiKey.split("|");
+	return { access, projectId: projectId || undefined };
+}
+
+function getDefaultOpencodeAccountsPath(): string {
+	const configDir = process.env.OPENCODE_CONFIG_DIR ?? join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "opencode");
+	return join(configDir, "antigravity-accounts.json");
+}
+
+export function getPiAuthPath(): string {
+	return join(getAgentDir(), "auth.json");
+}
+
+export async function readJsonFile<T>(path: string, fallback: T): Promise<T> {
+	try {
+		return JSON.parse(await fs.readFile(path, "utf8")) as T;
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return fallback;
+		throw error;
+	}
+}
+
+export async function writeJsonFileSecure(path: string, data: unknown): Promise<void> {
+	await fs.mkdir(dirname(path), { recursive: true });
+	await fs.writeFile(path, `${JSON.stringify(data, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+	await fs.chmod(path, 0o600).catch(() => undefined);
+}
+
+export function getStoredAccounts(credential?: PiAuthCredential): OpencodeAntigravityAccount[] {
+	return Array.isArray(credential?.accounts) ? credential.accounts.filter((account) => account.enabled !== false && account.refreshToken) : [];
+}
+
+export function clampAccountIndex(index: unknown, accountCount: number): number {
+	if (!Number.isInteger(index) || accountCount <= 0) return 0;
+	return Math.max(0, Math.min(index as number, accountCount - 1));
+}
+
+export function getAccountProjectId(account: OpencodeAntigravityAccount): string {
+	return account.projectId || account.managedProjectId || DEFAULT_PROJECT_ID;
+}
+
+export function accountFromCredential(credential?: PiAuthCredential): OpencodeAntigravityAccount | undefined {
+	if (credential?.type !== "oauth" || !credential.refresh) return undefined;
+	const refresh = splitRefresh(credential.refresh);
+	if (!refresh.refreshToken) return undefined;
+	return {
+		email: credential.email,
+		refreshToken: refresh.refreshToken,
+		projectId: refresh.projectId || refresh.managedProjectId || DEFAULT_PROJECT_ID,
+		managedProjectId: refresh.managedProjectId,
+		enabled: true,
+	};
+}
+
+export function findMatchingAccountIndex(accounts: OpencodeAntigravityAccount[], account: OpencodeAntigravityAccount): number {
+	const email = account.email?.toLowerCase();
+	if (email) {
+		const byEmail = accounts.findIndex((existing) => existing.email?.toLowerCase() === email);
+		if (byEmail >= 0) return byEmail;
+	}
+	if (account.refreshToken) {
+		return accounts.findIndex((existing) => existing.refreshToken === account.refreshToken);
+	}
+	return -1;
+}
+
+function selectOpencodeAccount(
+	storage: OpencodeAntigravityStorage,
+	options: { accountIndex?: number; email?: string },
+): { account: OpencodeAntigravityAccount; index: number; count: number } | undefined {
+	const accounts = storage.accounts?.filter((account) => account && typeof account.refreshToken === "string" && account.refreshToken) ?? [];
+	if (accounts.length === 0) return undefined;
+
+	if (options.email) {
+		const email = options.email.toLowerCase();
+		const index = accounts.findIndex((account) => account.email?.toLowerCase() === email);
+		return index >= 0 ? { account: accounts[index], index, count: accounts.length } : undefined;
+	}
+
+	if (typeof options.accountIndex === "number") {
+		const index = options.accountIndex;
+		return index >= 0 && index < accounts.length ? { account: accounts[index], index, count: accounts.length } : undefined;
+	}
+
+	const activeIndex = Number.isInteger(storage.activeIndex) ? Math.max(0, Math.min(storage.activeIndex ?? 0, accounts.length - 1)) : 0;
+	const activeAccount = accounts[activeIndex];
+	if (activeAccount?.enabled !== false) return { account: activeAccount, index: activeIndex, count: accounts.length };
+
+	const firstEnabledIndex = accounts.findIndex((account) => account.enabled !== false);
+	return firstEnabledIndex >= 0 ? { account: accounts[firstEnabledIndex], index: firstEnabledIndex, count: accounts.length } : undefined;
+}
+
+export async function importOpencodeAntigravityAccount(options: {
+	sourcePath?: string;
+	authPath?: string;
+	overwrite?: boolean;
+	accountIndex?: number;
+	email?: string;
+} = {}): Promise<OpencodeAntigravityImportResult> {
+	const sourcePath = options.sourcePath ?? getDefaultOpencodeAccountsPath();
+	const authPath = options.authPath ?? getPiAuthPath();
+	const storage = await readJsonFile<OpencodeAntigravityStorage | null>(sourcePath, null);
+	if (!storage || !Array.isArray(storage.accounts)) {
+		return { imported: false, reason: "source-missing-or-invalid", sourcePath, authPath };
+	}
+
+	const selected = selectOpencodeAccount(storage, options);
+	if (!selected) {
+		return { imported: false, reason: "matching-account-not-found", sourcePath, authPath, accountCount: storage.accounts.length };
+	}
+
+	const piAuth = await readJsonFile<PiAuthData>(authPath, {});
+	const existing = piAuth[PROVIDER_ID];
+	const refresh = joinRefresh(
+		selected.account.refreshToken!,
+		selected.account.projectId || selected.account.managedProjectId || DEFAULT_PROJECT_ID,
+		selected.account.managedProjectId,
+	);
+
+	if (existing?.type === "oauth" && existing.refresh === refresh) {
+		return {
+			imported: false,
+			reason: "already-imported",
+			sourcePath,
+			authPath,
+			email: selected.account.email,
+			accountIndex: selected.index,
+			accountCount: selected.count,
+		};
+	}
+	if (existing && !options.overwrite) {
+		return {
+			imported: false,
+			reason: "auth-exists-use-force",
+			sourcePath,
+			authPath,
+			email: selected.account.email,
+			accountIndex: selected.index,
+			accountCount: selected.count,
+		};
+	}
+
+	piAuth[PROVIDER_ID] = {
+		type: "oauth",
+		refresh,
+		access: "",
+		expires: 0,
+		email: selected.account.email,
+		accounts: storage.accounts.filter((account) => account.enabled !== false && account.refreshToken),
+		activeIndex: selected.index,
+	};
+	await writeJsonFileSecure(authPath, piAuth);
+
+	return {
+		imported: true,
+		sourcePath,
+		authPath,
+		email: selected.account.email,
+		accountIndex: selected.index,
+		accountCount: selected.count,
+		overwroteExisting: !!existing,
+	};
+}

package/external/pi-tools-suite/src/antigravity-auth/commands.ts

@@ -0,0 +1,80 @@
+import type { AntigravityAddAccountResult, AntigravityStatusDetails, OpencodeAntigravityImportResult } from "./types";
+
+function tokenizeArgs(args: string): string[] {
+	return args.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)?.map((part) => part.replace(/^("|')|("|')$/g, "")) ?? [];
+}
+
+export function parseImportCommandArgs(args: string): { sourcePath?: string; overwrite?: boolean; accountIndex?: number; email?: string } {
+	const tokens = tokenizeArgs(args);
+	const parsed: { sourcePath?: string; overwrite?: boolean; accountIndex?: number; email?: string } = {};
+	for (let i = 0; i < tokens.length; i += 1) {
+		const token = tokens[i];
+		if (token === "--force" || token === "-f") {
+			parsed.overwrite = true;
+		} else if (token === "--path" && tokens[i + 1]) {
+			parsed.sourcePath = tokens[++i];
+		} else if ((token === "--index" || token === "--account-index") && tokens[i + 1]) {
+			const index = Number(tokens[++i]);
+			if (Number.isInteger(index)) parsed.accountIndex = index;
+		} else if (token === "--email" && tokens[i + 1]) {
+			parsed.email = tokens[++i];
+		} else if (!token.startsWith("-") && !parsed.sourcePath) {
+			parsed.sourcePath = token;
+		}
+	}
+	return parsed;
+}
+
+export function formatImportResult(result: OpencodeAntigravityImportResult): string {
+	const account = result.email ? `${result.email} ` : "";
+	const position = typeof result.accountIndex === "number" && result.accountCount ? `(account ${result.accountIndex}/${result.accountCount - 1}) ` : "";
+	if (result.imported) {
+		return `Imported ${account}${position}from ${result.sourcePath} into ${result.authPath}. Token will refresh on first use.${result.overwroteExisting ? " Existing Antigravity auth was overwritten." : ""}`;
+	}
+	if (result.reason === "auth-exists-use-force") {
+		return `Antigravity auth already exists in ${result.authPath}; run /antigravity-import --force to overwrite it with ${account}${position}from ${result.sourcePath}.`;
+	}
+	if (result.reason === "already-imported") {
+		return `Antigravity auth is already imported from ${result.sourcePath} (${account}${position.trim()}).`;
+	}
+	return `Could not import Antigravity auth from ${result.sourcePath}: ${result.reason ?? "unknown error"}.`;
+}
+
+export function parseAddAccountCommandArgs(args: string): { activate?: boolean; email?: string; authPath?: string } {
+	const tokens = tokenizeArgs(args);
+	const parsed: { activate?: boolean; email?: string; authPath?: string } = {};
+	for (let i = 0; i < tokens.length; i += 1) {
+		const token = tokens[i];
+		if (token === "--activate" || token === "-a") {
+			parsed.activate = true;
+		} else if (token === "--email" && tokens[i + 1]) {
+			parsed.email = tokens[++i];
+		} else if (token === "--auth-path" && tokens[i + 1]) {
+			parsed.authPath = tokens[++i];
+		}
+	}
+	return parsed;
+}
+
+export function formatAddAccountResult(result: AntigravityAddAccountResult): string {
+	const account = result.email ?? "unknown account";
+	const action = result.updatedExisting ? "Updated" : "Added";
+	const active = result.activated ? " and activated" : "";
+	const project = result.projectId ? ` project ${result.projectId}` : "";
+	return `${action} Antigravity account ${account}${active} (${result.accountIndex + 1}/${result.accountCount})${project}. Saved to ${result.authPath}.`;
+}
+
+function formatAccountPosition(index?: number, count?: number): string {
+	return typeof index === "number" && typeof count === "number" ? `${index + 1}/${count}` : "unknown";
+}
+
+export function formatAntigravityStatus(details: AntigravityStatusDetails): string {
+	const account = details.email ?? "unknown account";
+	const position = formatAccountPosition(details.accountIndex, details.accountCount);
+	const project = details.projectId ? ` project ${details.projectId}` : "";
+	if (details.kind === "switch") {
+		return `Antigravity switched to ${account} (${position})`;
+	}
+	const expiry = details.expires && details.expires > 0 ? ` token expires ${new Date(details.expires).toLocaleTimeString()}` : " token will refresh on next use";
+	return `Antigravity current account: ${account} (${position})${project};${expiry}.`;
+}

package/external/pi-tools-suite/src/antigravity-auth/constants.ts

@@ -0,0 +1,26 @@
+export const PROVIDER_ID = "antigravity";
+export const API_ID = "antigravity-unified-gateway";
+export const STATUS_KEY = "dcp:antigravity";
+export const LEGACY_STATUS_KEY = "antigravity";
+export const ALL_ACCOUNTS_EXHAUSTED_MARKER = "ANTIGRAVITY_ALL_ACCOUNTS_EXHAUSTED";
+
+export const CLIENT_ID = process.env.PIX_ANTIGRAVITY_GOOGLE_CLIENT_ID ?? process.env.ANTIGRAVITY_GOOGLE_CLIENT_ID ?? "";
+export const CLIENT_SECRET = process.env.PIX_ANTIGRAVITY_GOOGLE_CLIENT_SECRET ?? process.env.ANTIGRAVITY_GOOGLE_CLIENT_SECRET ?? "";
+export const REDIRECT_URI = "http://localhost:51121/oauth-callback";
+export const SCOPES = [
+	"https://www.googleapis.com/auth/cloud-platform",
+	"https://www.googleapis.com/auth/userinfo.email",
+	"https://www.googleapis.com/auth/userinfo.profile",
+	"https://www.googleapis.com/auth/cclog",
+	"https://www.googleapis.com/auth/experimentsandconfigs",
+];
+
+export const ENDPOINT_DAILY = "https://daily-cloudcode-pa.sandbox.googleapis.com";
+export const ENDPOINT_PROD = "https://cloudcode-pa.googleapis.com";
+export const ENDPOINT_AUTOPUSH = "https://autopush-cloudcode-pa.sandbox.googleapis.com";
+export const STREAM_ENDPOINTS = [ENDPOINT_DAILY, ENDPOINT_AUTOPUSH, ENDPOINT_PROD];
+export const LOAD_ENDPOINTS = [ENDPOINT_PROD, ENDPOINT_DAILY, ENDPOINT_AUTOPUSH];
+export const DEFAULT_PROJECT_ID = "rising-fact-p41fc";
+export const TOKEN_EXPIRY_SKEW_MS = 5 * 60 * 1000;
+export const SKIP_THOUGHT_SIGNATURE = "skip_thought_signature_validator";
+export const MIN_THOUGHT_SIGNATURE_LENGTH = 50;

package/external/pi-tools-suite/src/antigravity-auth/headers.ts

@@ -0,0 +1,20 @@
+import type { AntigravityModel, HeaderStyle } from "./types";
+
+export function getAntigravityHeaders(style: "antigravity" | "gemini-cli" = "antigravity"): Record<string, string> {
+	if (style === "gemini-cli") {
+		return {
+			"User-Agent": "google-api-nodejs-client/9.15.1",
+			"X-Goog-Api-Client": "gl-node/22.17.0",
+			"Client-Metadata": "ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI",
+		};
+	}
+	return {
+		"User-Agent": "antigravity/1.18.3 darwin/arm64",
+		"X-Goog-Api-Client": "google-cloud-sdk vscode_cloudshelleditor/0.1",
+		"Client-Metadata": `{"ideType":"ANTIGRAVITY","platform":"${process.platform === "win32" ? "WINDOWS" : "MACOS"}","pluginType":"GEMINI"}`,
+	};
+}
+
+export function getModelHeaderStyle(model: AntigravityModel): HeaderStyle {
+	return model.antigravityHeaderStyle ?? "antigravity";
+}

package/external/pi-tools-suite/src/antigravity-auth/index.ts

@@ -0,0 +1,104 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { decodeApiKey, getEffectiveProjectId, importOpencodeAntigravityAccount } from "./auth-store";
+import { formatAddAccountResult, formatImportResult, parseAddAccountCommandArgs, parseImportCommandArgs } from "./commands";
+import { API_ID, DEFAULT_PROJECT_ID, ENDPOINT_DAILY, PROVIDER_ID } from "./constants";
+import { modelDefinitions } from "./models";
+import { addAntigravityAccount, loginAntigravity, refreshAntigravityToken } from "./oauth";
+import { emitAntigravityStatus, getCurrentAntigravityStatus, publishAntigravityAuthStartupSection, rememberAntigravityApi, rememberAntigravityUi } from "./status";
+import { streamAntigravity } from "./stream";
+
+export { importOpencodeAntigravityAccount } from "./auth-store";
+export { addAntigravityAccount } from "./oauth";
+export type { AntigravityAddAccountResult, OpencodeAntigravityImportResult } from "./types";
+
+export default async function antigravityAuth(pi: ExtensionAPI): Promise<void> {
+	rememberAntigravityApi(pi);
+	await publishAntigravityAuthStartupSection();
+
+	if (typeof pi.on === "function") {
+		pi.on("turn_start", (_event, ctx) => {
+			rememberAntigravityUi(ctx.ui);
+		});
+		pi.on("before_provider_request", (_event, ctx) => {
+			rememberAntigravityUi(ctx.ui);
+		});
+	}
+
+	pi.registerCommand("antigravity-import", {
+		description: "Import Antigravity OAuth from opencode antigravity-accounts.json into Pi auth.json",
+		handler: async (args: string, ctx: any) => {
+			try {
+				const result = await importOpencodeAntigravityAccount(parseImportCommandArgs(args));
+				ctx.ui?.notify?.(formatImportResult(result), result.imported ? "info" : result.reason === "auth-exists-use-force" ? "warn" : "error");
+			} catch (error) {
+				ctx.ui?.notify?.(error instanceof Error ? error.message : String(error), "error");
+			}
+		},
+	});
+
+	pi.registerCommand("antigravity-add-account", {
+		description: "Add a new Google Antigravity OAuth account to the Pi rotation pool",
+		handler: async (args: string, ctx: any) => {
+			rememberAntigravityUi(ctx.ui);
+			let authUrl = "";
+			try {
+				const options = parseAddAccountCommandArgs(args);
+				const result = await addAntigravityAccount(
+					{
+						onAuth: ({ url }) => {
+							authUrl = url;
+							ctx.ui?.notify?.(`Open this Antigravity OAuth URL, then paste the callback URL:\n${url}`, "info");
+						},
+						onPrompt: async ({ message }) => {
+							if (typeof ctx.ui?.input !== "function") {
+								throw new Error(`Interactive input is required. Open this URL and rerun in an interactive Pi session: ${authUrl}`);
+							}
+							const value = await ctx.ui.input("Antigravity OAuth callback URL", message);
+							if (!value) throw new Error("Antigravity OAuth was cancelled.");
+							return value;
+						},
+					},
+					options,
+				);
+				ctx.ui?.notify?.(formatAddAccountResult(result), "info");
+				emitAntigravityStatus(await getCurrentAntigravityStatus());
+			} catch (error) {
+				ctx.ui?.notify?.(error instanceof Error ? error.message : String(error), "error");
+			}
+		},
+	});
+
+	pi.registerCommand("antigravity-account", {
+		description: "Show the current Antigravity account, project, and rotation position",
+		handler: async (_args: string, ctx: any) => {
+			rememberAntigravityUi(ctx.ui);
+			emitAntigravityStatus(await getCurrentAntigravityStatus());
+		},
+	});
+
+	pi.registerCommand("antigravity-status", {
+		description: "Alias for /antigravity-account",
+		handler: async (_args: string, ctx: any) => {
+			rememberAntigravityUi(ctx.ui);
+			emitAntigravityStatus(await getCurrentAntigravityStatus());
+		},
+	});
+
+	pi.registerProvider(PROVIDER_ID, {
+		name: "Google Antigravity OAuth",
+		baseUrl: ENDPOINT_DAILY,
+		api: API_ID,
+		models: modelDefinitions.map((model) => ({ ...model })) as any,
+		oauth: {
+			name: "Google Antigravity OAuth",
+			login: loginAntigravity,
+			refreshToken: refreshAntigravityToken,
+			getApiKey: (credentials) => credentials.access,
+			modifyModels: (models, credentials) => {
+				const accessProjectId = decodeApiKey(credentials.access).projectId;
+				return models.map((model) => ({ ...model, antigravityProjectId: accessProjectId || getEffectiveProjectId(credentials.refresh) || DEFAULT_PROJECT_ID }));
+			},
+		},
+		streamSimple: streamAntigravity as any,
+	});
+}

package/external/pi-tools-suite/src/antigravity-auth/models.ts

@@ -0,0 +1,86 @@
+export const modelDefinitions = [
+	{
+		id: "antigravity-gemini-3.1-pro",
+		name: "Gemini 3.1 Pro (Antigravity)",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: 1_048_576,
+		maxTokens: 65_535,
+		thinkingLevelMap: { minimal: null, low: "low", medium: null, high: null, xhigh: null },
+	},
+	{
+		id: "antigravity-gemini-3-flash",
+		name: "Gemini 3 Flash (Antigravity)",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: 1_048_576,
+		maxTokens: 65_536,
+		thinkingLevelMap: { minimal: "minimal", low: "low", medium: "medium", high: "high", xhigh: null },
+	},
+	// These Gemini CLI-named models mirror opencode's provider surface, but opencode
+	// routes them Antigravity-first unless cli_first is enabled.
+	{
+		id: "gemini-2.5-flash",
+		name: "Gemini 2.5 Flash (Gemini CLI)",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: 1_048_576,
+		maxTokens: 65_535,
+		antigravityHeaderStyle: "antigravity",
+	},
+	{
+		id: "gemini-3-flash-preview",
+		name: "Gemini 3 Flash Preview (Gemini CLI)",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: 1_048_576,
+		maxTokens: 65_536,
+		thinkingLevelMap: { minimal: "minimal", low: "low", medium: "medium", high: "high", xhigh: null },
+		antigravityHeaderStyle: "antigravity",
+	},
+	{
+		id: "gemini-3.1-pro-preview",
+		name: "Gemini 3.1 Pro Preview (Gemini CLI)",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: 1_048_576,
+		maxTokens: 65_535,
+		thinkingLevelMap: { minimal: null, low: "low", medium: null, high: null, xhigh: null },
+		antigravityHeaderStyle: "antigravity",
+	},
+	{
+		id: "gemini-3.1-pro-preview-customtools",
+		name: "Gemini 3.1 Pro Preview Custom Tools (Gemini CLI)",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: 1_048_576,
+		maxTokens: 65_535,
+		thinkingLevelMap: { minimal: null, low: "low", medium: null, high: null, xhigh: null },
+		antigravityHeaderStyle: "antigravity",
+	},
+	{
+		id: "antigravity-claude-sonnet-4-6",
+		name: "Claude Sonnet 4.6 (Antigravity)",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: 200_000,
+		maxTokens: 64_000,
+	},
+	{
+		id: "antigravity-claude-opus-4-6-thinking",
+		name: "Claude Opus 4.6 Thinking (Antigravity)",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: 200_000,
+		maxTokens: 64_000,
+		thinkingLevelMap: { minimal: null, low: "low", medium: "medium", high: "high", xhigh: "high" },
+	},
+];