@openclaw/ai 2026.9.2 → 2026.9.3

package/dist/event-stream-zctLx0yr.d.mts

@@ -1 +0,0 @@
-import "./event-stream-BhT5T1Ay.mjs";

package/dist/google-shared-CWeG8RIl.mjs

@@ -1,636 +0,0 @@
-import { i as clampThinkingLevel, r as calculateCost, t as sanitizeSurrogates } from "./sanitize-unicode-D6xUvZaS.mjs";
-import { a as describeToolResultMediaPlaceholder, c as extractToolResultText, d as isImageWithMediaPayload } from "./host-CEvLw30U.mjs";
-import { d as stripSystemPromptCacheBoundary, m as sortPromptCacheToolsByName } from "./simple-options-BjHCCh4v.mjs";
-import { _ as transportAbortError, n as coerceTransportToolCallArguments, p as notifyProviderStreamOpened, t as assignTransportErrorDetails } from "./transport-stream-shared-CZqMhfIw.mjs";
-import { t as notifyLlmRequestActivity } from "./llm-request-activity-BjtkplhG.mjs";
-import { t as googleFlashSupportsMinimalThinking } from "./google-thinking-level-C-V3tecN.mjs";
-import { t as transformProviderMessages } from "./provider-transcript-transform-BaMbI1hr.mjs";
-import { FinishReason, FunctionCallingConfigMode, ThinkingLevel } from "@google/genai";
-//#region packages/ai/src/providers/google-shared.ts
-/**
-* Shared utilities for Google Generative AI and Google Vertex providers.
-*/
-const GOOGLE_MODEL_RESOURCE_PREFIX = /^(?:(?:projects\/[^/]+\/locations\/[^/]+\/)?publishers\/google\/models\/|google\/|models\/)/u;
-/**
-* 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.
-* @internal Directly tested provider implementation detail.
-*/
-function retainThoughtSignature(existing, incoming) {
-	if (typeof incoming === "string" && incoming.length > 0) return incoming;
-	return existing;
-}
-const base64SignaturePattern = /^[A-Za-z0-9+/]+={0,2}$/;
-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;
-}
-/**
-* Models via Google APIs that require explicit tool call IDs in function calls/responses.
-* @internal Directly tested provider implementation detail.
-*/
-function requiresToolCallId(modelId) {
-	return modelId.startsWith("claude-") || modelId.startsWith("gpt-oss-");
-}
-function getGeminiMajorVersion(modelId) {
-	const match = modelId.toLowerCase().match(/(?:^|\/)gemini(?:-live)?-(\d+)/);
-	if (!match) return;
-	const majorVersion = match.at(1);
-	return majorVersion === void 0 ? void 0 : Number.parseInt(majorVersion, 10);
-}
-function supportsMultimodalFunctionResponse(modelId) {
-	const geminiMajorVersion = getGeminiMajorVersion(modelId);
-	if (geminiMajorVersion !== void 0) return geminiMajorVersion >= 3;
-	return true;
-}
-/**
-* Convert internal messages to Gemini Content[] format.
-* @internal Directly tested provider implementation detail.
-*/
-function convertMessages(model, context) {
-	const contents = [];
-	const normalizeToolCallId = (id) => {
-		if (!requiresToolCallId(model.id)) return id;
-		return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
-	};
-	const transformedMessages = transformProviderMessages(context.messages, model, normalizeToolCallId);
-	const requiresToolCallThoughtSignature = model.provider !== "google-gemini-cli" && (isGemini3ProModel(model) || isGemini3FlashModel(model));
-	const pendingToolResultImageTurns = [];
-	const sameRouteToolCallIds = /* @__PURE__ */ new Set();
-	let activeToolResultParts;
-	const flushToolResultRun = () => {
-		contents.push(...pendingToolResultImageTurns);
-		pendingToolResultImageTurns.length = 0;
-		activeToolResultParts = void 0;
-	};
-	for (const msg of transformedMessages) {
-		if (msg.role !== "toolResult") flushToolResultRun();
-		if (msg.role === "user") {
-			if (typeof msg.content === "string") contents.push({
-				role: "user",
-				parts: [{ text: sanitizeSurrogates(msg.content) || " " }]
-			});
-			else {
-				const parts = msg.content.map((item) => {
-					if (item.type === "text") return { text: sanitizeSurrogates(item.text) || " " };
-					return { inlineData: {
-						mimeType: item.mimeType,
-						data: item.data
-					} };
-				});
-				if (parts.length === 0) parts.push({ text: " " });
-				contents.push({
-					role: "user",
-					parts
-				});
-			}
-		} else if (msg.role === "assistant") {
-			const parts = [];
-			let sawFunctionCall = false;
-			const isSameProviderAndModel = msg.provider === model.provider && msg.api === model.api && msg.model === model.id;
-			for (const block of msg.content) if (block.type === "text") {
-				const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.textSignature);
-				if ((!block.text || block.text.trim() === "") && !thoughtSignature) continue;
-				parts.push({
-					text: sanitizeSurrogates(block.text),
-					...thoughtSignature && { thoughtSignature }
-				});
-			} else if (block.type === "thinking") {
-				const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.thinkingSignature);
-				if ((!block.thinking || block.thinking.trim() === "") && !thoughtSignature) continue;
-				if (isSameProviderAndModel) parts.push({
-					thought: true,
-					text: sanitizeSurrogates(block.thinking),
-					...thoughtSignature && { thoughtSignature }
-				});
-				else parts.push({ text: sanitizeSurrogates(block.thinking) });
-			} else if (block.type === "toolCall") {
-				if (isSameProviderAndModel && model.provider !== "google-gemini-cli") sameRouteToolCallIds.add(block.id);
-				const args = coerceTransportToolCallArguments(block.arguments);
-				const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.thoughtSignature) ?? (!sawFunctionCall && requiresToolCallThoughtSignature ? "skip_thought_signature_validator" : void 0);
-				sawFunctionCall = true;
-				const part = {
-					functionCall: {
-						name: block.name,
-						args,
-						...sameRouteToolCallIds.has(block.id) || requiresToolCallId(model.id) ? { id: block.id } : {}
-					},
-					...thoughtSignature && { thoughtSignature }
-				};
-				parts.push(part);
-			}
-			if (parts.length === 0) continue;
-			contents.push({
-				role: "model",
-				parts
-			});
-		} else if (msg.role === "toolResult") {
-			const textResult = extractToolResultText(msg.content);
-			const imageContent = model.input.includes("image") ? msg.content.filter(isImageWithMediaPayload) : [];
-			const hasText = textResult.length > 0;
-			const hasImages = imageContent.length > 0;
-			const mediaPlaceholder = describeToolResultMediaPlaceholder(msg.content);
-			const modelSupportsMultimodalFunctionResponse = supportsMultimodalFunctionResponse(model.id);
-			const responseValue = hasText ? sanitizeSurrogates(textResult) : mediaPlaceholder ?? "";
-			const imageParts = imageContent.map((imageBlock) => ({ inlineData: {
-				mimeType: imageBlock.mimeType,
-				data: imageBlock.data
-			} }));
-			const includeId = sameRouteToolCallIds.has(msg.toolCallId) || requiresToolCallId(model.id);
-			const functionResponsePart = { functionResponse: {
-				name: msg.toolName,
-				response: msg.isError ? { error: responseValue } : { output: responseValue },
-				...hasImages && modelSupportsMultimodalFunctionResponse && { parts: imageParts },
-				...includeId ? { id: msg.toolCallId } : {}
-			} };
-			if (activeToolResultParts) activeToolResultParts.push(functionResponsePart);
-			else {
-				activeToolResultParts = [functionResponsePart];
-				contents.push({
-					role: "user",
-					parts: activeToolResultParts
-				});
-			}
-			if (hasImages && !modelSupportsMultimodalFunctionResponse) pendingToolResultImageTurns.push({
-				role: "user",
-				parts: [{ text: "Tool result image:" }, ...imageParts]
-			});
-		}
-	}
-	flushToolResultRun();
-	if (contents.length === 0) contents.push({
-		role: "user",
-		parts: [{ text: " " }]
-	});
-	return contents;
-}
-/**
-* Convert tools to Gemini function declarations format.
-* @internal Directly tested provider implementation detail.
-*/
-function convertTools(tools) {
-	if (tools.length === 0) return;
-	return [{ functionDeclarations: sortPromptCacheToolsByName(tools).map((tool) => ({
-		name: tool.name,
-		description: tool.description,
-		parametersJsonSchema: tool.parameters
-	})) }];
-}
-/**
-* Map tool choice string to Gemini FunctionCallingConfigMode.
-* @internal Directly tested provider implementation detail.
-*/
-function mapToolChoice(choice) {
-	switch (choice) {
-		case "auto": return FunctionCallingConfigMode.AUTO;
-		case "none": return FunctionCallingConfigMode.NONE;
-		case "any": return FunctionCallingConfigMode.ANY;
-		default: return FunctionCallingConfigMode.AUTO;
-	}
-}
-function createGoogleAssistantOutput(model, api = model.api) {
-	return {
-		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()
-	};
-}
-async function runGoogleGenerateContentLifecycle(params) {
-	const { stream, model, output, options } = params;
-	try {
-		const client = params.createClient();
-		let requestParams = params.buildParams();
-		const nextParams = await options?.onPayload?.(requestParams, model);
-		if (nextParams !== void 0) requestParams = nextParams;
-		const googleIterator = (await client.models.generateContentStream(requestParams))[Symbol.asyncIterator]();
-		await notifyProviderStreamOpened({
-			options,
-			cancelStream: async () => {
-				await googleIterator.return?.();
-			}
-		});
-		await consumeGoogleGenerateContentStream({
-			chunks: { [Symbol.asyncIterator]: () => googleIterator },
-			model,
-			output,
-			stream,
-			signal: options?.signal,
-			nextToolCallId: params.nextToolCallId
-		});
-	} catch (error) {
-		for (const block of output.content) if ("index" in block) delete block.index;
-		const failure = options?.signal?.aborted ? transportAbortError(options.signal) : error;
-		assignTransportErrorDetails(output, failure, options?.signal);
-		stream.push({
-			type: "error",
-			reason: output.stopReason === "aborted" ? "aborted" : "error",
-			error: output
-		});
-		stream.end();
-	}
-}
-function buildGoogleGenerateContentParams(model, context, options = {}) {
-	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.stop !== void 0 && options.stop.length > 0) generationConfig.stopSequences = options.stop;
-	const config = {
-		...Object.keys(generationConfig).length > 0 && generationConfig,
-		...context.systemPrompt && { systemInstruction: sanitizeSurrogates(stripSystemPromptCacheBoundary(context.systemPrompt)) },
-		...context.tools && context.tools.length > 0 && { tools: convertTools(context.tools) }
-	};
-	if (context.tools && context.tools.length > 0 && options.toolChoice) config.toolConfig = { functionCallingConfig: { mode: mapToolChoice(options.toolChoice) } };
-	else config.toolConfig = void 0;
-	if (options.thinking?.enabled && model.reasoning) {
-		const thinkingConfig = { includeThoughts: true };
-		if (options.thinking.level !== void 0) thinkingConfig.thinkingLevel = ThinkingLevel[options.thinking.level];
-		else if (options.thinking.budgetTokens !== void 0) thinkingConfig.thinkingBudget = options.thinking.budgetTokens;
-		config.thinkingConfig = thinkingConfig;
-	} else if (model.reasoning && options.thinking && !options.thinking.enabled) {
-		const disabledThinkingConfig = getDisabledGoogleThinkingConfig(model);
-		if (Object.keys(disabledThinkingConfig).length > 0) config.thinkingConfig = disabledThinkingConfig;
-	}
-	if (options.signal) {
-		if (options.signal.aborted) throw new Error("Request aborted");
-		config.abortSignal = options.signal;
-	}
-	return {
-		model: model.id,
-		contents,
-		config
-	};
-}
-function isAdaptiveGoogleReasoningLevel(value) {
-	return value === "adaptive";
-}
-function buildGoogleSimpleThinking(model, options, config) {
-	if (!options?.reasoning || options.reasoning === "off") return { enabled: false };
-	if (isAdaptiveGoogleReasoningLevel(options.reasoning)) {
-		if (!model.reasoning) return { enabled: false };
-		if (isGemma4Model(model)) return {
-			enabled: true,
-			level: ThinkingLevel.HIGH
-		};
-		return isGemini3ProModel(model) || isGemini3FlashModel(model) ? { enabled: true } : {
-			enabled: true,
-			budgetTokens: -1
-		};
-	}
-	const clampedReasoning = clampThinkingLevel(model, options.reasoning);
-	if (clampedReasoning === "off") return { enabled: false };
-	const effort = clampedReasoning === "max" ? "high" : clampedReasoning;
-	if (isGemini3ProModel(model) || isGemini3FlashModel(model) || config?.includeGemma4ThinkingLevel && isGemma4Model(model)) return {
-		enabled: true,
-		level: getGoogleThinkingLevel(effort, model, { includeGemma4: config?.includeGemma4ThinkingLevel })
-	};
-	return {
-		enabled: true,
-		budgetTokens: getGoogleBudget(model, effort, options.thinkingBudgets, { useFlashLiteBudgets: config?.useFlashLiteBudgets })
-	};
-}
-function getDisabledGoogleThinkingConfig(model) {
-	if (isGemini3ProModel(model)) return { thinkingLevel: ThinkingLevel.LOW };
-	if (isGemini3FlashModel(model)) return { thinkingLevel: googleFlashSupportsMinimalThinking(model.id) ? ThinkingLevel.MINIMAL : ThinkingLevel.LOW };
-	if (isGemma4Model(model) || model.id.toLowerCase().includes("gemini-2.5-pro")) return {};
-	return { thinkingBudget: 0 };
-}
-/** @internal Directly tested provider implementation detail. */
-function isGemma4Model(model) {
-	return /gemma-?4/.test(model.id.toLowerCase());
-}
-function isGemini3ProModel(model) {
-	return /gemini-(?:3(?:\.\d+)?-pro|pro-latest)/.test(model.id.toLowerCase());
-}
-function isGemini3FlashModel(model) {
-	return /gemini-(?:3(?:\.\d+)?-flash|flash(?:-lite)?-latest)/.test(model.id.toLowerCase());
-}
-function getGoogleThinkingLevel(effort, model, config) {
-	if (isGemini3ProModel(model)) switch (effort) {
-		case "minimal":
-		case "low": return ThinkingLevel.LOW;
-		case "medium":
-		case "high": return ThinkingLevel.HIGH;
-	}
-	if (config?.includeGemma4 && isGemma4Model(model)) switch (effort) {
-		case "minimal":
-		case "low": return ThinkingLevel.MINIMAL;
-		case "medium":
-		case "high": return ThinkingLevel.HIGH;
-	}
-	switch (effort) {
-		case "minimal": return isGemini3FlashModel(model) && !googleFlashSupportsMinimalThinking(model.id) ? ThinkingLevel.LOW : ThinkingLevel.MINIMAL;
-		case "low": return ThinkingLevel.LOW;
-		case "medium": return ThinkingLevel.MEDIUM;
-		case "high": return ThinkingLevel.HIGH;
-	}
-	return ThinkingLevel.HIGH;
-}
-function getGoogleBudget(model, effort, customBudgets, config) {
-	if (customBudgets?.[effort] !== void 0) return customBudgets[effort];
-	if (model.id.includes("2.5-pro")) return {
-		minimal: 128,
-		low: 2048,
-		medium: 8192,
-		high: 32768
-	}[effort];
-	if (config?.useFlashLiteBudgets && model.id.includes("2.5-flash-lite")) return {
-		minimal: 512,
-		low: 2048,
-		medium: 8192,
-		high: 24576
-	}[effort];
-	if (model.id.includes("2.5-flash")) return {
-		minimal: 128,
-		low: 2048,
-		medium: 8192,
-		high: 24576
-	}[effort];
-	return -1;
-}
-/**
-* Map Gemini FinishReason to our StopReason.
-* @internal Directly tested provider implementation detail.
-*/
-function mapStopReason(reason) {
-	switch (reason) {
-		case FinishReason.STOP: return "stop";
-		case FinishReason.MAX_TOKENS: return "length";
-		case FinishReason.BLOCKLIST:
-		case FinishReason.PROHIBITED_CONTENT:
-		case FinishReason.SPII:
-		case FinishReason.SAFETY:
-		case FinishReason.IMAGE_SAFETY:
-		case FinishReason.IMAGE_PROHIBITED_CONTENT:
-		case FinishReason.IMAGE_RECITATION:
-		case FinishReason.IMAGE_OTHER:
-		case FinishReason.RECITATION:
-		case FinishReason.FINISH_REASON_UNSPECIFIED:
-		case FinishReason.OTHER:
-		case FinishReason.LANGUAGE:
-		case FinishReason.MALFORMED_FUNCTION_CALL:
-		case FinishReason.TOO_MANY_TOOL_CALLS:
-		case FinishReason.UNEXPECTED_TOOL_CALL:
-		case FinishReason.NO_IMAGE: return "error";
-		default: throw new Error(`Unhandled stop reason: ${String(reason)}`);
-	}
-}
-/** @internal Directly tested provider implementation detail. */
-async function consumeGoogleGenerateContentStream(params) {
-	params.stream.push({
-		type: "start",
-		partial: params.output
-	});
-	let currentBlock = null;
-	const blocks = params.output.content;
-	let sawTerminalReason = false;
-	let terminalGenerationError;
-	const knownUsage = {
-		promptTokenCount: 0,
-		cachedContentTokenCount: 0,
-		toolUsePromptTokenCount: 0,
-		candidatesTokenCount: 0,
-		thoughtsTokenCount: 0
-	};
-	const toolCallIds = /* @__PURE__ */ new Set();
-	for (const block of blocks) if (block.type === "toolCall") toolCallIds.add(block.id);
-	const blockIndex = () => blocks.length - 1;
-	const endCurrentBlock = () => {
-		if (!currentBlock) return;
-		if (currentBlock.type === "text") params.stream.push({
-			type: "text_end",
-			contentIndex: blockIndex(),
-			content: currentBlock.text,
-			partial: params.output
-		});
-		else params.stream.push({
-			type: "thinking_end",
-			contentIndex: blockIndex(),
-			content: currentBlock.thinking,
-			partial: params.output
-		});
-		currentBlock = null;
-	};
-	for await (const chunk of params.chunks) {
-		notifyLlmRequestActivity(params.signal);
-		params.output.responseId ||= chunk.responseId;
-		const responseModel = chunk.modelVersion?.trim();
-		if (responseModel && params.model.id.replace(GOOGLE_MODEL_RESOURCE_PREFIX, "") !== responseModel.replace(GOOGLE_MODEL_RESOURCE_PREFIX, "")) params.output.responseModel ||= responseModel;
-		if (chunk.usageMetadata) {
-			for (const field of Object.keys(knownUsage)) {
-				const value = chunk.usageMetadata[field];
-				if (typeof value === "number") knownUsage[field] = value;
-			}
-			const promptTokens = knownUsage.promptTokenCount;
-			const cacheRead = knownUsage.cachedContentTokenCount;
-			const toolUsePromptTokens = knownUsage.toolUsePromptTokenCount;
-			const outputTokens = knownUsage.candidatesTokenCount + knownUsage.thoughtsTokenCount;
-			params.output.usage = {
-				input: Math.max(0, promptTokens - cacheRead) + toolUsePromptTokens,
-				output: outputTokens,
-				cacheRead,
-				cacheWrite: 0,
-				totalTokens: chunk.usageMetadata.totalTokenCount ?? promptTokens + outputTokens + toolUsePromptTokens,
-				cost: {
-					input: 0,
-					output: 0,
-					cacheRead: 0,
-					cacheWrite: 0,
-					total: 0
-				}
-			};
-			calculateCost(params.model, params.output.usage);
-		}
-		const candidate = chunk.candidates?.[0];
-		const promptFeedback = chunk.promptFeedback;
-		if (!candidate && promptFeedback) {
-			const blockReason = promptFeedback.blockReason ?? "PROMPT_BLOCKED";
-			const blockMessage = promptFeedback.blockReasonMessage?.trim();
-			params.output.errorCode = blockReason;
-			params.output.errorType = "google_prompt_blocked";
-			throw new Error(`Google prompt blocked (${blockReason})${blockMessage ? `: ${blockMessage}` : ""}`);
-		}
-		if (candidate?.content?.parts) for (const [partIndex, part] of candidate.content.parts.entries()) {
-			const text = part.text;
-			const hasText = typeof text === "string";
-			const hasThoughtSignature = typeof part.thoughtSignature === "string" && part.thoughtSignature.length > 0;
-			const signatureOnly = hasThoughtSignature && (!hasText || text.length === 0) && Object.keys(part).every((key) => key === "thought" || key === "thoughtSignature" || key === "text");
-			if (signatureOnly) {
-				if (!hasText && part.thought !== true) {
-					const latestBlock = blocks.at(-1);
-					if (partIndex === 0 && latestBlock?.type === "toolCall" && !latestBlock.thoughtSignature) {
-						latestBlock.thoughtSignature = retainThoughtSignature(latestBlock.thoughtSignature, part.thoughtSignature);
-						continue;
-					}
-				}
-				endCurrentBlock();
-			}
-			if (hasText || signatureOnly) {
-				if (currentBlock && (hasThoughtSignature || partIndex > 0)) {
-					const currentSignature = currentBlock.type === "thinking" ? currentBlock.thinkingSignature : currentBlock.textSignature;
-					if ((currentBlock.type === "thinking" ? currentBlock.thinking : currentBlock.text).length > 0 && (currentSignature !== part.thoughtSignature || partIndex > 0 && (currentSignature || hasThoughtSignature))) endCurrentBlock();
-				}
-				const isThinking = isThinkingPart(part);
-				if (!currentBlock || isThinking && currentBlock.type !== "thinking" || !isThinking && currentBlock.type !== "text") {
-					endCurrentBlock();
-					if (isThinking) {
-						currentBlock = {
-							type: "thinking",
-							thinking: "",
-							thinkingSignature: void 0
-						};
-						params.output.content.push(currentBlock);
-						params.stream.push({
-							type: "thinking_start",
-							contentIndex: blockIndex(),
-							partial: params.output
-						});
-					} else {
-						currentBlock = {
-							type: "text",
-							text: ""
-						};
-						params.output.content.push(currentBlock);
-						params.stream.push({
-							type: "text_start",
-							contentIndex: blockIndex(),
-							partial: params.output
-						});
-					}
-				}
-				const delta = hasText ? text : "";
-				if (currentBlock.type === "thinking") {
-					currentBlock.thinking += delta;
-					currentBlock.thinkingSignature = retainThoughtSignature(currentBlock.thinkingSignature, part.thoughtSignature);
-					params.stream.push({
-						type: "thinking_delta",
-						contentIndex: blockIndex(),
-						delta,
-						partial: params.output
-					});
-				} else {
-					currentBlock.text += delta;
-					currentBlock.textSignature = retainThoughtSignature(currentBlock.textSignature, part.thoughtSignature);
-					params.stream.push({
-						type: "text_delta",
-						contentIndex: blockIndex(),
-						delta,
-						partial: params.output
-					});
-				}
-				if (signatureOnly) endCurrentBlock();
-			}
-			if (part.functionCall) {
-				endCurrentBlock();
-				const providedId = part.functionCall.id;
-				const toolCall = {
-					type: "toolCall",
-					id: !providedId || toolCallIds.has(providedId) ? params.nextToolCallId(part.functionCall.name) : providedId,
-					name: part.functionCall.name || "",
-					arguments: part.functionCall.args ?? {},
-					...part.thoughtSignature && { thoughtSignature: part.thoughtSignature }
-				};
-				params.output.content.push(toolCall);
-				toolCallIds.add(toolCall.id);
-				params.stream.push({
-					type: "toolcall_start",
-					contentIndex: blockIndex(),
-					partial: params.output
-				});
-				params.stream.push({
-					type: "toolcall_delta",
-					contentIndex: blockIndex(),
-					delta: JSON.stringify(toolCall.arguments),
-					partial: params.output
-				});
-				params.stream.push({
-					type: "toolcall_end",
-					contentIndex: blockIndex(),
-					toolCall,
-					partial: params.output
-				});
-			}
-		}
-		if (candidate?.finishReason && candidate.finishReason !== FinishReason.FINISH_REASON_UNSPECIFIED) {
-			sawTerminalReason = true;
-			params.output.stopReason = mapStopReason(candidate.finishReason);
-			if (params.output.stopReason === "error") {
-				const finishMessage = candidate.finishMessage?.trim();
-				terminalGenerationError = Object.assign(/* @__PURE__ */ new Error(`Google generation stopped (${candidate.finishReason})${finishMessage ? `: ${finishMessage}` : ""}`), {
-					code: candidate.finishReason,
-					type: "google_generation_failed"
-				});
-			}
-			if (params.output.stopReason === "stop" && params.output.content.some((block) => block.type === "toolCall")) params.output.stopReason = "toolUse";
-		}
-	}
-	endCurrentBlock();
-	if (params.signal?.aborted) throw transportAbortError(params.signal);
-	if (terminalGenerationError) {
-		params.output.errorCode = terminalGenerationError.code;
-		params.output.errorType = terminalGenerationError.type;
-		throw terminalGenerationError;
-	}
-	if (!sawTerminalReason) {
-		params.output.errorCode = "STREAM_INCOMPLETE";
-		params.output.errorType = "google_incomplete_stream";
-		throw new Error("Google stream ended before a terminal finish reason");
-	}
-	if (params.output.stopReason === "aborted" || params.output.stopReason === "error") throw new Error("An unknown error occurred");
-	params.stream.push({
-		type: "done",
-		reason: params.output.stopReason,
-		message: params.output
-	});
-	params.stream.end();
-}
-//#endregion
-export { runGoogleGenerateContentLifecycle as i, buildGoogleSimpleThinking as n, createGoogleAssistantOutput as r, buildGoogleGenerateContentParams as t };

package/dist/google-thinking-level-C-V3tecN.mjs

@@ -1,9 +0,0 @@
-//#region packages/ai/src/transports/google-thinking-level.ts
-/** Returns whether a Gemini Flash model accepts the MINIMAL thinking level. */
-function googleFlashSupportsMinimalThinking(modelId) {
-	const match = modelId.toLowerCase().match(/(?:^|\/)gemini-3\.(\d+)-flash(?:-|$)/);
-	if (!match) return true;
-	return Number.parseInt(match[1] ?? "0", 10) < 7;
-}
-//#endregion
-export { googleFlashSupportsMinimalThinking as t };