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

package/lib/google-shared-DzhCb9b0.mjs

@@ -0,0 +1,760 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { o as readSseJson } from "./src-DTid0g4K.mjs";
+import { R as GoogleApiError, l as finalize, r as ValidationError, s as ProviderResponseError, t as ConfigurationError, v as AbortError } from "./error-B3bevhrs.mjs";
+import { M as normalizeSchemaForCCA, N as normalizeSchemaForGoogle, a as normalizeSystemPrompts, k as toolWireSchema, m as transformMessages, w as renderDemotedThinking } from "./utils-2Wq2eATG.mjs";
+import { t as calculateCost } from "./models-CfT4coYT.mjs";
+import { o as shouldSendServiceTier, t as NON_VISION_IMAGE_PLACEHOLDER } from "./vision-guard-BDD4OrKo.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-BDPi64mK.mjs";
+import { scheduler } from "node:timers/promises";
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/providers/google-shared.ts
+/**
+* Shared utilities for Google Generative AI and Google Cloud Code Assist providers.
+*/
+/**
+* Determines whether a streamed Gemini `Part` should be treated as "thinking".
+*
+* Protocol note (Gemini / Vertex AI thought signatures):
+* - `thought: true` is the definitive marker for thinking content (thought summaries).
+* - `thoughtSignature` is an encrypted representation of the model's internal thought process
+*   used to preserve reasoning context across multi-turn interactions.
+* - `thoughtSignature` can appear on ANY part type (text, functionCall, etc.) - it does NOT
+*   indicate the part itself is thinking content.
+* - For non-functionCall responses, the signature appears on the last part for context replay.
+* - When persisting/replaying model outputs, signature-bearing parts must be preserved as-is;
+*   do not merge/move signatures across parts.
+*
+* See: https://ai.google.dev/gemini-api/docs/thought-signatures
+*/
+function isThinkingPart(part) {
+	return part.thought === true;
+}
+/**
+* Retain thought signatures during streaming.
+*
+* Some backends only send `thoughtSignature` on the first delta for a given part/block; later deltas may omit it.
+* This helper preserves the last non-empty signature for the current block.
+*
+* Note: this does NOT merge or move signatures across distinct response parts. It only prevents
+* a signature from being overwritten with `undefined` within the same streamed block.
+*/
+function retainThoughtSignature(existing, incoming) {
+	if (typeof incoming === "string" && incoming.length > 0) return incoming;
+	return existing;
+}
+const base64SignaturePattern = /^[A-Za-z0-9+/]+={0,2}$/;
+const SKIP_THOUGHT_SIGNATURE = "skip_thought_signature_validator";
+function isValidThoughtSignature(signature) {
+	if (!signature) return false;
+	if (signature.length % 4 !== 0) return false;
+	return base64SignaturePattern.test(signature);
+}
+/**
+* Only keep signatures from the same provider/model and with valid base64.
+*/
+function resolveThoughtSignature(isSameProviderAndModel, signature) {
+	return isSameProviderAndModel && isValidThoughtSignature(signature) ? signature : void 0;
+}
+function supportsFunctionPartId(model) {
+	if (model.api === "google-vertex") return false;
+	return model.id.startsWith("claude-") || model.api === "google-generative-ai" && isGemini3Model(model.id);
+}
+function getGeminiMajorVersion(modelId) {
+	const match = modelId.toLowerCase().match(/^gemini(?:-live)?-(\d+)/);
+	if (!match) return void 0;
+	return Number.parseInt(match[1], 10);
+}
+function supportsMultimodalFunctionResponse(modelId) {
+	const geminiMajorVersion = getGeminiMajorVersion(modelId);
+	if (geminiMajorVersion !== void 0) return geminiMajorVersion >= 3;
+	return true;
+}
+function isGemini3Model(modelId) {
+	return modelId.includes("gemini-3");
+}
+/**
+* Convert internal messages to Gemini Content[] format.
+*/
+function convertMessages(model, context) {
+	const contents = [];
+	const emittedToolCallNames = /* @__PURE__ */ new Map();
+	const normalizeToolCallId = (id) => {
+		return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+	};
+	const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
+	let pendingToolImageParts = [];
+	const flushPendingToolImages = () => {
+		if (pendingToolImageParts.length === 0) return;
+		contents.push({
+			role: "user",
+			parts: pendingToolImageParts
+		});
+		pendingToolImageParts = [];
+	};
+	for (const msg of transformedMessages) {
+		if (msg.role !== "toolResult") flushPendingToolImages();
+		if (msg.role === "user" || msg.role === "developer") {
+			if (typeof msg.content === "string") {
+				if (!msg.content || msg.content.trim() === "") continue;
+				contents.push({
+					role: "user",
+					parts: [{ text: msg.content.toWellFormed() }]
+				});
+			} else {
+				const supportsImages = model.input.includes("image");
+				const parts = [];
+				let omittedImages = false;
+				for (const item of msg.content) if (item.type === "text") {
+					const text = item.text.toWellFormed();
+					if (text.trim().length === 0) continue;
+					parts.push({ text });
+				} else if (supportsImages) parts.push({ inlineData: {
+					mimeType: item.mimeType,
+					data: item.data
+				} });
+				else omittedImages = true;
+				if (omittedImages) parts.push({ text: NON_VISION_IMAGE_PLACEHOLDER });
+				if (parts.length === 0) continue;
+				contents.push({
+					role: "user",
+					parts
+				});
+			}
+		} else if (msg.role === "assistant") {
+			const parts = [];
+			const isSameProviderAndModel = msg.provider === model.provider && msg.model === model.id;
+			const dropsUnsignedThinking = model.provider === "google-antigravity" && model.id.toLowerCase().includes("claude");
+			for (const block of msg.content) if (block.type === "text") {
+				if (!block.text || block.text.trim() === "") continue;
+				const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.textSignature);
+				parts.push({
+					text: block.text.toWellFormed(),
+					...thoughtSignature && { thoughtSignature }
+				});
+			} else if (block.type === "thinking") {
+				if (!block.thinking || block.thinking.trim() === "") continue;
+				const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.thinkingSignature);
+				if (dropsUnsignedThinking && !thoughtSignature) continue;
+				if (thoughtSignature) parts.push({
+					thought: true,
+					text: block.thinking.toWellFormed(),
+					thoughtSignature
+				});
+				else parts.push({ text: renderDemotedThinking(model.id, block.thinking) });
+			} else if (block.type === "toolCall") {
+				emittedToolCallNames.set(block.id, block.name);
+				const effectiveSignature = resolveThoughtSignature(isSameProviderAndModel, block.thoughtSignature) || (isGemini3Model(model.id) ? SKIP_THOUGHT_SIGNATURE : void 0);
+				const part = { functionCall: {
+					name: block.name,
+					args: block.arguments ?? {},
+					...supportsFunctionPartId(model) ? { id: block.id } : {}
+				} };
+				if (model.provider === "google-vertex" && part?.functionCall?.id) delete part.functionCall.id;
+				if (effectiveSignature) part.thoughtSignature = effectiveSignature;
+				parts.push(part);
+			}
+			if (parts.length === 0) continue;
+			contents.push({
+				role: "model",
+				parts
+			});
+		} else if (msg.role === "toolResult") {
+			const supportsImages = model.input.includes("image");
+			const textResult = msg.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+			const imageContent = supportsImages ? msg.content.filter((c) => c.type === "image") : [];
+			const omittedImages = !supportsImages && msg.content.some((c) => c.type === "image");
+			const hasText = textResult.length > 0;
+			const hasImages = imageContent.length > 0;
+			const modelSupportsMultimodalFunctionResponse = supportsMultimodalFunctionResponse(model.id);
+			const responseValue = omittedImages ? [hasText ? textResult.toWellFormed() : "", NON_VISION_IMAGE_PLACEHOLDER].filter(Boolean).join("\n") : hasText ? textResult.toWellFormed() : hasImages ? "(see attached image)" : "";
+			const imageParts = imageContent.map((imageBlock) => ({ inlineData: {
+				mimeType: imageBlock.mimeType,
+				data: imageBlock.data
+			} }));
+			const includeId = supportsFunctionPartId(model);
+			const functionResponsePart = { functionResponse: {
+				name: emittedToolCallNames.get(msg.toolCallId) ?? msg.toolName,
+				response: msg.isError ? { error: responseValue } : { output: responseValue },
+				...hasImages && modelSupportsMultimodalFunctionResponse && { parts: imageParts },
+				...includeId ? { id: msg.toolCallId } : {}
+			} };
+			if (model.provider === "google-vertex" && functionResponsePart.functionResponse?.id) delete functionResponsePart.functionResponse.id;
+			const lastContent = contents[contents.length - 1];
+			if (lastContent?.role === "user" && lastContent.parts?.some((p) => p.functionResponse)) lastContent.parts.push(functionResponsePart);
+			else contents.push({
+				role: "user",
+				parts: [functionResponsePart]
+			});
+			if (hasImages && !modelSupportsMultimodalFunctionResponse) pendingToolImageParts.push({ text: "Tool result image:" }, ...imageParts);
+		}
+	}
+	flushPendingToolImages();
+	return contents;
+}
+/**
+* Convert tools to Gemini function declarations format.
+*
+* We prefer `parametersJsonSchema` (full JSON Schema: anyOf/oneOf/const/etc.).
+*
+* Claude models via Cloud Code Assist require the legacy `parameters` field; the API
+* translates it into Anthropic's `input_schema`. When using that path, we sanitize the
+* schema to remove Google-unsupported JSON Schema keywords.
+*/
+function convertTools(tools, model) {
+	if (tools.length === 0) return void 0;
+	/**
+	* Claude models on Cloud Code Assist need the legacy `parameters` field;
+	* the API translates it into Anthropic's `input_schema`.
+	*/
+	const useParameters = model.id.startsWith("claude-");
+	return [{ functionDeclarations: tools.map((tool) => ({
+		name: tool.name,
+		description: tool.description || "",
+		...useParameters ? { parameters: normalizeSchemaForCCA(toolWireSchema(tool)) } : { parametersJsonSchema: normalizeSchemaForGoogle(toolWireSchema(tool)) }
+	})) }];
+}
+/**
+* Map tool choice string to Gemini FunctionCallingConfigMode.
+*/
+function mapToolChoice(choice) {
+	switch (choice) {
+		case "auto": return "AUTO";
+		case "none": return "NONE";
+		case "any": return "ANY";
+		default: return "AUTO";
+	}
+}
+/**
+* Map Gemini FinishReason to our StopReason.
+*/
+function mapStopReason(reason) {
+	switch (reason) {
+		case "STOP": return "stop";
+		case "MAX_TOKENS": return "length";
+		case "BLOCKLIST":
+		case "PROHIBITED_CONTENT":
+		case "SPII":
+		case "SAFETY":
+		case "IMAGE_SAFETY":
+		case "IMAGE_PROHIBITED_CONTENT":
+		case "IMAGE_RECITATION":
+		case "IMAGE_OTHER":
+		case "RECITATION":
+		case "FINISH_REASON_UNSPECIFIED":
+		case "OTHER":
+		case "LANGUAGE":
+		case "MALFORMED_FUNCTION_CALL":
+		case "UNEXPECTED_TOOL_CALL":
+		case "NO_IMAGE": return "error";
+		default: throw new ConfigurationError(`Unhandled stop reason: ${reason}`);
+	}
+}
+/**
+* Map string finish reason to our StopReason (for raw API responses).
+*/
+function mapStopReasonString(reason) {
+	switch (reason) {
+		case "STOP": return "stop";
+		case "MAX_TOKENS": return "length";
+		default: return "error";
+	}
+}
+/**
+* Whether a completed Google assistant message carries content worth delivering.
+*
+* A tool call or any non-whitespace text counts as meaningful. An empty/whitespace-only
+* text part — or thinking that never produced an answer — is the "empty response" failure:
+* delivered as-is the agent loop has nothing to act on and silently halts, so the request
+* must be retried instead of surfaced.
+*/
+function hasMeaningfulGoogleContent(output) {
+	for (const block of output.content) {
+		if (block.type === "toolCall") return true;
+		if (block.type === "text" && block.text.trim().length > 0) return true;
+	}
+	return false;
+}
+/** Wipe a streamed message between empty-response retries so the next attempt starts clean. */
+function resetGoogleStreamOutputForRetry(output) {
+	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();
+}
+/**
+* Module-local counter for generating unique tool call IDs across Google providers.
+* Shared so that a single monotonically-increasing sequence is used regardless of which
+* Google API surface produced the stream — purely for uniqueness, not ordering semantics.
+*/
+let toolCallCounter = 0;
+function nextToolCallId(name) {
+	return `${name}_${Date.now()}_${++toolCallCounter}`;
+}
+/**
+* Push the appropriate `text_end` / `thinking_end` event for the given block.
+* Shared between the SDK-backed stream consumer and the gemini-cli SSE consumer so
+* the end-of-block event shape stays in lockstep.
+*/
+function pushBlockEndEvent(block, contentIndex, output, stream) {
+	if (block.type === "text") stream.push({
+		type: "text_end",
+		contentIndex,
+		content: block.text,
+		partial: output
+	});
+	else stream.push({
+		type: "thinking_end",
+		contentIndex,
+		content: block.thinking,
+		partial: output
+	});
+}
+/**
+* Push the three lifecycle events (`toolcall_start` / `toolcall_delta` / `toolcall_end`) for a
+* fully-assembled `ToolCall`. Caller is responsible for appending the toolCall to `output.content`
+* before invoking — this helper does not mutate `output.content`.
+*/
+function pushToolCallEvents(toolCall, contentIndex, output, stream) {
+	stream.push({
+		type: "toolcall_start",
+		contentIndex,
+		partial: output
+	});
+	stream.push({
+		type: "toolcall_delta",
+		contentIndex,
+		delta: JSON.stringify(toolCall.arguments),
+		partial: output
+	});
+	stream.push({
+		type: "toolcall_end",
+		contentIndex,
+		toolCall,
+		partial: output
+	});
+}
+function startTextOrThinkingBlock(isThinking, output, stream, onBeforeStartEvent) {
+	const block = isThinking ? {
+		type: "thinking",
+		thinking: "",
+		thinkingSignature: void 0
+	} : {
+		type: "text",
+		text: ""
+	};
+	output.content.push(block);
+	onBeforeStartEvent?.();
+	const contentIndex = output.content.length - 1;
+	if (isThinking) stream.push({
+		type: "thinking_start",
+		contentIndex,
+		partial: output
+	});
+	else stream.push({
+		type: "text_start",
+		contentIndex,
+		partial: output
+	});
+	return block;
+}
+/**
+* Drives the chunked `generateContentStream` iterator into an `AssistantMessage` and
+* the corresponding `AssistantMessageEventStream`. Shared between `streamGoogle` and
+* `streamGoogleVertex` — every observable event order and stop-reason rule is preserved.
+*
+* The caller still owns: `output` construction, timing fields (`duration`/`ttft`),
+* `rawRequestDump`, the `client.models.generateContentStream(params)` call itself,
+* pushing `start`/`done`/`error` events, and the surrounding try/catch that translates
+* thrown errors into `output.stopReason`/`errorMessage`.
+*
+* This helper handles: the chunk loop, currentBlock flush transitions, usage metadata
+* decoding (`calculateCost` included), tool-call id collision avoidance, finish-reason
+* mapping, and the abort/stop-reason post-checks that re-throw to bubble into the
+* caller's catch.
+*/
+async function consumeGoogleStream(args) {
+	const { googleStream, output, stream, model, options, retainTextSignature, onFirstToken } = args;
+	const blocks = output.content;
+	const blockIndex = () => blocks.length - 1;
+	let currentBlock = null;
+	let firstTokenSeen = false;
+	let sawFinishReason = false;
+	const flushCurrent = () => {
+		if (!currentBlock) return;
+		pushBlockEndEvent(currentBlock, blockIndex(), output, stream);
+	};
+	for await (const chunk of googleStream) {
+		if (chunk.error) {
+			const message = `Google API stream error: ${chunk.error.message || chunk.error.status || "unknown error"}`;
+			throw typeof chunk.error.code === "number" && chunk.error.code >= 400 ? new GoogleApiError(message, chunk.error.code) : new ProviderResponseError(message, {
+				provider: model.provider,
+				kind: "output"
+			});
+		}
+		if (!chunk.candidates?.length && chunk.promptFeedback?.blockReason) {
+			const detail = chunk.promptFeedback.blockReasonMessage;
+			throw new ProviderResponseError(`Request blocked by Google (${chunk.promptFeedback.blockReason})${detail ? `: ${detail}` : ""}`, {
+				provider: model.provider,
+				kind: "content-blocked"
+			});
+		}
+		const candidate = chunk.candidates?.[0];
+		if (candidate?.content?.parts) for (const part of candidate.content.parts) {
+			if (part.text !== void 0 && part.text !== "") {
+				if (!firstTokenSeen) {
+					firstTokenSeen = true;
+					onFirstToken?.();
+				}
+				const isThinking = isThinkingPart(part);
+				if (!currentBlock || isThinking && currentBlock.type !== "thinking" || !isThinking && currentBlock.type !== "text") {
+					flushCurrent();
+					currentBlock = startTextOrThinkingBlock(isThinking, output, stream);
+				}
+				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;
+					if (retainTextSignature) currentBlock.textSignature = retainThoughtSignature(currentBlock.textSignature, part.thoughtSignature);
+					stream.push({
+						type: "text_delta",
+						contentIndex: blockIndex(),
+						delta: part.text,
+						partial: output
+					});
+				}
+			} else if (part.text === "" && part.thoughtSignature && currentBlock && !part.functionCall) {
+				if (currentBlock.type === "thinking") currentBlock.thinkingSignature = retainThoughtSignature(currentBlock.thinkingSignature, part.thoughtSignature);
+				else if (retainTextSignature) currentBlock.textSignature = retainThoughtSignature(currentBlock.textSignature, part.thoughtSignature);
+			}
+			if (part.functionCall) {
+				if (currentBlock) {
+					flushCurrent();
+					currentBlock = null;
+				}
+				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);
+				pushToolCallEvents(toolCall, blockIndex(), output, stream);
+			}
+		}
+		if (candidate?.finishReason) {
+			sawFinishReason = true;
+			const mapped = mapStopReason(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 (chunk.usageMetadata) {
+			const cachedTokens = chunk.usageMetadata.cachedContentTokenCount || 0;
+			const thinkingTokens = chunk.usageMetadata.thoughtsTokenCount || 0;
+			output.usage = {
+				input: (chunk.usageMetadata.promptTokenCount || 0) - cachedTokens,
+				output: (chunk.usageMetadata.candidatesTokenCount || 0) + thinkingTokens,
+				cacheRead: cachedTokens,
+				cacheWrite: 0,
+				totalTokens: chunk.usageMetadata.totalTokenCount || 0,
+				...thinkingTokens > 0 ? { reasoningTokens: thinkingTokens } : {},
+				cost: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					total: 0
+				}
+			};
+			calculateCost(model, output.usage);
+		}
+	}
+	flushCurrent();
+	if (options?.signal?.aborted) throw new AbortError();
+	if (!sawFinishReason) throw new ProviderResponseError("Google API stream ended without a finish reason (connection dropped or response truncated)", {
+		provider: model.provider,
+		kind: "incomplete-stream"
+	});
+	if (output.stopReason === "aborted" || output.stopReason === "error") throw new ProviderResponseError(output.errorMessage ?? "An unknown error occurred", {
+		provider: model.provider,
+		kind: "output"
+	});
+}
+/**
+* Build the `GenerateContentParameters` payload for the public Gemini API and Vertex AI.
+* Both surfaces accept the same `GenerateContentConfig` shape — every numeric/string knob,
+* tool-config, thinking-config, and system-instruction conversion is identical.
+*
+* `google-gemini-cli` is NOT routed through here: its `CloudCodeAssistRequest` body has a
+* distinct top-level shape (project/request/requestType) and a different thinking-config
+* placement on `generationConfig`.
+*/
+function buildGoogleGenerateContentParams(model, context, options) {
+	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;
+	const config = {
+		...Object.keys(generationConfig).length > 0 && generationConfig,
+		...systemPrompts.length > 0 && { systemInstruction: { parts: systemPrompts.map((text) => ({ text })) } },
+		...context.tools && context.tools.length > 0 && { tools: convertTools(context.tools, model) }
+	};
+	if (model.provider === "google" && shouldSendServiceTier(options.serviceTier, model.provider)) config.serviceTier = options.serviceTier;
+	if (context.tools && context.tools.length > 0 && options.toolChoice) {
+		const choice = options.toolChoice;
+		if (typeof choice === "string") {
+			const mode = mapToolChoice(choice);
+			if (mode !== "AUTO") config.toolConfig = { functionCallingConfig: { mode } };
+		} else config.toolConfig = { functionCallingConfig: {
+			mode: "ANY",
+			allowedFunctionNames: [...choice.allowedFunctionNames]
+		} };
+	} else config.toolConfig = void 0;
+	const thinking = options.thinking;
+	if (thinking && model.reasoning && (thinking.enabled || thinking.level !== void 0 || thinking.budgetTokens !== void 0)) {
+		const cfg = { includeThoughts: thinking.enabled && !options.hideThinkingSummary };
+		if (thinking.level !== void 0) cfg.thinkingLevel = thinking.level;
+		else if (thinking.budgetTokens !== void 0) cfg.thinkingBudget = thinking.budgetTokens;
+		config.thinkingConfig = cfg;
+	}
+	if (options.signal) {
+		if (options.signal.aborted) throw new AbortError("Request aborted");
+		config.abortSignal = options.signal;
+	}
+	if (options.cachedContent !== void 0) {
+		if (options.cachedContent.trim().length === 0) throw new ValidationError("cachedContent must not be blank");
+		const incompatibleFields = [
+			config.systemInstruction !== void 0 && "systemInstruction",
+			config.tools !== void 0 && "tools",
+			config.toolConfig !== void 0 && "toolConfig"
+		].filter((field) => Boolean(field));
+		if (incompatibleFields.length > 0) throw new ValidationError(`cachedContent cannot be combined with request-level ${incompatibleFields.join(", ")}`);
+		config.cachedContent = options.cachedContent;
+	}
+	return {
+		model: model.id,
+		contents,
+		config
+	};
+}
+function streamGoogleGenAI(args) {
+	const { model, options, api, retainTextSignature, prepare } = args;
+	const stream = new AssistantMessageEventStream();
+	(async () => {
+		const startTime = performance.now();
+		let firstTokenTime;
+		const output = {
+			role: "assistant",
+			content: [],
+			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;
+		try {
+			const plan = await prepare();
+			let params = plan.params;
+			const replacement = await options?.onPayload?.(params, model);
+			if (replacement !== void 0) params = replacement;
+			rawRequestDump = {
+				provider: model.provider,
+				api: output.api,
+				model: model.id,
+				method: "POST",
+				url: plan.url,
+				body: params,
+				headers: plan.headers
+			};
+			const bodyJson = JSON.stringify(paramsToWireBody(params));
+			const fetchImpl = plan.fetch ?? options?.fetch ?? globalThis.fetch.bind(globalThis);
+			const openStreamAt = async (requestUrl) => {
+				const response = await fetchImpl(requestUrl, {
+					method: "POST",
+					headers: {
+						...plan.headers,
+						"Content-Type": "application/json",
+						Accept: "text/event-stream"
+					},
+					body: bodyJson,
+					signal: options?.signal
+				});
+				if (!response.ok) {
+					const errorText = await response.text().catch(() => "");
+					throw new GoogleApiError(`Google API error (${response.status}): ${extractGoogleErrorMessage(errorText)}`, response.status, { headers: response.headers });
+				}
+				if (!response.body) throw new ProviderResponseError("Google API returned an empty response body", {
+					provider: model.provider,
+					kind: "empty-body"
+				});
+				return response.body;
+			};
+			const openStream = async () => {
+				if (!plan.fallbackUrl) return openStreamAt(plan.url);
+				try {
+					return await openStreamAt(plan.url);
+				} catch (error) {
+					if (error instanceof GoogleApiError && error.status === 404) return openStreamAt(plan.fallbackUrl);
+					throw error;
+				}
+			};
+			let body = await openStream();
+			stream.push({
+				type: "start",
+				partial: output
+			});
+			for (let emptyAttempt = 0;; emptyAttempt++) {
+				await consumeGoogleStream({
+					googleStream: readSseJson(body, options?.signal, (event) => options?.onSseEvent?.({
+						event: event.event,
+						data: event.data,
+						raw: [...event.raw]
+					}, model)),
+					output,
+					stream,
+					model,
+					options,
+					retainTextSignature,
+					onFirstToken: () => {
+						firstTokenTime = performance.now();
+					}
+				});
+				if (output.stopReason !== "stop" || hasMeaningfulGoogleContent(output) || options?.acceptEmptyResponse === true) break;
+				if (emptyAttempt >= 2) throw new ProviderResponseError(`Google API returned an empty response (finishReason STOP with no content) after 3 attempts`, {
+					provider: model.provider,
+					kind: "empty-body"
+				});
+				try {
+					await scheduler.wait(500 * 2 ** emptyAttempt, { signal: options?.signal });
+				} catch {
+					throw new AbortError();
+				}
+				resetGoogleStreamOutputForRetry(output);
+				body = await openStream();
+			}
+			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;
+}
+/**
+* Lift the SDK's `params.config` fields out of `config` and place them where the
+* Gemini / Vertex AI REST API expects them on the request body. Mirrors the
+* generateContentParametersTo{Mldev,Vertex} transformation in @google/genai
+* for the subset of fields this codebase actually sets.
+*
+* `abortSignal` is intentionally dropped — the SDK propagates it via `fetch.signal`,
+* which our caller already wires up through `options.signal`.
+*/
+function paramsToWireBody(params) {
+	const body = { contents: params.contents };
+	const config = params.config;
+	if (!config) return body;
+	if (config.systemInstruction !== void 0) body.systemInstruction = config.systemInstruction;
+	if (config.tools !== void 0) body.tools = config.tools;
+	if (config.toolConfig !== void 0) body.toolConfig = config.toolConfig;
+	if (config.safetySettings !== void 0) body.safetySettings = config.safetySettings;
+	if (config.cachedContent !== void 0) body.cachedContent = config.cachedContent;
+	if (config.serviceTier !== void 0) body.serviceTier = config.serviceTier;
+	const gen = {};
+	if (config.temperature !== void 0) gen.temperature = config.temperature;
+	if (config.maxOutputTokens !== void 0) gen.maxOutputTokens = config.maxOutputTokens;
+	if (config.topP !== void 0) gen.topP = config.topP;
+	if (config.topK !== void 0) gen.topK = config.topK;
+	if (config.candidateCount !== void 0) gen.candidateCount = config.candidateCount;
+	if (config.stopSequences !== void 0) gen.stopSequences = config.stopSequences;
+	if (config.presencePenalty !== void 0) gen.presencePenalty = config.presencePenalty;
+	if (config.frequencyPenalty !== void 0) gen.frequencyPenalty = config.frequencyPenalty;
+	if (config.seed !== void 0) gen.seed = config.seed;
+	if (config.responseMimeType !== void 0) gen.responseMimeType = config.responseMimeType;
+	if (config.responseSchema !== void 0) gen.responseSchema = config.responseSchema;
+	if (config.responseJsonSchema !== void 0) gen.responseJsonSchema = config.responseJsonSchema;
+	if (config.responseModalities !== void 0) gen.responseModalities = config.responseModalities;
+	if (config.thinkingConfig !== void 0) gen.thinkingConfig = config.thinkingConfig;
+	const generationConfig = config;
+	if (generationConfig.minP !== void 0) gen.minP = generationConfig.minP;
+	if (generationConfig.repetitionPenalty !== void 0) gen.repetitionPenalty = generationConfig.repetitionPenalty;
+	if (Object.keys(gen).length > 0) body.generationConfig = gen;
+	return body;
+}
+function extractGoogleErrorMessage(errorText) {
+	if (!errorText) return "Unknown error";
+	try {
+		const parsed = JSON.parse(errorText);
+		if (parsed.error?.message) return parsed.error.message;
+	} catch {}
+	return errorText;
+}
+//#endregion
+export { isThinkingPart as a, nextToolCallId as c, retainThoughtSignature as d, startTextOrThinkingBlock as f, hasMeaningfulGoogleContent as i, pushBlockEndEvent as l, convertMessages as n, mapStopReasonString as o, streamGoogleGenAI as p, convertTools as r, mapToolChoice as s, buildGoogleGenerateContentParams as t, pushToolCallEvents as u };