@langchain/google 0.1.0

package/dist/converters/messages.js

@@ -0,0 +1,691 @@
+import { iife } from "../utils/misc.js";
+import { InvalidInputError, ToolCallNotFoundError } from "../utils/errors.js";
+import { AIMessage, ChatMessage, HumanMessage, SystemMessage, ToolMessage, convertToProviderContentBlock, isDataContentBlock, parseBase64DataUrl } from "@langchain/core/messages";
+
+//#region src/converters/messages.ts
+/**
+* Standard content block converter for Google Gemini API.
+* Converts deprecated Data content blocks to Gemini Part format.
+*
+* @deprecated This converter is for backward compatibility with older message formats.
+* Use ContentBlock.Multimodal.Standard instead.
+*/
+const geminiContentBlockConverter = {
+	providerName: "ChatGoogle",
+	fromStandardTextBlock(block) {
+		return { text: block.text };
+	},
+	fromStandardImageBlock(block) {
+		if (isDataContentBlock(block)) {
+			if (block.source_type === "base64") {
+				if (!block.mime_type) throw new InvalidInputError("mime_type is required for base64 image blocks");
+				const dataStr = typeof block.data === "string" ? block.data : typeof block.data === "object" && block.data !== null ? btoa(Array.from(block.data).map((byte) => String.fromCharCode(byte)).join("")) : String(block.data);
+				return { inlineData: {
+					mimeType: block.mime_type,
+					data: dataStr
+				} };
+			}
+			if (block.source_type === "url") {
+				const parsed = parseBase64DataUrl({ dataUrl: block.url });
+				if (parsed) {
+					const dataStr = typeof parsed.data === "string" ? parsed.data : btoa(Array.from(parsed.data).map((byte) => String.fromCharCode(byte)).join(""));
+					return { inlineData: {
+						mimeType: parsed.mime_type || block.mime_type || "image/jpeg",
+						data: dataStr
+					} };
+				}
+				return { fileData: {
+					mimeType: block.mime_type || "image/jpeg",
+					fileUri: block.url
+				} };
+			}
+			if (block.source_type === "id") return { fileData: {
+				mimeType: block.mime_type || "image/jpeg",
+				fileUri: block.id
+			} };
+		}
+		throw new InvalidInputError(`Image content blocks with source_type "${block.source_type}" are not supported for ChatGoogle. Supported source types are: "base64", "url", "id".`);
+	},
+	fromStandardAudioBlock(block) {
+		if (isDataContentBlock(block)) {
+			if (block.source_type === "base64") {
+				if (!block.mime_type) throw new InvalidInputError("mime_type is required for base64 audio blocks");
+				const dataStr = typeof block.data === "string" ? block.data : typeof block.data === "object" && block.data !== null ? btoa(Array.from(block.data).map((byte) => String.fromCharCode(byte)).join("")) : String(block.data);
+				return { inlineData: {
+					mimeType: block.mime_type,
+					data: dataStr
+				} };
+			}
+			if (block.source_type === "url") {
+				const parsed = parseBase64DataUrl({ dataUrl: block.url });
+				if (parsed) {
+					const dataStr = typeof parsed.data === "string" ? parsed.data : btoa(Array.from(parsed.data).map((byte) => String.fromCharCode(byte)).join(""));
+					return { inlineData: {
+						mimeType: parsed.mime_type || block.mime_type || "audio/mpeg",
+						data: dataStr
+					} };
+				}
+				return { fileData: {
+					mimeType: block.mime_type || "audio/mpeg",
+					fileUri: block.url
+				} };
+			}
+			if (block.source_type === "id") return { fileData: {
+				mimeType: block.mime_type || "audio/mpeg",
+				fileUri: block.id
+			} };
+		}
+		throw new InvalidInputError(`Audio content blocks with source_type "${block.source_type}" are not supported for ChatGoogle. Supported source types are: "base64", "url", "id".`);
+	},
+	fromStandardFileBlock(block) {
+		if (isDataContentBlock(block)) {
+			if (block.source_type === "base64") {
+				if (!block.mime_type) throw new InvalidInputError("mime_type is required for base64 file blocks");
+				const dataStr = typeof block.data === "string" ? block.data : typeof block.data === "object" && block.data !== null ? btoa(Array.from(block.data).map((byte) => String.fromCharCode(byte)).join("")) : String(block.data);
+				return { inlineData: {
+					mimeType: block.mime_type,
+					data: dataStr
+				} };
+			}
+			if (block.source_type === "url") {
+				const parsed = parseBase64DataUrl({ dataUrl: block.url });
+				if (parsed) {
+					const dataStr = typeof parsed.data === "string" ? parsed.data : btoa(Array.from(parsed.data).map((byte) => String.fromCharCode(byte)).join(""));
+					return { inlineData: {
+						mimeType: parsed.mime_type || block.mime_type || "application/octet-stream",
+						data: dataStr
+					} };
+				}
+				return { fileData: {
+					mimeType: block.mime_type || "application/octet-stream",
+					fileUri: block.url
+				} };
+			}
+			if (block.source_type === "id") return { fileData: {
+				mimeType: block.mime_type || "application/octet-stream",
+				fileUri: block.id
+			} };
+		}
+		if ("source_type" in block && block.source_type === "text" && "text" in block) return { text: block.text };
+		throw new InvalidInputError(`File content blocks with source_type "${block.source_type}" are not supported for ChatGoogle. Supported source types are: "base64", "url", "id", "text".`);
+	}
+};
+function convertStandardDataContentBlockToGeminiPart(block) {
+	function uint8arrayToString(data) {
+		return btoa(Array.from(data).map((byte) => String.fromCharCode(byte)).join(""));
+	}
+	function extractMimeType(str) {
+		if (str.startsWith("data:")) return {
+			mimeType: str.split(":")[1].split(";")[0],
+			data: str.split(",")[1]
+		};
+		return {
+			mimeType: null,
+			data: null
+		};
+	}
+	if ("mimeType" in block && "data" in block) {
+		const mimeType = block.mimeType;
+		const data = typeof block.data === "string" ? block.data : uint8arrayToString(block.data);
+		return { inlineData: {
+			mimeType,
+			data
+		} };
+	} else if ("mimeType" in block && "url" in block) {
+		const mimeType = block.mimeType;
+		const fileUri = block.url;
+		return { fileData: {
+			mimeType,
+			fileUri
+		} };
+	} else if ("url" in block && block.url?.startsWith("data:")) {
+		const { mimeType, data } = extractMimeType(block.url);
+		if (mimeType && data) return { inlineData: {
+			mimeType,
+			data
+		} };
+	}
+	return null;
+}
+function convertStandardVideoContentBlockToGeminiPart(block) {
+	const ret = convertStandardDataContentBlockToGeminiPart(block);
+	if (ret && block.metadata && "videoMetadata" in block.metadata) ret.videoMetadata = block.metadata.videoMetadata;
+	return ret;
+}
+/**
+* Converts a single LangChain standard content block (v1 format)
+* into a Gemini.Part.
+*
+* This is intended to be called from `convertStandardContentMessageToGeminiContent`
+*/
+function convertStandardContentBlockToGeminiPart(block) {
+	switch (block.type) {
+		case "text": return { text: block.text };
+		case "image":
+		case "audio": return convertStandardDataContentBlockToGeminiPart(block);
+		case "video": return convertStandardVideoContentBlockToGeminiPart(block);
+		default: return null;
+	}
+}
+/**
+* Converts a single LangChain message with standard content blocks (v1 format) to Gemini Content.
+* This handles messages that have `response_metadata.output_version === "v1"`.
+*
+* This is intended to be called from `convertMessagesToGeminiContent`
+*/
+function convertStandardContentMessageToGeminiContent(message) {
+	if (SystemMessage.isInstance(message)) return null;
+	let role;
+	if (HumanMessage.isInstance(message)) role = "user";
+	else if (AIMessage.isInstance(message)) role = "model";
+	else if (ToolMessage.isInstance(message)) role = "function";
+	else if (ChatMessage.isInstance(message)) {
+		const msgRole = message.role.toLowerCase();
+		if (msgRole === "user" || msgRole === "human") role = "user";
+		else if (msgRole === "assistant" || msgRole === "ai" || msgRole === "model") role = "model";
+		else if (msgRole === "function" || msgRole === "tool") role = "function";
+		else role = "user";
+	} else role = "user";
+	const parts = [];
+	message.contentBlocks.forEach((block) => {
+		const contentBlock = message.additional_kwargs.originalTextContentBlock || block;
+		const part = convertStandardContentBlockToGeminiPart(contentBlock);
+		if (part) parts.push(part);
+	});
+	if (ToolMessage.isInstance(message) && message.tool_call_id) {
+		const responseContent = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
+		parts.push({ functionResponse: {
+			name: message.name || "unknown",
+			response: { result: responseContent }
+		} });
+	}
+	if (parts.length === 0) return null;
+	return {
+		role,
+		parts
+	};
+}
+/**
+* Converts a single LangChain message with legacy content blocks (v0 format) to Gemini Content.
+* This handles messages that have `response_metadata.output_version === "v0"`.
+*
+* This is intended to be called from `convertMessagesToGeminiContent`
+*/
+function convertLegacyContentMessageToGeminiContent(message, messages) {
+	if (SystemMessage.isInstance(message)) return null;
+	/**
+	* @deprecated - This is for use by `convertLegacyContentMessageToGeminiContent` only
+	*/
+	function isMessageContentText(content) {
+		return typeof content === "object" && content !== null && "text" in content;
+	}
+	/**
+	* @deprecated - This is for use by `convertLegacyContentMessageToGeminiContent` only
+	*/
+	function isMessageContentImageUrl(content) {
+		return typeof content === "object" && content !== null && "image_url" in content;
+	}
+	/**
+	* @deprecated - This is for use by `convertLegacyContentMessageToGeminiContent` only
+	*/
+	function isMessageContentMedia(content) {
+		return typeof content === "object" && content !== null && "type" in content && content.type === "media";
+	}
+	/**
+	* Infers the MIME type from a URL based on its file extension.
+	* This is used as a fallback when the MIME type is not provided.
+	*
+	* @param url - The URL to infer the MIME type from
+	* @returns The inferred MIME type or a generic type if it cannot be determined
+	*/
+	function inferMimeTypeFromUrl(url) {
+		const mimeTypeMap = {
+			jpg: "image/jpeg",
+			jpeg: "image/jpeg",
+			png: "image/png",
+			gif: "image/gif",
+			webp: "image/webp",
+			bmp: "image/bmp",
+			svg: "image/svg+xml",
+			ico: "image/x-icon",
+			tiff: "image/tiff",
+			tif: "image/tiff"
+		};
+		try {
+			const pathname = new URL(url).pathname;
+			const extension = pathname.split(".").pop()?.toLowerCase().split(/[?#]/)[0];
+			return extension ? mimeTypeMap[extension] : "application/octet-stream";
+		} catch {
+			const match = url.match(/\.([a-zA-Z0-9]+)(?:[?#]|$)/);
+			if (match) {
+				const extension = match[1].toLowerCase();
+				return mimeTypeMap[extension];
+			}
+			return "application/octet-stream";
+		}
+	}
+	function messageContentImageUrlData(content) {
+		const url = typeof content.image_url === "string" ? content.image_url : content.image_url.url;
+		if (!url) throw new InvalidInputError("Missing image URL in image_url content block.");
+		const dataUrl = parseBase64DataUrl({ dataUrl: url });
+		if (dataUrl?.data && dataUrl?.mime_type) return { inlineData: {
+			data: dataUrl.data,
+			mimeType: dataUrl.mime_type
+		} };
+		else {
+			const mimeType = inferMimeTypeFromUrl(url) || "image/png";
+			return { fileData: {
+				mimeType,
+				fileUri: url
+			} };
+		}
+	}
+	function messageContentImageUrl(content) {
+		const ret = messageContentImageUrlData(content);
+		supplementVideoMetadata(content, ret);
+		return ret;
+	}
+	function messageContentMediaData(content) {
+		if ("mimeType" in content && "data" in content) return { inlineData: {
+			mimeType: content.mimeType,
+			data: content.data
+		} };
+		else if ("mimeType" in content && "fileUri" in content) return { fileData: {
+			mimeType: content.mimeType,
+			fileUri: content.fileUri
+		} };
+		throw new InvalidInputError(`Invalid media content: ${JSON.stringify(content, null, 1)}. Expected either { mimeType, data } for inline data or { mimeType, fileUri } for file references.`);
+	}
+	function supplementVideoMetadata(content, ret) {
+		if ("videoMetadata" in content && typeof ret === "object") ret.videoMetadata = content.videoMetadata;
+		return ret;
+	}
+	function messageContentMedia(content) {
+		const ret = messageContentMediaData(content);
+		supplementVideoMetadata(content, ret);
+		return ret;
+	}
+	const role = iife(() => {
+		if (HumanMessage.isInstance(message)) return "user";
+		else if (AIMessage.isInstance(message)) return "model";
+		else if (ToolMessage.isInstance(message)) return "function";
+		else if (ChatMessage.isInstance(message)) {
+			const msgRole = message.role.toLowerCase();
+			if (msgRole === "user" || msgRole === "human") return "user";
+			else if (msgRole === "assistant" || msgRole === "ai" || msgRole === "model") return "model";
+			else if (msgRole === "function" || msgRole === "tool") return "function";
+			else return "user";
+		} else return "user";
+	});
+	let parts = [];
+	if (typeof message.content === "string") {
+		if (message.content.trim()) parts.push({ text: message.content });
+	} else if (Array.isArray(message.content)) {
+		for (const item of message.content) if (typeof item === "string") parts.push({ text: item });
+		else if (typeof item === "object" && item !== null) if (isMessageContentText(item)) parts.push({ text: item.text });
+		else if (isDataContentBlock(item)) parts.push(convertToProviderContentBlock(item, geminiContentBlockConverter));
+		else if (item?.type === "functionCall") {
+			const { type, functionCall,...etc } = item;
+			parts.push({
+				...etc,
+				functionCall
+			});
+		} else if (isMessageContentImageUrl(item)) parts.push(messageContentImageUrl(item));
+		else if (isMessageContentMedia(item)) parts.push(messageContentMedia(item));
+		else parts.push(item);
+	}
+	if (ToolMessage.isInstance(message) && message.tool_call_id) {
+		const responseContent = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
+		const toolCall = messages.filter(AIMessage.isInstance).find((msg) => msg.tool_calls?.find((tc) => tc.id === message.tool_call_id));
+		if (!toolCall) throw new ToolCallNotFoundError(message.tool_call_id);
+		parts.push({ functionResponse: {
+			name: toolCall?.name || "unknown",
+			response: { result: responseContent }
+		} });
+	}
+	if (role === "function") parts = parts.filter((part) => "functionResponse" in part);
+	if (parts.length > 0) return {
+		role,
+		parts
+	};
+	return null;
+}
+/**
+* Converts an array of LangChain messages to Gemini API content format.
+*
+* This converter transforms LangChain's message types into the content structure
+* expected by Google's Gemini API.
+*
+* @remarks
+* The converter processes messages in two distinct ways based on their format:
+*
+* **V1 Standard Content Format**:
+* Messages with `output_version: "v1"` in their response metadata use the
+* standardized content block format. These are processed through
+* `convertStandardContentMessageToGeminiContent`, which extracts text blocks
+* from the `contentBlocks` array and maps message roles appropriately.
+*
+* **Google Format**:
+* Messages without the v1 marker are processed using generic logic that handles:
+* - String content: Simple text strings are converted to text parts
+* - Array content: Arrays of strings or content blocks are processed individually
+* - Tool messages: Converted to function response parts with tool call metadata
+*
+* @example
+* ```typescript
+* // Simple conversation with text messages
+* const messages = [
+*   new HumanMessage("What is the weather?"),
+*   new AIMessage("I'll check that for you.")
+* ];
+* const contents = convertMessagesToGeminiContents(messages);
+* // Returns: [
+* //   { role: "user", parts: [{ text: "What is the weather?" }] },
+* //   { role: "model", parts: [{ text: "I'll check that for you." }] }
+* // ]
+* ```
+*/
+const convertMessagesToGeminiContents = (messages) => {
+	const contents = [];
+	for (const message of messages) {
+		const content = iife(() => {
+			const outputVersion = "output_version" in message.response_metadata ? message.response_metadata?.output_version : "v0";
+			switch (outputVersion) {
+				case "v1": return convertStandardContentMessageToGeminiContent(message);
+				case "v0":
+				default: return convertLegacyContentMessageToGeminiContent(message, messages);
+			}
+		});
+		if (content) contents.push(content);
+	}
+	return contents;
+};
+/**
+* Converts LangChain system messages to Gemini API system instruction format.
+*
+* This converter extracts system messages from a message array and transforms them
+* into the format expected by Google's Gemini API for system instructions. System
+* instructions provide context and guidelines that influence the model's behavior
+* throughout the conversation.
+*
+* @remarks
+* The converter handles two distinct message formats:
+*
+* 1. **V1 Standard Content Format**: Messages with `output_version: "v1"` in their
+*    response metadata use the standardized content block format. Only text blocks
+*    are extracted from the `contentBlocks` array.
+*
+* 2. **Legacy Google Format**: Messages without the v1 marker use the legacy format
+*    where content can be:
+*    - A simple string (trimmed and converted to a text part)
+*    - An array of strings or objects with `type: "text"` and a `text` property
+*
+* The converter filters out non-SystemMessage instances and only processes text
+* content, ignoring other content types like images or tool calls that may be
+* present in the message array.
+*
+* @example
+* ```typescript
+* // Simple string system message
+* const messages = [
+*   new SystemMessage("You are a helpful assistant.")
+* ];
+* const instruction = convertMessagesToGeminiSystemInstruction(messages);
+* // Returns: { parts: [{ text: "You are a helpful assistant." }] }
+* ```
+*
+* @param messages - Array of LangChain messages to extract system instructions from
+* @returns A Gemini system instruction object with text parts, or undefined if no
+*          system messages with text content are found
+*/
+const convertMessagesToGeminiSystemInstruction = (messages) => {
+	const systemParts = [];
+	for (const message of messages) if (SystemMessage.isInstance(message)) {
+		if (message.text.trim()) systemParts.push({ text: message.text });
+	}
+	if (systemParts.length === 0) return void 0;
+	return { parts: systemParts };
+};
+/**
+* Converts an array of Gemini API parts into an array of LangChain tool calls.
+*
+* This function iterates through a given array of `Gemini.Part` objects,
+* identifies parts that represent a function call, and transforms them into
+* LangChain's standardized `ToolCall` format. Each resulting tool call is
+* assigned a unique, sequential ID.
+*
+* @param parts - An array of `Gemini.Part` objects, which may or may not
+*   contain function calls.
+* @returns An array of `ContentBlock.Tools.ToolCall` objects. If no function
+*   call parts are found, an empty array is returned.
+*
+* @remarks
+* The `id` for each tool call is generated sequentially in the format `call_0`,
+* `call_1`, and so on, based on its order of appearance in the input array.
+*
+* @example
+* ```typescript
+* const geminiParts: Gemini.Part[] = [
+*   { text: "Thinking about what to do..." },
+*   {
+*     functionCall: {
+*       name: "search_web",
+*       args: { query: "latest AI news" }
+*     }
+*   },
+*   {
+*     functionCall: {
+*       name: "calculator",
+*       args: { expression: "2 + 2" }
+*     }
+*   }
+* ];
+*
+* const toolCalls = convertGeminiPartsToToolCalls(geminiParts);
+* // toolCalls will be:
+* // [
+* //   { type: "tool_call", id: "call_0", name: "search_web", args: { query: "latest AI news" } },
+* //   { type: "tool_call", id: "call_1", name: "calculator", args: { expression: "2 + 2" } }
+* // ]
+* ```
+*/
+const convertGeminiPartsToToolCalls = (parts) => {
+	const toolCalls = [];
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i];
+		if ("functionCall" in part && part.functionCall) {
+			const functionCallPart = part;
+			toolCalls.push({
+				type: "tool_call",
+				id: `call_${toolCalls.length}`,
+				name: functionCallPart.functionCall.name,
+				args: functionCallPart.functionCall.args ?? {},
+				thoughtSignature: functionCallPart.thoughtSignature
+			});
+		}
+	}
+	return toolCalls;
+};
+const convertGeminiPartToContentBlock = (part) => {
+	const block = iife(() => {
+		if ("text" in part && typeof part.text === "string") return {
+			type: "text",
+			text: part.text
+		};
+		else if ("inlineData" in part && part.inlineData) return {
+			type: "inlineData",
+			inlineData: part.inlineData
+		};
+		else if ("fileData" in part && part.fileData) return {
+			type: "fileData",
+			fileData: part.fileData
+		};
+		else if ("functionCall" in part && part.functionCall) return {
+			type: "functionCall",
+			functionCall: part.functionCall
+		};
+		else if ("functionResponse" in part && part.functionResponse) return {
+			type: "functionResponse",
+			functionResponse: part.functionResponse
+		};
+		else if ("executableCode" in part && part.executableCode) return {
+			type: "executableCode",
+			executableCode: part.executableCode
+		};
+		else if ("codeExecutionResult" in part && part.codeExecutionResult) return {
+			type: "codeExecutionResult",
+			codeExecutionResult: part.codeExecutionResult
+		};
+		return part;
+	});
+	const ret = {
+		thought: part.thought,
+		thoughtSignature: part.thoughtSignature,
+		partMetadata: part.partMetadata,
+		...block
+	};
+	for (const attribute in ret) if (ret[attribute] === void 0) delete ret[attribute];
+	return ret;
+};
+/**
+* Converts a Gemini API candidate response to a LangChain AIMessage.
+*
+* This converter transforms the response from Google's Gemini API into a standardized
+* AIMessage format that can be used throughout the LangChain ecosystem. It handles
+* various types of content including text, inline data, file data, function calls,
+* and code execution results.
+*
+* @remarks
+* The converter performs the following transformations:
+* - Extracts tool calls from function call parts and assigns sequential IDs
+* - Converts single text responses to string format for simplicity
+* - Converts multi-part responses to ContentBlock array format
+* - Preserves metadata including finish reason, safety ratings, and citations
+* - Handles various Gemini part types (text, inlineData, fileData, functionCall, etc.)
+*
+* @example
+* ```typescript
+* const candidate: Gemini.Candidate = {
+*   content: {
+*     parts: [
+*       { text: "Hello, how can I help you?" }
+*     ]
+*   },
+*   finishReason: "STOP",
+*   safetyRatings: [...]
+* };
+*
+* const aiMessage = convertGeminiCandidateToAIMessage(candidate);
+* // Returns: AIMessage with content "Hello, how can I help you?"
+* ```
+*
+* @param candidate - The Gemini API candidate response containing content parts and metadata
+* @returns An AIMessage instance with converted content, tool calls, and metadata
+*/
+const convertGeminiCandidateToAIMessage = (candidate) => {
+	function groundingSupportByPart(groundingSupports) {
+		const ret = [];
+		if (!groundingSupports || groundingSupports.length === 0) return [[]];
+		groundingSupports?.forEach((groundingSupport) => {
+			const segment = groundingSupport?.segment;
+			const partIndex = segment?.partIndex ?? 0;
+			if (ret[partIndex]) ret[partIndex].push(groundingSupport);
+			else ret[partIndex] = [groundingSupport];
+		});
+		return ret;
+	}
+	const parts = candidate.content?.parts || [];
+	const toolCalls = convertGeminiPartsToToolCalls(parts);
+	let content;
+	let originalTextContentBlock = void 0;
+	const groundingMetadata = candidate?.groundingMetadata;
+	const citationMetadata = candidate?.citationMetadata;
+	const groundingParts = groundingSupportByPart(groundingMetadata?.groundingSupports);
+	const hasContentPayload = (p) => !!p.text || !!p.thought || !!p.inlineData || !!p.fileData || !!p.functionCall || !!p.functionResponse || !!p.executableCode || !!p.codeExecutionResult;
+	const contentParts = parts.filter(hasContentPayload);
+	if (contentParts.length === 0) {
+		content = "";
+		if (parts.length > 0) originalTextContentBlock = convertGeminiPartToContentBlock(parts[0]);
+	} else if (contentParts.length === 1 && "text" in contentParts[0] && !("thought" in contentParts[0])) {
+		content = contentParts[0].text ?? "";
+		const mergedPart = { ...contentParts[0] };
+		for (const p of parts) if (p !== contentParts[0] && p.thoughtSignature) mergedPart.thoughtSignature = p.thoughtSignature;
+		originalTextContentBlock = convertGeminiPartToContentBlock(mergedPart);
+	} else content = parts.map((p) => convertGeminiPartToContentBlock(p));
+	const additional_kwargs = {
+		finishReason: candidate.finishReason,
+		finishMessage: candidate.finishMessage,
+		safetyRatings: candidate.safetyRatings,
+		tokenCount: candidate.tokenCount,
+		citationMetadata: candidate.citationMetadata,
+		groundingMetadata: candidate.groundingMetadata,
+		groundingAttributions: candidate.groundingAttributions,
+		urlRetrievalMetadata: candidate.urlRetrievalMetadata,
+		urlContextMetadata: candidate.urlContextMetadata,
+		avgLogprobs: candidate.avgLogprobs,
+		logprobsResult: candidate.logprobsResult,
+		originalTextContentBlock
+	};
+	const response_metadata = {
+		model_provider: "google",
+		finish_reason: candidate.finishReason,
+		safety_ratings: candidate.safetyRatings,
+		citation_metadata: candidate.citationMetadata,
+		grounding_metadata: candidate.groundingMetadata,
+		grounding_attributions: candidate.groundingAttributions,
+		url_retrieval_metadata: candidate.urlRetrievalMetadata,
+		url_context_metadata: candidate.urlContextMetadata,
+		avg_logprobs: candidate.avgLogprobs,
+		logprobs_result: candidate.logprobsResult,
+		citationMetadata,
+		groundingMetadata,
+		groundingSupport: groundingParts[0]
+	};
+	for (const attribute in additional_kwargs) if (additional_kwargs[attribute] === void 0) delete additional_kwargs[attribute];
+	for (const attribute in response_metadata) if (response_metadata[attribute] === void 0) delete response_metadata[attribute];
+	return new AIMessage({
+		content,
+		tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
+		additional_kwargs,
+		response_metadata
+	});
+};
+const convertAIMessageToText = (message) => {
+	if (typeof message.content === "string") return message.content;
+	else if (Array.isArray(message.content)) return message.content.filter((c) => typeof c === "string" || c.type === "text").map((c) => typeof c === "string" ? c : c.text || "").join("");
+	else return "";
+};
+const convertGeminiGenerateContentResponseToUsageMetadata = (data) => {
+	function addModalityCounts(modalityTokenCounts, details) {
+		modalityTokenCounts?.forEach((modalityTokenCount) => {
+			const { modality, tokenCount } = modalityTokenCount;
+			if (typeof modality === "undefined" || typeof tokenCount === "undefined") return;
+			const modalityLc = modality.toLowerCase();
+			const currentCount = details[modalityLc] ?? 0;
+			details[modalityLc] = currentCount + tokenCount;
+		});
+	}
+	const usageMetadata = data.usageMetadata;
+	const inputTokenCount = usageMetadata?.promptTokenCount ?? 0;
+	const candidatesTokenCount = usageMetadata?.candidatesTokenCount ?? 0;
+	const thoughtsTokenCount = usageMetadata?.thoughtsTokenCount ?? 0;
+	const outputTokenCount = candidatesTokenCount + thoughtsTokenCount;
+	const totalTokens = usageMetadata?.totalTokenCount ?? inputTokenCount + outputTokenCount;
+	const input_token_details = {};
+	addModalityCounts(usageMetadata?.promptTokensDetails, input_token_details);
+	input_token_details.cache_read = usageMetadata?.cachedContentTokenCount ?? 0;
+	const output_token_details = {};
+	addModalityCounts(usageMetadata?.candidatesTokensDetails, output_token_details);
+	output_token_details.reasoning = usageMetadata?.thoughtsTokenCount ?? 0;
+	return {
+		input_tokens: inputTokenCount,
+		output_tokens: outputTokenCount,
+		total_tokens: totalTokens,
+		input_token_details,
+		output_token_details
+	};
+};
+
+//#endregion
+export { convertAIMessageToText, convertGeminiCandidateToAIMessage, convertGeminiGenerateContentResponseToUsageMetadata, convertGeminiPartsToToolCalls, convertMessagesToGeminiContents, convertMessagesToGeminiSystemInstruction };
+//# sourceMappingURL=messages.js.map