@f5-sales-demo/pi-ai 19.51.2

package/src/providers/google-gemini-cli.ts

@@ -0,0 +1,1133 @@
+/**
+ * Google Gemini CLI / Antigravity provider.
+ * Shared implementation for both google-gemini-cli and google-antigravity providers.
+ * Uses the Cloud Code Assist API endpoint to access Gemini and Claude models.
+ */
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { abortableSleep, readSseJson } from "@f5xc-salesdemos/pi-utils";
+import type { Content, FunctionCallingConfigMode, ThinkingConfig } from "@google/genai";
+import { calculateCost } from "../models";
+import type {
+	Api,
+	AssistantMessage,
+	Context,
+	Model,
+	StreamFunction,
+	StreamOptions,
+	TextContent,
+	ThinkingContent,
+	ToolCall,
+} from "../types";
+import { AssistantMessageEventStream } from "../utils/event-stream";
+import { appendRawHttpRequestDumpFor400, type RawHttpRequestDump, withHttpStatus } from "../utils/http-inspector";
+import { refreshAntigravityToken } from "../utils/oauth/google-antigravity";
+import { refreshGoogleCloudToken } from "../utils/oauth/google-gemini-cli";
+import { extractHttpStatusFromError } from "../utils/retry";
+import { sanitizeSchemaForCCA } from "../utils/schema";
+import {
+	convertMessages,
+	convertTools,
+	isThinkingPart,
+	mapStopReasonString,
+	mapToolChoice,
+	retainThoughtSignature,
+} from "./google-shared";
+
+/**
+ * Thinking level for Gemini 3 models.
+ * Mirrors Google's ThinkingLevel enum values.
+ */
+export type GoogleThinkingLevel = "THINKING_LEVEL_UNSPECIFIED" | "MINIMAL" | "LOW" | "MEDIUM" | "HIGH";
+
+export interface GoogleGeminiCliOptions extends StreamOptions {
+	toolChoice?: "auto" | "none" | "any";
+	/**
+	 * Thinking/reasoning configuration.
+	 * - Gemini 2.x models: use `budgetTokens` to set the thinking budget
+	 * - Gemini 3 models (gemini-3-pro-*, gemini-3-flash-*): use `level` instead
+	 *
+	 * When using `streamSimple`, this is handled automatically based on the model.
+	 */
+	thinking?: {
+		enabled: boolean;
+		/** Thinking budget in tokens. Use for Gemini 2.x models. */
+		budgetTokens?: number;
+		/** Thinking level. Use for Gemini 3 models (LOW/HIGH for Pro, MINIMAL/LOW/MEDIUM/HIGH for Flash). */
+		level?: GoogleThinkingLevel;
+	};
+	projectId?: string;
+}
+
+const DEFAULT_ENDPOINT = "https://cloudcode-pa.googleapis.com";
+const ANTIGRAVITY_DAILY_ENDPOINT = "https://daily-cloudcode-pa.googleapis.com";
+const ANTIGRAVITY_SANDBOX_ENDPOINT = "https://daily-cloudcode-pa.sandbox.googleapis.com";
+const ANTIGRAVITY_ENDPOINT_FALLBACKS = [ANTIGRAVITY_DAILY_ENDPOINT, ANTIGRAVITY_SANDBOX_ENDPOINT] as const;
+
+/**
+ * Build a User-Agent string that identifies as Gemini CLI to unlock higher rate limits.
+ * Uses the same format as the official Gemini CLI (v0.35+):
+ * GeminiCLI/VERSION/MODEL (PLATFORM; ARCH; SURFACE)
+ */
+export function getGeminiCliUserAgent(modelId = "gemini-3.1-pro-preview"): string {
+	const version = process.env.PI_AI_GEMINI_CLI_VERSION || "0.35.3";
+	const platform = process.platform === "win32" ? "win32" : process.platform;
+	const arch = process.arch === "x64" ? "x64" : process.arch;
+	return `GeminiCLI/${version}/${modelId} (${platform}; ${arch}; terminal)`;
+}
+
+const ANTIGRAVITY_USER_AGENT = (() => {
+	const DEFAULT_ANTIGRAVITY_VERSION = "1.104.0";
+	const version = process.env.PI_AI_ANTIGRAVITY_VERSION || DEFAULT_ANTIGRAVITY_VERSION;
+	// Map Node.js platform/arch to Antigravity's expected format.
+	// Verified against Antigravity source: _qn() and wqn() in main.js.
+	// process.platform: win32→windows, others pass through (darwin, linux)
+	// process.arch:     x64→amd64, ia32→386, others pass through (arm64)
+	const os = process.platform === "win32" ? "windows" : process.platform;
+	const arch = process.arch === "x64" ? "amd64" : process.arch === "ia32" ? "386" : process.arch;
+	return `antigravity/${version} ${os}/${arch}`;
+})();
+
+const GEMINI_CLI_HEADERS = (modelId?: string) =>
+	Object.freeze({
+		"User-Agent": getGeminiCliUserAgent(modelId),
+		"Client-Metadata": "ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI",
+	});
+
+// Antigravity auth headers (project discovery/onboarding).
+// Verified from binary: kae.w() and kae.y() send only Content-Type + User-Agent.
+// X-Goog-Api-Client and Client-Metadata are NOT sent by the real client — product
+// identification (ideType, ideName, ideVersion) goes in the protobuf request body.
+const ANTIGRAVITY_AUTH_HEADERS = Object.freeze({
+	"User-Agent": ANTIGRAVITY_USER_AGENT,
+});
+
+// Antigravity executor headers (streaming/generation).
+// Same header set as auth calls — only User-Agent per binary analysis.
+const ANTIGRAVITY_STREAMING_HEADERS = Object.freeze({
+	"User-Agent": ANTIGRAVITY_USER_AGENT,
+});
+
+// Headers for Gemini CLI (prod endpoint)
+export function getGeminiCliHeaders(modelId?: string) {
+	return GEMINI_CLI_HEADERS(modelId);
+}
+export function getGeminiCliUserAgentValue(modelId?: string) {
+	return getGeminiCliUserAgent(modelId);
+}
+
+// Headers for Antigravity (sandbox endpoint)
+export function getAntigravityAuthHeaders() {
+	return ANTIGRAVITY_AUTH_HEADERS;
+}
+export function getAntigravityHeaders() {
+	return ANTIGRAVITY_STREAMING_HEADERS;
+}
+export function getAntigravityUserAgent() {
+	return ANTIGRAVITY_USER_AGENT;
+}
+
+// Antigravity system instruction (compact version from CLIProxyAPI).
+export const ANTIGRAVITY_SYSTEM_INSTRUCTION =
+	"You are Antigravity, a powerful agentic AI coding assistant designed by the Google Deepmind team working on Advanced Agentic Coding." +
+	"You are pair programming with a USER to solve their coding task. The task may require creating a new codebase, modifying or debugging an existing codebase, or simply answering a question." +
+	"**Absolute paths only**" +
+	"**Proactiveness**";
+
+// Counter for generating unique tool call IDs
+let toolCallCounter = 0;
+
+// Retry configuration
+const MAX_RETRIES = 3;
+const BASE_DELAY_MS = 1000;
+const MAX_EMPTY_STREAM_RETRIES = 2;
+const EMPTY_STREAM_BASE_DELAY_MS = 500;
+const RATE_LIMIT_BUDGET_MS = 5 * 60 * 1000;
+const CLAUDE_THINKING_BETA_HEADER = "interleaved-thinking-2025-05-14";
+const GOOGLE_GEMINI_REFRESH_SKEW_MS = 60_000;
+const ANTIGRAVITY_REFRESH_SKEW_MS = 60_000;
+
+/**
+ * Extract retry delay from Gemini error response (in milliseconds).
+ * Checks headers first (Retry-After, x-ratelimit-reset, x-ratelimit-reset-after),
+ * then parses body patterns like:
+ * - "Your quota will reset after 39s"
+ * - "Your quota will reset after 18h31m10s"
+ * - "Please retry in Xs" or "Please retry in Xms"
+ * - "retryDelay": "34.074824224s" (JSON field)
+ */
+export function extractRetryDelay(errorText: string, response?: Response | Headers): number | undefined {
+	const normalizeDelay = (ms: number): number | undefined => (ms > 0 ? Math.ceil(ms + 1000) : undefined);
+
+	const headers = response instanceof Headers ? response : response?.headers;
+	if (headers) {
+		const retryAfter = headers.get("retry-after");
+		if (retryAfter) {
+			const retryAfterSeconds = Number(retryAfter);
+			if (Number.isFinite(retryAfterSeconds)) {
+				const delay = normalizeDelay(retryAfterSeconds * 1000);
+				if (delay !== undefined) {
+					return delay;
+				}
+			}
+			const retryAfterDate = new Date(retryAfter);
+			const retryAfterMs = retryAfterDate.getTime();
+			if (!Number.isNaN(retryAfterMs)) {
+				const delay = normalizeDelay(retryAfterMs - Date.now());
+				if (delay !== undefined) {
+					return delay;
+				}
+			}
+		}
+
+		const rateLimitReset = headers.get("x-ratelimit-reset");
+		if (rateLimitReset) {
+			const resetSeconds = Number.parseInt(rateLimitReset, 10);
+			if (!Number.isNaN(resetSeconds)) {
+				const delay = normalizeDelay(resetSeconds * 1000 - Date.now());
+				if (delay !== undefined) {
+					return delay;
+				}
+			}
+		}
+
+		const rateLimitResetAfter = headers.get("x-ratelimit-reset-after");
+		if (rateLimitResetAfter) {
+			const resetAfterSeconds = Number(rateLimitResetAfter);
+			if (Number.isFinite(resetAfterSeconds)) {
+				const delay = normalizeDelay(resetAfterSeconds * 1000);
+				if (delay !== undefined) {
+					return delay;
+				}
+			}
+		}
+	}
+
+	// Pattern 1: "Your quota will reset after ..." (formats: "18h31m10s", "10m15s", "6s", "39s")
+	const durationMatch = errorText.match(/reset after (?:(\d+)h)?(?:(\d+)m)?(\d+(?:\.\d+)?)s/i);
+	if (durationMatch) {
+		const hours = durationMatch[1] ? parseInt(durationMatch[1], 10) : 0;
+		const minutes = durationMatch[2] ? parseInt(durationMatch[2], 10) : 0;
+		const seconds = parseFloat(durationMatch[3]);
+		if (!Number.isNaN(seconds)) {
+			const totalMs = ((hours * 60 + minutes) * 60 + seconds) * 1000;
+			const delay = normalizeDelay(totalMs);
+			if (delay !== undefined) {
+				return delay;
+			}
+		}
+	}
+
+	// Pattern 2: "Please retry in X[ms|s]"
+	const retryInMatch = errorText.match(/Please retry in ([0-9.]+)(ms|s)/i);
+	if (retryInMatch?.[1]) {
+		const value = parseFloat(retryInMatch[1]);
+		if (!Number.isNaN(value) && value > 0) {
+			const ms = retryInMatch[2].toLowerCase() === "ms" ? value : value * 1000;
+			const delay = normalizeDelay(ms);
+			if (delay !== undefined) {
+				return delay;
+			}
+		}
+	}
+
+	// Pattern 3: "retryDelay": "34.074824224s" (JSON field in error details)
+	const retryDelayMatch = errorText.match(/"retryDelay":\s*"([0-9.]+)(ms|s)"/i);
+	if (retryDelayMatch?.[1]) {
+		const value = parseFloat(retryDelayMatch[1]);
+		if (!Number.isNaN(value) && value > 0) {
+			const ms = retryDelayMatch[2].toLowerCase() === "ms" ? value : value * 1000;
+			const delay = normalizeDelay(ms);
+			if (delay !== undefined) {
+				return delay;
+			}
+		}
+	}
+
+	return undefined;
+}
+
+function isClaudeModel(modelId: string): boolean {
+	return modelId.toLowerCase().includes("claude");
+}
+
+function needsClaudeThinkingBetaHeader(model: Model<"google-gemini-cli">): boolean {
+	return model.provider === "google-antigravity" && model.id.startsWith("claude-") && model.reasoning;
+}
+
+function shouldInjectAntigravitySystemInstruction(modelId: string): boolean {
+	const normalized = modelId.toLowerCase();
+	return normalized.includes("claude") || normalized.includes("gemini-3-pro-high");
+}
+
+/**
+ * Check if an error is retryable (rate limit, server error, network error, etc.)
+ */
+function isRetryableError(status: number, errorText: string): boolean {
+	if (status === 429 || status === 500 || status === 502 || status === 503 || status === 504) {
+		return true;
+	}
+	return /resource.?exhausted|rate.?limit|overloaded|service.?unavailable|other.?side.?closed/i.test(errorText);
+}
+
+/**
+ * Extract a clean, user-friendly error message from Google API error response.
+ * Parses JSON error responses and returns just the message field.
+ */
+function extractErrorMessage(errorText: string): string {
+	try {
+		const parsed = JSON.parse(errorText) as { error?: { message?: string } };
+		if (parsed.error?.message) {
+			return parsed.error.message;
+		}
+	} catch {
+		// Not JSON, return as-is
+	}
+	return errorText;
+}
+
+interface GeminiCliApiKeyPayload {
+	token?: unknown;
+	projectId?: unknown;
+	project_id?: unknown;
+	refreshToken?: unknown;
+	expiresAt?: unknown;
+	refresh?: unknown;
+	expires?: unknown;
+}
+interface ParsedGeminiCliCredentials {
+	accessToken: string;
+	projectId: string;
+	refreshToken?: string;
+	expiresAt?: number;
+}
+
+function normalizeExpiryMs(value: unknown): number | undefined {
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+		return undefined;
+	}
+	return value < 10_000_000_000 ? value * 1000 : value;
+}
+
+export function parseGeminiCliCredentials(apiKeyRaw: string): ParsedGeminiCliCredentials {
+	const invalidCredentialsMessage = "Invalid Google Cloud Code Assist credentials. Use /login to re-authenticate.";
+	const missingCredentialsMessage =
+		"Missing token or projectId in Google Cloud credentials. Use /login to re-authenticate.";
+
+	let parsed: GeminiCliApiKeyPayload;
+	try {
+		parsed = JSON.parse(apiKeyRaw) as GeminiCliApiKeyPayload;
+	} catch {
+		throw new Error(invalidCredentialsMessage);
+	}
+
+	const projectId =
+		typeof parsed.projectId === "string"
+			? parsed.projectId
+			: typeof parsed.project_id === "string"
+				? parsed.project_id
+				: undefined;
+
+	if (typeof parsed.token !== "string" || typeof projectId !== "string") {
+		throw new Error(missingCredentialsMessage);
+	}
+
+	const refreshToken =
+		typeof parsed.refreshToken === "string"
+			? parsed.refreshToken
+			: typeof parsed.refresh === "string"
+				? parsed.refresh
+				: undefined;
+	const expiresAt = normalizeExpiryMs(parsed.expiresAt ?? parsed.expires);
+
+	return {
+		accessToken: parsed.token,
+		projectId,
+		refreshToken,
+		expiresAt,
+	};
+}
+
+export function shouldRefreshGeminiCliCredentials(
+	expiresAt: number | undefined,
+	isAntigravity: boolean,
+	nowMs = Date.now(),
+): boolean {
+	if (expiresAt === undefined) {
+		return false;
+	}
+
+	const skewMs = isAntigravity ? ANTIGRAVITY_REFRESH_SKEW_MS : GOOGLE_GEMINI_REFRESH_SKEW_MS;
+	return nowMs + skewMs >= expiresAt;
+}
+
+async function refreshGeminiCliCredentialsIfNeeded(
+	credentials: ParsedGeminiCliCredentials,
+	isAntigravity: boolean,
+): Promise<ParsedGeminiCliCredentials> {
+	if (!credentials.refreshToken || !shouldRefreshGeminiCliCredentials(credentials.expiresAt, isAntigravity)) {
+		return credentials;
+	}
+
+	try {
+		const refreshed = isAntigravity
+			? await refreshAntigravityToken(credentials.refreshToken, credentials.projectId)
+			: await refreshGoogleCloudToken(credentials.refreshToken, credentials.projectId);
+		return {
+			accessToken: refreshed.access,
+			projectId: credentials.projectId,
+			refreshToken: refreshed.refresh,
+			expiresAt: refreshed.expires,
+		};
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		// Permanent auth failure (revoked/invalid token) — re-authentication required.
+		// Google returns 400 invalid_grant when a token is revoked or expired server-side.
+		if (/invalid_grant|invalid_token|token.*revoked|account.*disabled/i.test(reason)) {
+			throw new Error(`OAuth token has been revoked or invalidated. Use /login to re-authenticate. (${reason})`);
+		}
+		// Transient failure (network, 5xx) — fall back to existing token if not yet expired.
+		if (credentials.expiresAt !== undefined && Date.now() >= credentials.expiresAt) {
+			throw new Error(`OAuth token refresh failed before request: ${reason}`);
+		}
+		return credentials;
+	}
+}
+interface CloudCodeAssistRequest {
+	project: string;
+	model: string;
+	request: {
+		contents: Content[];
+		sessionId?: string;
+		systemInstruction?: { role?: string; parts: { text: string }[] };
+		generationConfig?: {
+			maxOutputTokens?: number;
+			temperature?: number;
+			topP?: number;
+			topK?: number;
+			minP?: number;
+			presencePenalty?: number;
+			repetitionPenalty?: number;
+			thinkingConfig?: ThinkingConfig;
+		};
+		tools?: { functionDeclarations: Record<string, unknown>[] }[] | undefined;
+		toolConfig?: {
+			functionCallingConfig: {
+				mode: FunctionCallingConfigMode;
+			};
+		};
+	};
+	requestType?: string;
+	userAgent?: string;
+	requestId?: string;
+}
+
+interface CloudCodeAssistResponseChunk {
+	response?: {
+		candidates?: Array<{
+			content?: {
+				role: string;
+				parts?: Array<{
+					text?: string;
+					thought?: boolean;
+					thoughtSignature?: string;
+					functionCall?: {
+						name: string;
+						args: Record<string, unknown>;
+						id?: string;
+					};
+				}>;
+			};
+			finishReason?: string;
+		}>;
+		usageMetadata?: {
+			promptTokenCount?: number;
+			candidatesTokenCount?: number;
+			thoughtsTokenCount?: number;
+			totalTokenCount?: number;
+			cachedContentTokenCount?: number;
+		};
+		modelVersion?: string;
+		responseId?: string;
+	};
+	traceId?: string;
+}
+
+export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
+	model: Model<"google-gemini-cli">,
+	context: Context,
+	options?: GoogleGeminiCliOptions,
+): AssistantMessageEventStream => {
+	const stream = new AssistantMessageEventStream();
+
+	(async () => {
+		const startTime = Date.now();
+		let firstTokenTime: number | undefined;
+
+		const output: AssistantMessage = {
+			role: "assistant",
+			content: [],
+			api: "google-gemini-cli" as Api,
+			provider: model.provider,
+			model: model.id,
+			usage: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				totalTokens: 0,
+				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+			},
+			stopReason: "stop",
+			timestamp: Date.now(),
+		};
+		let rawRequestDump: RawHttpRequestDump | undefined;
+
+		try {
+			const apiKeyRaw = options?.apiKey;
+			if (!apiKeyRaw) {
+				throw new Error("Google Cloud Code Assist requires OAuth authentication. Use /login to authenticate.");
+			}
+
+			const isAntigravity = model.provider === "google-antigravity";
+			const parsedCredentials = parseGeminiCliCredentials(apiKeyRaw);
+			const activeCredentials = await refreshGeminiCliCredentialsIfNeeded(parsedCredentials, isAntigravity);
+			const { accessToken, projectId } = activeCredentials;
+
+			const baseUrl = model.baseUrl?.trim();
+			const endpoints = baseUrl ? [baseUrl] : isAntigravity ? ANTIGRAVITY_ENDPOINT_FALLBACKS : [DEFAULT_ENDPOINT];
+
+			let requestBody = buildRequest(model, context, projectId, options, isAntigravity);
+			const replacementPayload = await options?.onPayload?.(requestBody, model);
+			if (replacementPayload !== undefined) {
+				requestBody = replacementPayload as typeof requestBody;
+			}
+			const headers = isAntigravity ? getAntigravityHeaders() : getGeminiCliHeaders(model.id);
+
+			const requestHeaders = {
+				Authorization: `Bearer ${accessToken}`,
+				"Content-Type": "application/json",
+				Accept: "text/event-stream",
+				...headers,
+				...(needsClaudeThinkingBetaHeader(model) ? { "anthropic-beta": CLAUDE_THINKING_BETA_HEADER } : {}),
+				...(options?.headers ?? {}),
+			};
+			const requestBodyJson = JSON.stringify(requestBody);
+			rawRequestDump = {
+				provider: model.provider,
+				api: output.api,
+				model: model.id,
+				method: "POST",
+				body: requestBody,
+				headers: requestHeaders,
+			};
+
+			// Fetch with retry logic for rate limits and transient errors
+			let response: Response | undefined;
+			let lastError: Error | undefined;
+			let requestUrl: string | undefined;
+			let rateLimitTimeSpent = 0;
+
+			for (let attempt = 0; ; attempt++) {
+				if (options?.signal?.aborted) {
+					throw new Error("Request was aborted");
+				}
+
+				try {
+					const endpoint = endpoints[Math.min(attempt, endpoints.length - 1)];
+					requestUrl = `${endpoint}/v1internal:streamGenerateContent?alt=sse`;
+					response = await fetch(requestUrl, {
+						method: "POST",
+						headers: requestHeaders,
+						body: requestBodyJson,
+						signal: options?.signal,
+					});
+
+					if (response.ok) {
+						break; // Success, exit retry loop
+					}
+
+					const errorText = await response.text();
+
+					// Handle 429 rate limits with time budget
+					if (response.status === 429) {
+						if (/quota|exhausted/i.test(errorText)) {
+							throw withHttpStatus(
+								new Error(`Cloud Code Assist API error (429): ${extractErrorMessage(errorText)}`),
+								429,
+							);
+						}
+						const serverDelay = extractRetryDelay(errorText, response);
+						if (serverDelay && rateLimitTimeSpent + serverDelay <= RATE_LIMIT_BUDGET_MS) {
+							rateLimitTimeSpent += serverDelay;
+							await abortableSleep(serverDelay, options?.signal);
+							continue;
+						}
+						// Fallback: use exponential backoff if no server delay, up to MAX_RETRIES
+						if (!serverDelay && attempt < MAX_RETRIES) {
+							await abortableSleep(BASE_DELAY_MS * 2 ** attempt, options?.signal);
+							continue;
+						}
+					} else if (attempt < MAX_RETRIES && isRetryableError(response.status, errorText)) {
+						// Non-429 retryable errors use standard attempt cap
+						const serverDelay = extractRetryDelay(errorText, response);
+						const delayMs = serverDelay ?? BASE_DELAY_MS * 2 ** attempt;
+
+						// Check if server delay exceeds max allowed (default: 60s) for non-429 errors
+						const maxDelayMs = options?.maxRetryDelayMs ?? 60000;
+						if (maxDelayMs > 0 && serverDelay && serverDelay > maxDelayMs) {
+							const delaySeconds = Math.ceil(serverDelay / 1000);
+							throw withHttpStatus(
+								new Error(
+									`Server requested ${delaySeconds}s retry delay (max: ${Math.ceil(maxDelayMs / 1000)}s). ${extractErrorMessage(errorText)}`,
+								),
+								response.status,
+							);
+						}
+
+						await abortableSleep(delayMs, options?.signal);
+						continue;
+					}
+
+					// Not retryable or budget exceeded
+					throw withHttpStatus(
+						new Error(`Cloud Code Assist API error (${response.status}): ${extractErrorMessage(errorText)}`),
+						response.status,
+					);
+				} catch (error) {
+					// Check for abort - fetch throws AbortError, our code throws "Request was aborted"
+					if (error instanceof Error) {
+						if (error.name === "AbortError" || error.message === "Request was aborted") {
+							throw new Error("Request was aborted");
+						}
+					}
+
+					// HTTP responses are handled inside the try block.
+					// If we intentionally throw with status metadata, don't convert it into a network retry.
+					if (extractHttpStatusFromError(error) !== undefined) {
+						throw error;
+					}
+					// Extract detailed error message from fetch errors (Node includes cause)
+					lastError = error instanceof Error ? error : new Error(String(error));
+					if (lastError.message === "fetch failed" && lastError.cause instanceof Error) {
+						lastError = new Error(`Network error: ${lastError.cause.message}`);
+					}
+					// Network errors are retryable
+					if (attempt < MAX_RETRIES) {
+						const delayMs = BASE_DELAY_MS * 2 ** attempt;
+						await abortableSleep(delayMs, options?.signal);
+						continue;
+					}
+					throw lastError;
+				}
+			}
+
+			if (!response?.ok) {
+				throw lastError ?? new Error("Failed to get response after retries");
+			}
+
+			let started = false;
+			const ensureStarted = () => {
+				if (!started) {
+					if (!firstTokenTime) firstTokenTime = Date.now();
+					stream.push({ type: "start", partial: output });
+					started = true;
+				}
+			};
+
+			const resetOutput = () => {
+				output.content = [];
+				output.usage = {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					totalTokens: 0,
+					cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+				};
+				output.stopReason = "stop";
+				output.errorMessage = undefined;
+				output.timestamp = Date.now();
+				started = false;
+			};
+
+			const streamResponse = async (activeResponse: Response): Promise<boolean> => {
+				if (!activeResponse.body) {
+					throw new Error("No response body");
+				}
+
+				let hasContent = false;
+				let currentBlock: TextContent | ThinkingContent | null = null;
+				const blocks = output.content;
+				const blockIndex = () => blocks.length - 1;
+
+				for await (const chunk of readSseJson<CloudCodeAssistResponseChunk>(
+					activeResponse.body!,
+					options?.signal,
+				)) {
+					const responseData = chunk.response;
+					if (!responseData) continue;
+
+					const candidate = responseData.candidates?.[0];
+					if (candidate?.content?.parts) {
+						for (const part of candidate.content.parts) {
+							if (part.text !== undefined) {
+								hasContent = true;
+								const isThinking = isThinkingPart(part);
+								if (
+									!currentBlock ||
+									(isThinking && currentBlock.type !== "thinking") ||
+									(!isThinking && currentBlock.type !== "text")
+								) {
+									if (currentBlock) {
+										if (currentBlock.type === "text") {
+											stream.push({
+												type: "text_end",
+												contentIndex: blocks.length - 1,
+												content: currentBlock.text,
+												partial: output,
+											});
+										} else {
+											stream.push({
+												type: "thinking_end",
+												contentIndex: blockIndex(),
+												content: currentBlock.thinking,
+												partial: output,
+											});
+										}
+									}
+									if (isThinking) {
+										currentBlock = { type: "thinking", thinking: "", thinkingSignature: undefined };
+										output.content.push(currentBlock);
+										ensureStarted();
+										stream.push({
+											type: "thinking_start",
+											contentIndex: blockIndex(),
+											partial: output,
+										});
+									} else {
+										currentBlock = { type: "text", text: "" };
+										output.content.push(currentBlock);
+										ensureStarted();
+										stream.push({ type: "text_start", contentIndex: blockIndex(), partial: output });
+									}
+								}
+								if (currentBlock.type === "thinking") {
+									currentBlock.thinking += part.text;
+									currentBlock.thinkingSignature = retainThoughtSignature(
+										currentBlock.thinkingSignature,
+										part.thoughtSignature,
+									);
+									stream.push({
+										type: "thinking_delta",
+										contentIndex: blockIndex(),
+										delta: part.text,
+										partial: output,
+									});
+								} else {
+									currentBlock.text += part.text;
+									currentBlock.textSignature = retainThoughtSignature(
+										currentBlock.textSignature,
+										part.thoughtSignature,
+									);
+									stream.push({
+										type: "text_delta",
+										contentIndex: blockIndex(),
+										delta: part.text,
+										partial: output,
+									});
+								}
+							}
+
+							if (part.functionCall) {
+								hasContent = true;
+								if (currentBlock) {
+									if (currentBlock.type === "text") {
+										stream.push({
+											type: "text_end",
+											contentIndex: blockIndex(),
+											content: currentBlock.text,
+											partial: output,
+										});
+									} else {
+										stream.push({
+											type: "thinking_end",
+											contentIndex: blockIndex(),
+											content: currentBlock.thinking,
+											partial: output,
+										});
+									}
+									currentBlock = null;
+								}
+
+								const providedId = part.functionCall.id;
+								const needsNewId =
+									!providedId || output.content.some(b => b.type === "toolCall" && b.id === providedId);
+								const toolCallId = needsNewId
+									? `${part.functionCall.name}_${Date.now()}_${++toolCallCounter}`
+									: providedId;
+
+								const toolCall: ToolCall = {
+									type: "toolCall",
+									id: toolCallId,
+									name: part.functionCall.name || "",
+									arguments: part.functionCall.args as Record<string, unknown>,
+									...(part.thoughtSignature && { thoughtSignature: part.thoughtSignature }),
+								};
+
+								output.content.push(toolCall);
+								ensureStarted();
+								stream.push({ type: "toolcall_start", contentIndex: blockIndex(), partial: output });
+								stream.push({
+									type: "toolcall_delta",
+									contentIndex: blockIndex(),
+									delta: JSON.stringify(toolCall.arguments),
+									partial: output,
+								});
+								stream.push({
+									type: "toolcall_end",
+									contentIndex: blockIndex(),
+									toolCall,
+									partial: output,
+								});
+							}
+						}
+					}
+
+					if (candidate?.finishReason) {
+						output.stopReason = mapStopReasonString(candidate.finishReason);
+						if (output.content.some(b => b.type === "toolCall")) {
+							output.stopReason = "toolUse";
+						}
+					}
+
+					if (responseData.usageMetadata) {
+						// promptTokenCount includes cachedContentTokenCount, so subtract to get fresh input
+						const promptTokens = responseData.usageMetadata.promptTokenCount || 0;
+						const cacheReadTokens = responseData.usageMetadata.cachedContentTokenCount || 0;
+						output.usage = {
+							input: promptTokens - cacheReadTokens,
+							output:
+								(responseData.usageMetadata.candidatesTokenCount || 0) +
+								(responseData.usageMetadata.thoughtsTokenCount || 0),
+							cacheRead: cacheReadTokens,
+							cacheWrite: 0,
+							totalTokens: responseData.usageMetadata.totalTokenCount || 0,
+							cost: {
+								input: 0,
+								output: 0,
+								cacheRead: 0,
+								cacheWrite: 0,
+								total: 0,
+							},
+						};
+						calculateCost(model, output.usage);
+					}
+				}
+
+				if (currentBlock) {
+					if (currentBlock.type === "text") {
+						stream.push({
+							type: "text_end",
+							contentIndex: blockIndex(),
+							content: currentBlock.text,
+							partial: output,
+						});
+					} else {
+						stream.push({
+							type: "thinking_end",
+							contentIndex: blockIndex(),
+							content: currentBlock.thinking,
+							partial: output,
+						});
+					}
+				}
+
+				return hasContent;
+			};
+
+			let receivedContent = false;
+			let currentResponse = response;
+
+			for (let emptyAttempt = 0; emptyAttempt <= MAX_EMPTY_STREAM_RETRIES; emptyAttempt++) {
+				if (options?.signal?.aborted) {
+					throw new Error("Request was aborted");
+				}
+
+				if (emptyAttempt > 0) {
+					const backoffMs = EMPTY_STREAM_BASE_DELAY_MS * 2 ** (emptyAttempt - 1);
+					try {
+						await abortableSleep(backoffMs, options?.signal);
+					} catch {
+						// Normalize AbortError to expected message for consistent error handling
+						throw new Error("Request was aborted");
+					}
+
+					if (!requestUrl) {
+						throw new Error("Missing request URL");
+					}
+
+					currentResponse = await fetch(requestUrl, {
+						method: "POST",
+						headers: requestHeaders,
+						body: requestBodyJson,
+						signal: options?.signal,
+					});
+
+					if (!currentResponse.ok) {
+						const retryErrorText = await currentResponse.text();
+						throw withHttpStatus(
+							new Error(`Cloud Code Assist API error (${currentResponse.status}): ${retryErrorText}`),
+							currentResponse.status,
+						);
+					}
+				}
+
+				const streamed = await streamResponse(currentResponse);
+				if (streamed) {
+					receivedContent = true;
+					break;
+				}
+
+				if (emptyAttempt < MAX_EMPTY_STREAM_RETRIES) {
+					resetOutput();
+				}
+			}
+
+			if (!receivedContent) {
+				throw new Error("Cloud Code Assist API returned an empty response");
+			}
+
+			if (options?.signal?.aborted) {
+				throw new Error("Request was aborted");
+			}
+
+			if (output.stopReason === "aborted" || output.stopReason === "error") {
+				throw new Error("An unknown error occurred");
+			}
+
+			output.duration = Date.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
+			stream.push({ type: "done", reason: output.stopReason, message: output });
+			stream.end();
+		} catch (error) {
+			for (const block of output.content) {
+				if ("index" in block) {
+					delete (block as { index?: number }).index;
+				}
+			}
+			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+			output.errorMessage = await appendRawHttpRequestDumpFor400(
+				error instanceof Error ? error.message : JSON.stringify(error),
+				error,
+				rawRequestDump,
+			);
+			output.duration = Date.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
+			stream.push({ type: "error", reason: output.stopReason, error: output });
+			stream.end();
+		}
+	})();
+
+	return stream;
+};
+
+const INT63_MASK = (1n << 63n) - 1n;
+const ANTIGRAVITY_RANDOM_BOUND = 9_000_000_000_000_000_000n;
+
+function formatSignedDecimalSessionId(value: bigint): string {
+	return `-${value.toString()}`;
+}
+
+function deriveSignedDecimalFromHash(text: string): string {
+	const digest = createHash("sha256").update(text).digest();
+	let value = 0n;
+	for (let index = 0; index < 8; index += 1) {
+		value = (value << 8n) | BigInt(digest[index] ?? 0);
+	}
+	return formatSignedDecimalSessionId(value & INT63_MASK);
+}
+
+function randomBoundedInt63(maxExclusive: bigint): bigint {
+	while (true) {
+		const bytes = randomBytes(8);
+		let value = 0n;
+		for (const byte of bytes) {
+			value = (value << 8n) | BigInt(byte);
+		}
+		value &= INT63_MASK;
+		if (value < maxExclusive) {
+			return value;
+		}
+	}
+}
+
+function randomSignedDecimalSessionId(): string {
+	return formatSignedDecimalSessionId(randomBoundedInt63(ANTIGRAVITY_RANDOM_BOUND));
+}
+
+function getFirstUserTextForAntigravitySession(context: Context): string | undefined {
+	for (const message of context.messages) {
+		if (message.role !== "user") {
+			continue;
+		}
+
+		if (typeof message.content === "string") {
+			return message.content;
+		}
+
+		if (Array.isArray(message.content)) {
+			const firstTextPart = message.content.find((item): item is TextContent => item.type === "text");
+			return firstTextPart?.text;
+		}
+
+		return undefined;
+	}
+
+	return undefined;
+}
+
+function deriveAntigravitySessionId(context: Context): string {
+	const text = getFirstUserTextForAntigravitySession(context);
+	if (text && text.trim().length > 0) {
+		return deriveSignedDecimalFromHash(text);
+	}
+
+	return randomSignedDecimalSessionId();
+}
+
+function normalizeAntigravityTools(
+	tools: CloudCodeAssistRequest["request"]["tools"],
+): CloudCodeAssistRequest["request"]["tools"] {
+	return tools?.map(tool => ({
+		...tool,
+		functionDeclarations: tool.functionDeclarations.map(declaration => {
+			if ("parameters" in declaration) {
+				return declaration;
+			}
+
+			const { parametersJsonSchema, ...rest } = declaration;
+			return {
+				...rest,
+				parameters: sanitizeSchemaForCCA(parametersJsonSchema),
+			};
+		}),
+	}));
+}
+
+export function buildRequest(
+	model: Model<"google-gemini-cli">,
+	context: Context,
+	projectId: string,
+	options: GoogleGeminiCliOptions = {},
+	isAntigravity = false,
+): CloudCodeAssistRequest {
+	const contents = convertMessages(model, context);
+
+	const generationConfig: CloudCodeAssistRequest["request"]["generationConfig"] = {};
+	if (options.temperature !== undefined) {
+		generationConfig.temperature = options.temperature;
+	}
+	if (options.maxTokens !== undefined) {
+		generationConfig.maxOutputTokens = options.maxTokens;
+	}
+	if (options.topP !== undefined) {
+		generationConfig.topP = options.topP;
+	}
+	if (options.topK !== undefined) {
+		generationConfig.topK = options.topK;
+	}
+	if (options.minP !== undefined) {
+		generationConfig.minP = options.minP;
+	}
+	if (options.presencePenalty !== undefined) {
+		generationConfig.presencePenalty = options.presencePenalty;
+	}
+	if (options.repetitionPenalty !== undefined) {
+		generationConfig.repetitionPenalty = options.repetitionPenalty;
+	}
+
+	// Thinking config
+	if (options.thinking?.enabled && model.reasoning) {
+		generationConfig.thinkingConfig = {
+			includeThoughts: true,
+		};
+		// Gemini 3 models use thinkingLevel, older models use thinkingBudget
+		if (options.thinking.level !== undefined) {
+			// Cast to any since our GoogleThinkingLevel mirrors Google's ThinkingLevel enum values
+			generationConfig.thinkingConfig.thinkingLevel = options.thinking.level as any;
+		} else if (options.thinking.budgetTokens !== undefined) {
+			generationConfig.thinkingConfig.thinkingBudget = options.thinking.budgetTokens;
+		}
+	}
+
+	const request: CloudCodeAssistRequest["request"] = {
+		contents,
+	};
+
+	if (isAntigravity) {
+		request.sessionId = deriveAntigravitySessionId(context);
+	}
+
+	// System instruction must be object with parts, not plain string
+	if (context.systemPrompt) {
+		request.systemInstruction = {
+			parts: [{ text: context.systemPrompt.toWellFormed() }],
+		};
+	}
+
+	if (Object.keys(generationConfig).length > 0) {
+		request.generationConfig = generationConfig;
+	}
+
+	if (context.tools && context.tools.length > 0) {
+		const convertedTools = convertTools(context.tools, model);
+		request.tools = isAntigravity ? normalizeAntigravityTools(convertedTools) : convertedTools;
+		if (options.toolChoice) {
+			request.toolConfig = {
+				functionCallingConfig: {
+					mode: mapToolChoice(options.toolChoice),
+				},
+			};
+		}
+	}
+
+	if (isAntigravity && !isClaudeModel(model.id) && request.generationConfig?.maxOutputTokens !== undefined) {
+		delete request.generationConfig.maxOutputTokens;
+		if (Object.keys(request.generationConfig).length === 0) {
+			delete request.generationConfig;
+		}
+	}
+
+	if (isAntigravity && isClaudeModel(model.id)) {
+		request.toolConfig = {
+			functionCallingConfig: {
+				mode: "VALIDATED" as FunctionCallingConfigMode,
+			},
+		};
+	}
+
+	if (isAntigravity && shouldInjectAntigravitySystemInstruction(model.id)) {
+		const existingParts = request.systemInstruction?.parts ?? [];
+		request.systemInstruction = {
+			role: "user",
+			parts: [
+				{ text: ANTIGRAVITY_SYSTEM_INSTRUCTION },
+				{ text: `Please ignore following [ignore]${ANTIGRAVITY_SYSTEM_INSTRUCTION}[/ignore]` },
+				...existingParts,
+			],
+		};
+	}
+
+	return {
+		project: projectId,
+		model: model.id,
+		request,
+		...(isAntigravity
+			? {
+					requestType: "agent",
+					userAgent: "antigravity",
+					requestId: `agent-${randomUUID()}`,
+				}
+			: {}),
+	};
+}