@xiaoso/dsh-tool-plus 0.1.0-beta.2 → 0.1.0-beta.4

package/lib/google-gemini-cli-Cb97bzQc.mjs

@@ -0,0 +1,850 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { o as readSseJson } from "./src-lDmkSRbm.mjs";
+import { G as fetchWithRetry, L as GeminiCliApiError, S as classify, W as extractHttpStatusFromError, a as isTransientStatus, c as OAuthError, j as retriable, l as finalize, n as StreamTimeoutError, r as ValidationError, s as ProviderResponseError, t as ConfigurationError, v as AbortError } from "./error-yCSG0mGC.mjs";
+import { M as normalizeSchemaForCCA, a as normalizeSystemPrompts } from "./utils-Bw139LTz.mjs";
+import { t as calculateCost } from "./models-D_XnT6ay.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-loUa0s1T.mjs";
+import { i as getGeminiCliHeaders, n as getAntigravityUserAgent, t as getAntigravityModelWireProfile } from "./gemini-headers-DKUShltF.mjs";
+import { i as getStreamFirstEventTimeoutMs, o as iterateWithIdleTimeout, t as armPreResponseTimeout } from "./idle-iterator-Baoyn3Hp.mjs";
+import { t as StreamMarkupHealing } from "./stream-markup-healing-DMsxBx1L.mjs";
+import { n as formatGoogleValidationRequiredMessage, t as extractGoogleValidationUrl } from "./google-validation-Cgbn3tWJ.mjs";
+import { a as isThinkingPart, c as nextToolCallId, d as retainThoughtSignature, f as startTextOrThinkingBlock, i as hasMeaningfulGoogleContent, l as pushBlockEndEvent, n as convertMessages, o as mapStopReasonString, r as convertTools, s as mapToolChoice, u as pushToolCallEvents } from "./google-shared-CgKmmdO3.mjs";
+import { scheduler } from "node:timers/promises";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { type } from "@oh-my-pi/omptype";
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/providers/google-antigravity-forced-tool.md
+var google_antigravity_forced_tool_default = "TOOL-ONLY TURN. This turn accepts a tool call and nothing else; a text reply here is discarded unread and you will be re-prompted. Emit the tool call now.\n";
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/providers/google-gemini-cli.ts
+/**
+* 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.
+*/
+function isPlanningLeakPrefix(text) {
+	const trimmed = text.trimStart();
+	if (!trimmed.startsWith("{")) return false;
+	const afterBrace = trimmed.slice(1).trimStart();
+	if (afterBrace === "") return trimmed.length <= 100;
+	if (afterBrace[0] !== "\"") return false;
+	const nextQuoteIndex = afterBrace.indexOf("\"", 1);
+	if (nextQuoteIndex === -1) {
+		const keyPrefix = afterBrace.slice(1);
+		return "thought".startsWith(keyPrefix) && trimmed.length <= 100;
+	}
+	if (afterBrace.slice(1, nextQuoteIndex) !== "thought") return false;
+	const afterKey = afterBrace.slice(nextQuoteIndex + 1).trimStart();
+	if (afterKey === "") return trimmed.length <= 100;
+	if (afterKey[0] !== ":") return false;
+	return true;
+}
+function isPlanningLeakObject(parsed, toolNames) {
+	if (!parsed || typeof parsed !== "object") return false;
+	const record = parsed;
+	const hasThought = typeof record.thought === "string";
+	const isOmpTool = typeof record.call === "string" && toolNames.has(record.call);
+	const hasToolSignature = "_i" in record || "paths" in record || "command" in record || "path" in record && "content" in record;
+	return hasThought || isOmpTool || hasToolSignature;
+}
+function splitLeadingJsonObject(text) {
+	const prefixLength = text.length - text.trimStart().length;
+	const trimmed = text.slice(prefixLength);
+	if (!trimmed.startsWith("{")) return void 0;
+	let depth = 0;
+	let inString = false;
+	let escaped = false;
+	for (let index = 0; index < trimmed.length; index += 1) {
+		const ch = trimmed[index];
+		if (inString) {
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			if (ch === "\\") {
+				escaped = true;
+				continue;
+			}
+			if (ch === "\"") inString = false;
+			continue;
+		}
+		if (ch === "\"") {
+			inString = true;
+			continue;
+		}
+		if (ch === "{") {
+			depth += 1;
+			continue;
+		}
+		if (ch !== "}") continue;
+		depth -= 1;
+		if (depth !== 0) continue;
+		const jsonText = trimmed.slice(0, index + 1);
+		return {
+			prefixLength: prefixLength + index + 1,
+			jsonText,
+			rest: trimmed.slice(index + 1)
+		};
+	}
+}
+function splitLeadingJsonObjectIgnoringQuotes(text) {
+	const prefixLength = text.length - text.trimStart().length;
+	const trimmed = text.slice(prefixLength);
+	if (!trimmed.startsWith("{")) return void 0;
+	let depth = 0;
+	for (let index = 0; index < trimmed.length; index += 1) {
+		const ch = trimmed[index];
+		if (ch === "{") depth += 1;
+		else if (ch === "}") {
+			depth -= 1;
+			if (depth === 0) return {
+				prefixLength: prefixLength + index + 1,
+				jsonText: trimmed.slice(0, index + 1),
+				rest: trimmed.slice(index + 1)
+			};
+		}
+	}
+}
+function consumePlanningBuffer(text, toolNames, isFinal = false) {
+	if (!isPlanningLeakPrefix(text)) return {
+		kind: "plain",
+		visibleText: text
+	};
+	let leading = splitLeadingJsonObject(text);
+	if (!leading) leading = splitLeadingJsonObjectIgnoringQuotes(text);
+	if (!leading) {
+		if (isFinal) {
+			const trimmed = text.trim();
+			const hasThoughtKey = trimmed.includes("\"thought\"");
+			const hasToolKey = Array.from(toolNames).some((name) => trimmed.includes(`"${name}"`));
+			const hasToolSignature = trimmed.includes("\"_i\"") || trimmed.includes("\"paths\"") || trimmed.includes("\"command\"") || trimmed.includes("\"path\"") && trimmed.includes("\"content\"");
+			if (hasThoughtKey || hasToolKey || hasToolSignature) return {
+				kind: "leak",
+				visibleText: ""
+			};
+			return {
+				kind: "plain",
+				visibleText: text
+			};
+		}
+		return { kind: "incomplete" };
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(leading.jsonText);
+	} catch {
+		const hasThoughtKey = leading.jsonText.includes("\"thought\"");
+		const hasToolKey = Array.from(toolNames).some((name) => leading.jsonText.includes(`"${name}"`));
+		const hasToolSignature = leading.jsonText.includes("\"_i\"") || leading.jsonText.includes("\"paths\"") || leading.jsonText.includes("\"command\"") || leading.jsonText.includes("\"path\"") && leading.jsonText.includes("\"content\"");
+		if (hasThoughtKey || hasToolKey || hasToolSignature) return {
+			kind: "leak",
+			visibleText: leading.rest
+		};
+		return {
+			kind: "plain",
+			visibleText: text
+		};
+	}
+	return isPlanningLeakObject(parsed, toolNames) ? {
+		kind: "leak",
+		visibleText: leading.rest
+	} : {
+		kind: "plain",
+		visibleText: text
+	};
+}
+const ANTIGRAVITY_PROVIDER_SESSION_STATE_KEY = "google-antigravity-session-state";
+function getAntigravityProviderSessionState(providerSessionState) {
+	if (!providerSessionState) return void 0;
+	let existing = providerSessionState.get(ANTIGRAVITY_PROVIDER_SESSION_STATE_KEY);
+	if (!existing) {
+		existing = { close: () => {} };
+		providerSessionState.set(ANTIGRAVITY_PROVIDER_SESSION_STATE_KEY, existing);
+	}
+	return existing;
+}
+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];
+const BASE_DELAY_MS = 1e3;
+const FLASH_FIRST_EVENT_TIMEOUT_MS = 6e4;
+const DEFAULT_FIRST_EVENT_TIMEOUT_MS = 3e5;
+const FIRST_EVENT_TIMEOUT_ERROR = "Cloud Code Assist stream timed out while waiting for the first event";
+const RATE_LIMIT_BUDGET_MS = 3e5;
+const CLAUDE_THINKING_BETA_HEADER = "interleaved-thinking-2025-05-14";
+const GOOGLE_GEMINI_REFRESH_SKEW_MS = 6e4;
+const ANTIGRAVITY_REFRESH_SKEW_MS = 6e4;
+function isClaudeModel(modelId) {
+	return modelId.toLowerCase().includes("claude");
+}
+function needsClaudeThinkingBetaHeader(model) {
+	return model.provider === "google-antigravity" && model.id.startsWith("claude-") && model.reasoning;
+}
+const optionalCredentialString = type("unknown").pipe((raw) => {
+	const out = type("string")(raw);
+	return out instanceof type.errors ? void 0 : out;
+});
+const innerCredentialsSchema = type({
+	"token?": optionalCredentialString,
+	"projectId?": optionalCredentialString,
+	"project_id?": optionalCredentialString,
+	"refreshToken?": optionalCredentialString,
+	"refresh?": optionalCredentialString,
+	"email?": optionalCredentialString,
+	"expiresAt?": "unknown",
+	"expires?": "unknown"
+});
+const geminiCliCredentialsSchema = type("unknown").pipe((raw) => {
+	const out = innerCredentialsSchema(raw);
+	return out instanceof type.errors ? {} : out;
+});
+function normalizeExpiryMs(value) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return;
+	return value < 1e10 ? value * 1e3 : value;
+}
+function parseGeminiCliCredentials(apiKeyRaw) {
+	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 rawCredentials;
+	try {
+		rawCredentials = JSON.parse(apiKeyRaw);
+	} catch {
+		throw new ValidationError(invalidCredentialsMessage);
+	}
+	const parsed = geminiCliCredentialsSchema(rawCredentials);
+	if (parsed instanceof type.errors) throw new ValidationError(invalidCredentialsMessage);
+	const projectId = parsed.projectId ?? parsed.project_id;
+	if (parsed.token === void 0 || projectId === void 0) throw new ValidationError(missingCredentialsMessage);
+	const refreshToken = parsed.refreshToken ?? parsed.refresh;
+	const expiresAt = normalizeExpiryMs(parsed.expiresAt ?? parsed.expires);
+	const email = parsed.email && parsed.email.length > 0 ? parsed.email : void 0;
+	return {
+		accessToken: parsed.token,
+		projectId,
+		refreshToken,
+		expiresAt,
+		email
+	};
+}
+function shouldRefreshGeminiCliCredentials(expiresAt, isAntigravity, nowMs = Date.now()) {
+	if (expiresAt === void 0) return false;
+	return nowMs + (isAntigravity ? ANTIGRAVITY_REFRESH_SKEW_MS : GOOGLE_GEMINI_REFRESH_SKEW_MS) >= expiresAt;
+}
+const streamGoogleGeminiCli = (model, context, options) => {
+	const stream = new AssistantMessageEventStream();
+	(async () => {
+		const startTime = performance.now();
+		let firstTokenTime;
+		const output = {
+			role: "assistant",
+			content: [],
+			api: "google-gemini-cli",
+			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;
+		try {
+			const apiKeyRaw = options?.apiKey;
+			if (!apiKeyRaw) throw new ConfigurationError("Google Cloud Code Assist requires OAuth authentication. Use /login to authenticate.");
+			const isAntigravity = model.provider === "google-antigravity";
+			const parsedCredentials = parseGeminiCliCredentials(apiKeyRaw);
+			const { accessToken, projectId } = parsedCredentials;
+			if (shouldRefreshGeminiCliCredentials(parsedCredentials.expiresAt, isAntigravity) && parsedCredentials.expiresAt !== void 0 && Date.now() >= parsedCredentials.expiresAt) throw new OAuthError("OAuth token expired before request — please retry; AuthStorage will refresh on the next attempt.", {
+				kind: "token-refresh",
+				provider: model.provider
+			});
+			const baseUrl = model.baseUrl?.trim();
+			let endpoints;
+			const providerState = isAntigravity ? getAntigravityProviderSessionState(options?.providerSessionState) : void 0;
+			if (isAntigravity) {
+				const mode = options?.antigravityEndpointMode ?? "auto";
+				if (mode === "sandbox") {
+					endpoints = [ANTIGRAVITY_SANDBOX_ENDPOINT];
+					if (providerState) providerState.lastGoodEndpoint = void 0;
+				} else if (mode === "production") {
+					endpoints = [ANTIGRAVITY_DAILY_ENDPOINT];
+					if (providerState) providerState.lastGoodEndpoint = void 0;
+				} else if (baseUrl) {
+					const cleanUrl = baseUrl.replace(/\/+$/, "");
+					if (cleanUrl !== ANTIGRAVITY_DAILY_ENDPOINT && cleanUrl !== ANTIGRAVITY_SANDBOX_ENDPOINT) {
+						endpoints = [baseUrl];
+						if (providerState) providerState.lastGoodEndpoint = void 0;
+					} else {
+						const defaultFallbacks = [...ANTIGRAVITY_ENDPOINT_FALLBACKS];
+						const lastGood = providerState?.lastGoodEndpoint;
+						if (lastGood && defaultFallbacks.includes(lastGood)) endpoints = [lastGood, ...defaultFallbacks.filter((e) => e !== lastGood)];
+						else endpoints = defaultFallbacks;
+					}
+				} else {
+					const defaultFallbacks = [...ANTIGRAVITY_ENDPOINT_FALLBACKS];
+					const lastGood = providerState?.lastGoodEndpoint;
+					if (lastGood && defaultFallbacks.includes(lastGood)) endpoints = [lastGood, ...defaultFallbacks.filter((e) => e !== lastGood)];
+					else endpoints = defaultFallbacks;
+				}
+			} else endpoints = baseUrl ? [baseUrl] : [DEFAULT_ENDPOINT];
+			let requestBody = buildRequest(model, context, projectId, options, isAntigravity);
+			const replacementPayload = await options?.onPayload?.(requestBody, model);
+			if (replacementPayload !== void 0) requestBody = replacementPayload;
+			const headers = isAntigravity ? { "User-Agent": getAntigravityUserAgent() } : 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
+			};
+			const firstEventTimeoutMs = options?.streamFirstEventTimeoutMs ?? getStreamFirstEventTimeoutMs(void 0, model.id.includes("flash") ? FLASH_FIRST_EVENT_TIMEOUT_MS : DEFAULT_FIRST_EVENT_TIMEOUT_MS);
+			const callerSignal = options?.signal;
+			const toolNames = new Set(context.tools?.map((t) => t.name) ?? []);
+			const isFlashLeakModel = model.id.includes("flash");
+			let started = false;
+			let sawFinishReason = false;
+			let lastResponseId;
+			const ensureStarted = () => {
+				if (!started) {
+					if (!firstTokenTime) firstTokenTime = performance.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 = void 0;
+				output.timestamp = Date.now();
+				sawFinishReason = false;
+			};
+			const streamResponse = async (activeResponse) => {
+				if (!activeResponse.body) throw new ProviderResponseError("No response body", {
+					provider: model.provider,
+					kind: "empty-body"
+				});
+				lastResponseId = void 0;
+				let currentBlock = null;
+				const blocks = output.content;
+				const blockIndex = () => blocks.length - 1;
+				const visibleTextHealing = new StreamMarkupHealing({ pattern: "thinking" });
+				let isBuffering = false;
+				let textBuffer = "";
+				let bufferedTextSignature;
+				let strippedPlanningLeak = false;
+				const endCurrentBlock = () => {
+					if (!currentBlock) return;
+					pushBlockEndEvent(currentBlock, blockIndex(), output, stream);
+					currentBlock = null;
+				};
+				const startTextBlock = () => {
+					let block = currentBlock;
+					if (block?.type !== "text") {
+						endCurrentBlock();
+						block = startTextOrThinkingBlock(false, output, stream, ensureStarted);
+						currentBlock = block;
+					}
+					return block;
+				};
+				const startThinkingBlock = () => {
+					let block = currentBlock;
+					if (block?.type !== "thinking") {
+						endCurrentBlock();
+						block = startTextOrThinkingBlock(true, output, stream, ensureStarted);
+						currentBlock = block;
+					}
+					return block;
+				};
+				const emitVisibleText = (delta, thoughtSignature) => {
+					if (!delta) return;
+					const block = startTextBlock();
+					block.text += delta;
+					block.textSignature = retainThoughtSignature(block.textSignature, thoughtSignature);
+					stream.push({
+						type: "text_delta",
+						contentIndex: blockIndex(),
+						delta,
+						partial: output
+					});
+				};
+				const emitVisibleThinking = (delta) => {
+					if (!delta) return;
+					const block = startThinkingBlock();
+					block.thinking += delta;
+					stream.push({
+						type: "thinking_delta",
+						contentIndex: blockIndex(),
+						delta,
+						partial: output
+					});
+				};
+				const emitHealingEvent = (event, thoughtSignature) => {
+					if (event.type === "text") emitVisibleText(event.text, thoughtSignature);
+					else if (event.type === "thinking") emitVisibleThinking(event.thinking);
+				};
+				const feedVisibleText = (delta, thoughtSignature) => {
+					for (const event of visibleTextHealing.feedEvents(delta)) emitHealingEvent(event, thoughtSignature);
+				};
+				const flushVisibleText = (thoughtSignature) => {
+					for (const event of visibleTextHealing.flushEvents()) emitHealingEvent(event, thoughtSignature);
+				};
+				const retainCurrentBlockThoughtSignature = (thoughtSignature) => {
+					const block = currentBlock;
+					if (!block) return;
+					if (block.type === "thinking") block.thinkingSignature = retainThoughtSignature(block.thinkingSignature, thoughtSignature);
+					else block.textSignature = retainThoughtSignature(block.textSignature, thoughtSignature);
+				};
+				const responseAbortController = new AbortController();
+				const responseSignal = options?.signal ? AbortSignal.any([options.signal, responseAbortController.signal]) : responseAbortController.signal;
+				const chunks = iterateWithIdleTimeout(readSseJson(activeResponse.body, responseSignal, (event) => options?.onSseEvent?.({
+					event: event.event,
+					data: event.data,
+					raw: [...event.raw]
+				}, model)), {
+					firstItemTimeoutMs: firstEventTimeoutMs,
+					errorMessage: FIRST_EVENT_TIMEOUT_ERROR,
+					firstItemErrorMessage: FIRST_EVENT_TIMEOUT_ERROR,
+					onFirstItemTimeout: () => responseAbortController.abort(new StreamTimeoutError(FIRST_EVENT_TIMEOUT_ERROR)),
+					abortSignal: options?.signal
+				});
+				for await (const chunk of chunks) {
+					if (chunk.error) {
+						const message = `Cloud Code Assist stream error: ${chunk.error.message || chunk.error.status || "unknown error"}`;
+						throw typeof chunk.error.code === "number" && chunk.error.code >= 400 ? new GeminiCliApiError(message, chunk.error.code) : new ProviderResponseError(message, {
+							provider: model.provider,
+							kind: "runtime"
+						});
+					}
+					const responseData = chunk.response;
+					if (!responseData) continue;
+					if (responseData.responseId) lastResponseId = responseData.responseId;
+					if (!responseData.candidates?.length && responseData.promptFeedback?.blockReason) {
+						const detail = responseData.promptFeedback.blockReasonMessage;
+						throw new ProviderResponseError(`Request blocked by Google (${responseData.promptFeedback.blockReason})${detail ? `: ${detail}` : ""}`, {
+							provider: model.provider,
+							kind: "content-blocked"
+						});
+					}
+					const candidate = responseData.candidates?.[0];
+					if (candidate?.content?.parts) for (const part of candidate.content.parts) {
+						if (part.text !== void 0 && part.text !== "") {
+							if (isThinkingPart(part)) {
+								flushVisibleText();
+								const block = startThinkingBlock();
+								block.thinking += part.text;
+								block.thinkingSignature = retainThoughtSignature(block.thinkingSignature, part.thoughtSignature);
+								stream.push({
+									type: "thinking_delta",
+									contentIndex: blockIndex(),
+									delta: part.text,
+									partial: output
+								});
+							} else {
+								if (isBuffering) {
+									textBuffer += part.text;
+									bufferedTextSignature = retainThoughtSignature(bufferedTextSignature, part.thoughtSignature);
+								} else if (isFlashLeakModel && part.text.trimStart().startsWith("{")) {
+									isBuffering = true;
+									textBuffer = part.text;
+									bufferedTextSignature = part.thoughtSignature;
+								} else feedVisibleText(part.text, part.thoughtSignature);
+								if (isBuffering) {
+									const buffered = consumePlanningBuffer(textBuffer, toolNames);
+									if (buffered.kind !== "incomplete") {
+										if (buffered.kind === "leak") strippedPlanningLeak = true;
+										const visibleSignature = bufferedTextSignature;
+										isBuffering = false;
+										textBuffer = "";
+										bufferedTextSignature = void 0;
+										feedVisibleText(buffered.visibleText, visibleSignature);
+									}
+								}
+							}
+						} else if (part.text === "" && part.thoughtSignature && !part.functionCall) retainCurrentBlockThoughtSignature(part.thoughtSignature);
+						if (part.functionCall) {
+							flushVisibleText();
+							endCurrentBlock();
+							isBuffering = false;
+							textBuffer = "";
+							const providedId = part.functionCall.id;
+							const toolCall = {
+								type: "toolCall",
+								id: !providedId || output.content.some((b) => b.type === "toolCall" && b.id === providedId) ? nextToolCallId(part.functionCall.name || "tool") : providedId,
+								name: part.functionCall.name || "",
+								arguments: part.functionCall.args ?? {},
+								...part.thoughtSignature && { thoughtSignature: part.thoughtSignature }
+							};
+							output.content.push(toolCall);
+							ensureStarted();
+							pushToolCallEvents(toolCall, blockIndex(), output, stream);
+						}
+					}
+					if (candidate?.finishReason) {
+						sawFinishReason = true;
+						const mapped = mapStopReasonString(candidate.finishReason);
+						if ((mapped === "stop" || mapped === "length") && output.content.some((b) => b.type === "toolCall")) output.stopReason = "toolUse";
+						else {
+							output.stopReason = mapped;
+							if (mapped === "error") output.errorMessage = `Generation failed with finish reason: ${candidate.finishReason}`;
+						}
+					}
+					if (responseData.usageMetadata) {
+						const promptTokens = responseData.usageMetadata.promptTokenCount || 0;
+						const cacheReadTokens = responseData.usageMetadata.cachedContentTokenCount || 0;
+						const thinkingTokens = responseData.usageMetadata.thoughtsTokenCount || 0;
+						output.usage = {
+							input: promptTokens - cacheReadTokens,
+							output: (responseData.usageMetadata.candidatesTokenCount || 0) + thinkingTokens,
+							cacheRead: cacheReadTokens,
+							cacheWrite: 0,
+							totalTokens: responseData.usageMetadata.totalTokenCount || 0,
+							...thinkingTokens > 0 ? { reasoningTokens: thinkingTokens } : {},
+							cost: {
+								input: 0,
+								output: 0,
+								cacheRead: 0,
+								cacheWrite: 0,
+								total: 0
+							}
+						};
+						calculateCost(model, output.usage);
+					}
+				}
+				if (isBuffering && textBuffer !== "") {
+					const buffered = consumePlanningBuffer(textBuffer, toolNames, true);
+					if (buffered.kind !== "incomplete") {
+						if (buffered.kind === "leak") strippedPlanningLeak = true;
+						feedVisibleText(buffered.visibleText, bufferedTextSignature);
+					}
+					bufferedTextSignature = void 0;
+					isBuffering = false;
+					textBuffer = "";
+				}
+				flushVisibleText(bufferedTextSignature);
+				endCurrentBlock();
+				return {
+					meaningful: hasMeaningfulGoogleContent(output),
+					strippedPlanningLeak
+				};
+			};
+			let receivedContent = false;
+			const hasThinkingOutput = () => output.content.some((block) => block.type === "thinking" && (block.thinking.trim().length > 0 || Boolean(block.thinkingSignature)));
+			for (let i = 0; i < endpoints.length; i++) {
+				const endpoint = endpoints[i];
+				const isLastEndpoint = i === endpoints.length - 1;
+				try {
+					started = false;
+					resetOutput();
+					const watchdog = armPreResponseTimeout(callerSignal, firstEventTimeoutMs);
+					let response;
+					try {
+						response = await fetchWithRetry(() => `${endpoint}/v1internal:streamGenerateContent?alt=sse`, {
+							method: "POST",
+							headers: requestHeaders,
+							body: requestBodyJson,
+							signal: watchdog.signal,
+							maxAttempts: isLastEndpoint ? 4 : 1,
+							defaultDelayMs: (attempt) => BASE_DELAY_MS * 2 ** attempt,
+							maxDelayMs: options?.maxRetryDelayMs ?? RATE_LIMIT_BUDGET_MS,
+							fetch: options?.fetch,
+							timeout: false
+						});
+					} finally {
+						watchdog.clear();
+					}
+					if (!response.ok) {
+						if (isTransientStatus(response.status)) {
+							if (!isLastEndpoint) continue;
+						}
+						const errorText = await response.text();
+						const validationUrl = extractGoogleValidationUrl(errorText);
+						const errorMessage = validationUrl ? formatGoogleValidationRequiredMessage(validationUrl, "retry your request", parsedCredentials.email) : errorText;
+						throw new GeminiCliApiError(`Cloud Code Assist API error (${response.status}): ${errorMessage}`, response.status, { headers: response.headers });
+					}
+					const requestUrl = response.url;
+					let currentResponse = response;
+					for (let emptyAttempt = 0; emptyAttempt <= 2; emptyAttempt++) {
+						if (options?.signal?.aborted) throw new AbortError("Request was aborted");
+						if (emptyAttempt > 0) {
+							const backoffMs = 500 * 2 ** (emptyAttempt - 1);
+							try {
+								await scheduler.wait(backoffMs, { signal: options?.signal });
+							} catch {
+								throw new AbortError("Request was aborted");
+							}
+							if (!requestUrl) throw new ConfigurationError("Missing request URL");
+							currentResponse = await (options?.fetch ?? fetch)(requestUrl, {
+								method: "POST",
+								headers: requestHeaders,
+								body: requestBodyJson,
+								signal: options?.signal
+							});
+							if (!currentResponse.ok) {
+								const retryErrorText = await currentResponse.text();
+								throw new GeminiCliApiError(`Cloud Code Assist API error (${currentResponse.status}): ${retryErrorText}`, currentResponse.status, { headers: currentResponse.headers });
+							}
+						}
+						const streamed = await streamResponse(currentResponse);
+						const thoughtOnly = hasThinkingOutput();
+						const acceptedSilence = options?.acceptEmptyResponse === true && !streamed.strippedPlanningLeak && (isLastEndpoint || thoughtOnly);
+						if (output.stopReason !== "stop" || streamed.meaningful || acceptedSilence) {
+							receivedContent = streamed.meaningful || acceptedSilence;
+							break;
+						}
+						if (thoughtOnly) break;
+						if (emptyAttempt < 2) resetOutput();
+					}
+					if (output.stopReason === "aborted" || output.stopReason === "error") throw new ProviderResponseError(output.errorMessage ?? "An unknown error occurred", {
+						provider: model.provider,
+						kind: "output"
+					});
+					if (!receivedContent) {
+						const thoughtOnly = hasThinkingOutput();
+						throw new ProviderResponseError(thoughtOnly ? "Cloud Code Assist API returned a thought-only response without final output" : "Cloud Code Assist API returned an empty response", {
+							provider: model.provider,
+							kind: thoughtOnly ? "empty-output" : "empty-body"
+						});
+					}
+					if (options?.signal?.aborted) throw new AbortError("Request was aborted");
+					if (!sawFinishReason) throw new ProviderResponseError("Cloud Code Assist stream ended without a finish reason (connection dropped or response truncated)", {
+						provider: model.provider,
+						kind: "incomplete-stream"
+					});
+					if (providerState && (options?.antigravityEndpointMode === "auto" || !options?.antigravityEndpointMode)) providerState.lastGoodEndpoint = endpoint;
+					if (providerState) providerState.lastExecutionId = lastResponseId;
+					break;
+				} catch (error) {
+					const status = extractHttpStatusFromError(error);
+					if (!isLastEndpoint && !started && (isTransientStatus(status) || status === void 0 && !(error instanceof ProviderResponseError && error.kind === "output") && retriable(classify(error)))) continue;
+					throw error;
+				}
+			}
+			if (output.stopReason === "aborted" || output.stopReason === "error") throw new ProviderResponseError(output.errorMessage ?? "An unknown error occurred", {
+				provider: model.provider,
+				kind: "output"
+			});
+			output.duration = performance.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
+			stream.push({
+				type: "done",
+				reason: output.stopReason,
+				message: output
+			});
+			stream.end();
+		} catch (error) {
+			const result = await finalize(error, {
+				api: model.api,
+				signal: options?.signal,
+				rawRequestDump
+			});
+			output.stopReason = result.stopReason;
+			output.errorStatus = result.status;
+			output.errorId = result.id;
+			output.errorMessage = result.message;
+			output.duration = performance.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 = 9000000000000000000n;
+function formatSignedDecimalSessionId(value) {
+	return `-${value.toString()}`;
+}
+function deriveSignedDecimalFromHash(text) {
+	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) {
+	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() {
+	return formatSignedDecimalSessionId(randomBoundedInt63(ANTIGRAVITY_RANDOM_BOUND));
+}
+function getFirstUserTextForAntigravitySession(context) {
+	for (const message of context.messages) {
+		if (message.role !== "user") continue;
+		if (typeof message.content === "string") return message.content;
+		if (Array.isArray(message.content)) return message.content.find((item) => item.type === "text")?.text;
+		return;
+	}
+}
+function deriveAntigravitySessionId(context) {
+	const text = getFirstUserTextForAntigravitySession(context);
+	if (text && text.trim().length > 0) return deriveSignedDecimalFromHash(text);
+	return randomSignedDecimalSessionId();
+}
+function normalizeAntigravityTools(tools) {
+	return tools?.map((tool) => ({
+		...tool,
+		functionDeclarations: tool.functionDeclarations.map((declaration) => {
+			if ("parameters" in declaration) return declaration;
+			const { parametersJsonSchema, ...rest } = declaration;
+			return {
+				...rest,
+				parameters: normalizeSchemaForCCA(parametersJsonSchema)
+			};
+		})
+	}));
+}
+/**
+* Build the Antigravity request envelope (sessionId, structured requestId,
+* labels) advancing the per-conversation session state. Mirrors the real
+* `antigravity/hub` client: `requestId` is `agent/<agentId>/<ts>/<trajectoryId>/<step>`
+* and `labels.last_step_index` trails the requestId step by one. Without session
+* state (direct callers/tests) it falls back to ephemeral ids.
+*/
+function buildAntigravityRequestEnvelope(model, context, wireModelId, state) {
+	if (state) {
+		state.agentId ??= randomUUID();
+		state.trajectoryId ??= randomUUID();
+		state.sessionId ??= randomSignedDecimalSessionId();
+		state.stepIndex = (state.stepIndex ?? 1) + 1;
+	}
+	const agentId = state?.agentId ?? randomUUID();
+	const trajectoryId = state?.trajectoryId ?? randomUUID();
+	const sessionId = state?.sessionId ?? deriveAntigravitySessionId(context);
+	const step = state?.stepIndex ?? 2;
+	const requestId = `agent/${agentId}/${Date.now()}/${trajectoryId}/${step}`;
+	const isClaude = isClaudeModel(model.id);
+	const profile = getAntigravityModelWireProfile(wireModelId);
+	const labels = {};
+	if (state?.lastExecutionId) labels.last_execution_id = state.lastExecutionId;
+	labels.last_step_index = String(step - 1);
+	if (profile?.modelEnum !== void 0) labels.model_enum = profile.modelEnum;
+	labels.trajectory_id = trajectoryId;
+	labels.used_claude = String(isClaude);
+	labels.used_claude_conservative = String(isClaude);
+	return {
+		sessionId,
+		requestId,
+		labels
+	};
+}
+function buildRequest(model, context, projectId, options = {}, isAntigravity = false) {
+	const systemPrompts = normalizeSystemPrompts(context.systemPrompt);
+	const contents = convertMessages(model, context);
+	const generationConfig = {};
+	if (options.temperature !== void 0) generationConfig.temperature = options.temperature;
+	if (options.maxTokens !== void 0) generationConfig.maxOutputTokens = options.maxTokens;
+	if (options.topP !== void 0) generationConfig.topP = options.topP;
+	if (options.topK !== void 0) generationConfig.topK = options.topK;
+	if (options.minP !== void 0) generationConfig.minP = options.minP;
+	if (options.presencePenalty !== void 0) generationConfig.presencePenalty = options.presencePenalty;
+	if (options.repetitionPenalty !== void 0) generationConfig.repetitionPenalty = options.repetitionPenalty;
+	if (options.thinking?.enabled && model.reasoning) {
+		generationConfig.thinkingConfig = { includeThoughts: !options.hideThinkingSummary };
+		if (options.thinking.level !== void 0) generationConfig.thinkingConfig.thinkingLevel = options.thinking.level;
+		else if (options.thinking.budgetTokens !== void 0) generationConfig.thinkingConfig.thinkingBudget = options.thinking.budgetTokens;
+	} else if (options.thinking?.suppress && model.reasoning) {
+		const suppress = options.thinking.suppress;
+		generationConfig.thinkingConfig = { includeThoughts: false };
+		if ("level" in suppress) generationConfig.thinkingConfig.thinkingLevel = suppress.level;
+		else generationConfig.thinkingConfig.thinkingBudget = suppress.budget;
+	}
+	const request = { contents };
+	if (systemPrompts.length > 0) request.systemInstruction = {
+		...isAntigravity ? { role: "user" } : {},
+		parts: systemPrompts.map((text) => ({ text }))
+	};
+	if (context.tools && context.tools.length > 0) {
+		const convertedTools = convertTools(context.tools, model);
+		request.tools = isAntigravity ? normalizeAntigravityTools(convertedTools) : convertedTools;
+		if (options.toolChoice) {
+			const choice = options.toolChoice;
+			if (typeof choice === "string") {
+				const mode = mapToolChoice(choice);
+				if (mode !== "AUTO") request.toolConfig = { functionCallingConfig: { mode } };
+			} else request.toolConfig = { functionCallingConfig: {
+				mode: "ANY",
+				allowedFunctionNames: [...choice.allowedFunctionNames]
+			} };
+			if (isAntigravity && !isClaudeModel(model.id) && request.toolConfig?.functionCallingConfig.mode === "ANY") contents.push({
+				role: "user",
+				parts: [{ text: google_antigravity_forced_tool_default }]
+			});
+		}
+		if (isAntigravity && !request.toolConfig) request.toolConfig = { functionCallingConfig: { mode: "VALIDATED" } };
+	}
+	if (isAntigravity && isClaudeModel(model.id)) request.toolConfig = { functionCallingConfig: { mode: "VALIDATED" } };
+	const wireModelId = options.requestModelId ?? model.requestModelId ?? model.id;
+	if (isAntigravity) {
+		const profile = getAntigravityModelWireProfile(wireModelId);
+		if (profile) generationConfig.maxOutputTokens = profile.maxOutputTokens;
+		const envelope = buildAntigravityRequestEnvelope(model, context, wireModelId, getAntigravityProviderSessionState(options.providerSessionState));
+		request.labels = envelope.labels;
+		if (Object.keys(generationConfig).length > 0) request.generationConfig = generationConfig;
+		request.sessionId = envelope.sessionId;
+		return {
+			project: projectId,
+			requestId: envelope.requestId,
+			request,
+			model: wireModelId,
+			userAgent: "antigravity",
+			requestType: "agent"
+		};
+	}
+	if (Object.keys(generationConfig).length > 0) request.generationConfig = generationConfig;
+	return {
+		project: projectId,
+		model: wireModelId,
+		request
+	};
+}
+//#endregion
+export { streamGoogleGeminiCli };