@intrvls/langchain-google-genai 3.0.0-alpha.0

package/dist/index.mjs

@@ -0,0 +1,1878 @@
+import { FunctionCallingConfigMode, GoogleGenAI } from "@google/genai";
+import { getEnvironmentVariable } from "@langchain/core/utils/env";
+import { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import { interopSafeParseAsync, isInteropZodSchema } from "@langchain/core/utils/types";
+import { toJsonSchema } from "@langchain/core/utils/json_schema";
+import { isSerializableSchema } from "@langchain/core/utils/standard_schema";
+import { AIMessage, AIMessageChunk, ChatMessage, convertToProviderContentBlock, isAIMessage, isBaseMessage, isDataContentBlock, isToolMessage, parseBase64DataUrl } from "@langchain/core/messages";
+import { ChatGenerationChunk } from "@langchain/core/outputs";
+import { isLangChainTool } from "@langchain/core/utils/function_calling";
+import { isOpenAITool } from "@langchain/core/language_models/base";
+import { v4 } from "uuid";
+import { BaseLLMOutputParser, OutputParserException } from "@langchain/core/output_parsers";
+import { assembleStructuredOutputPipeline, createContentParser, createFunctionCallingParser } from "@langchain/core/language_models/structured_output";
+import { Embeddings } from "@langchain/core/embeddings";
+import { chunkArray } from "@langchain/core/utils/chunk_array";
+//#region src/utils/zod_to_genai_parameters.ts
+function removeAdditionalProperties(obj) {
+	if (typeof obj === "object" && obj !== null) {
+		const newObj = { ...obj };
+		if ("additionalProperties" in newObj) delete newObj.additionalProperties;
+		if ("$schema" in newObj) delete newObj.$schema;
+		if ("strict" in newObj) delete newObj.strict;
+		for (const key in newObj) if (key in newObj) {
+			if (Array.isArray(newObj[key])) newObj[key] = newObj[key].map(removeAdditionalProperties);
+			else if (typeof newObj[key] === "object" && newObj[key] !== null) newObj[key] = removeAdditionalProperties(newObj[key]);
+		}
+		return newObj;
+	}
+	return obj;
+}
+function schemaToGenerativeAIParameters(schema) {
+	const { $schema, ...rest } = removeAdditionalProperties(isInteropZodSchema(schema) || isSerializableSchema(schema) ? toJsonSchema(schema) : schema);
+	return rest;
+}
+function jsonSchemaToGeminiParameters(schema) {
+	const { $schema, ...rest } = removeAdditionalProperties(schema);
+	return rest;
+}
+//#endregion
+//#region src/utils/validate_schema.ts
+function assertNoEmptyStringEnums(schema, toolName, path = []) {
+	if (schema == null || typeof schema !== "object") return;
+	const obj = schema;
+	if (Array.isArray(obj.enum)) {
+		if (obj.enum.some((v) => v === "")) {
+			const pathStr = path.length ? ` at path "${path.join(".")}"` : "";
+			const toolStr = toolName ? ` in tool "${toolName}"` : "";
+			throw new Error(`Invalid enum: empty string not allowed${toolStr}${pathStr}. Gemini API rejects empty strings in enums.`);
+		}
+	}
+	if (obj.type === "object" && obj.properties && typeof obj.properties === "object") for (const [prop, child] of Object.entries(obj.properties)) assertNoEmptyStringEnums(child, toolName, [...path, prop]);
+	if (obj.items) assertNoEmptyStringEnums(obj.items, toolName, [...path, "[]"]);
+	for (const k of [
+		"anyOf",
+		"oneOf",
+		"allOf"
+	]) {
+		const arr = obj[k];
+		if (Array.isArray(arr)) arr.forEach((child, i) => assertNoEmptyStringEnums(child, toolName, [...path, `${k}[${i}]`]));
+	}
+	if (obj.additionalProperties && typeof obj.additionalProperties === "object") assertNoEmptyStringEnums(obj.additionalProperties, toolName, [...path, "additionalProperties"]);
+}
+//#endregion
+//#region src/utils/common.ts
+const _FUNCTION_CALL_THOUGHT_SIGNATURES_MAP_KEY = "__gemini_function_call_thought_signatures__";
+const DUMMY_SIGNATURE = "ErYCCrMCAdHtim9kOoOkrPiCNVsmlpMIKd7ZMxgiFbVQOkgp7nlLcDMzVsZwIzvuT7nQROivoXA72ccC2lSDvR0Gh7dkWaGuj7ctv6t7ZceHnecx0QYa+ix8tYpRfjhyWozQ49lWiws6+YGjCt10KRTyWsZ2h6O7iHTYJwKIRwGUHRKy/qK/6kFxJm5ML00gLq4D8s5Z6DBpp2ZlR+uF4G8jJgeWQgyHWVdx2wGYElaceVAc66tZdPQRdOHpWtgYSI1YdaXgVI8KHY3/EfNc2YqqMIulvkDBAnuMhkAjV9xmBa54Tq+ih3Im4+r3DzqhGqYdsSkhS0kZMwte4Hjs65dZzCw9lANxIqYi1DJ639WNPYihp/DCJCos7o+/EeSPJaio5sgWDyUnMGkY1atsJZ+m7pj7DD5tvQ==";
+const iife = (fn) => fn();
+function getMessageAuthor(message) {
+	if (ChatMessage.isInstance(message)) return message.role;
+	return message.type;
+}
+/**
+* Maps a message type to a Google Generative AI chat author.
+* @param message The message to map.
+* @param model The model to use for mapping.
+* @returns The message type mapped to a Google Generative AI chat author.
+*/
+function convertAuthorToRole(author) {
+	switch (author) {
+		/**
+		*  Note: Gemini currently is not supporting system messages
+		*  we will convert them to human messages and merge with following
+		* */
+		case "supervisor":
+		case "ai":
+		case "model": return "model";
+		case "system": return "system";
+		case "human": return "user";
+		case "tool":
+		case "function": return "function";
+		default: throw new Error(`Unknown / unsupported author: ${author}`);
+	}
+}
+function messageContentMedia(content) {
+	if ("mimeType" in content && "data" in content) return { inlineData: {
+		mimeType: content.mimeType,
+		data: content.data
+	} };
+	if ("mimeType" in content && "fileUri" in content) return { fileData: {
+		mimeType: content.mimeType,
+		fileUri: content.fileUri
+	} };
+	throw new Error("Invalid media content");
+}
+function inferToolNameFromPreviousMessages(message, previousMessages) {
+	return previousMessages.map((msg) => {
+		if (isAIMessage(msg)) return msg.tool_calls ?? [];
+		return [];
+	}).flat().find((toolCall) => {
+		return toolCall.id === message.tool_call_id;
+	})?.name;
+}
+/**
+* Converts a ContentBlock.Multimodal block (image, video, audio, file)
+* to the appropriate Google Generative AI Part format.
+*
+* Handles three data record variants:
+*  - DataRecordBase64: has `data` property → InlineDataPart
+*  - DataRecordUrl: has `url` property → FileDataPart (or InlineDataPart for data: URLs)
+*  - DataRecordFileId: has `fileId` property → not directly supported, throws
+*/
+function _multimodalContentBlockToPart(block, defaultMimeType) {
+	if ("data" in block && block.data !== void 0) {
+		const data = block.data instanceof Uint8Array ? btoa(String.fromCharCode(...block.data)) : block.data;
+		return { inlineData: {
+			mimeType: block.mimeType || defaultMimeType,
+			data
+		} };
+	}
+	if ("url" in block && block.url !== void 0) {
+		const parsed = parseBase64DataUrl({ dataUrl: block.url });
+		if (parsed) return { inlineData: {
+			mimeType: parsed.mime_type,
+			data: parsed.data
+		} };
+		return { fileData: {
+			mimeType: block.mimeType || defaultMimeType,
+			fileUri: block.url
+		} };
+	}
+	if ("fileId" in block && block.fileId !== void 0) throw new Error("ContentBlock.Multimodal fileId is not supported by Google Generative AI. Use a URL or base64 data instead.");
+	throw new Error(`Invalid multimodal content block: must have "data", "url", or "fileId" property. Received: ${JSON.stringify(block)}`);
+}
+function _getStandardContentBlockConverter(isMultimodalModel) {
+	return {
+		providerName: "Google Gemini",
+		fromStandardTextBlock(block) {
+			return { text: block.text };
+		},
+		fromStandardImageBlock(block) {
+			if (!isMultimodalModel) throw new Error("This model does not support images");
+			if (block.source_type === "url") {
+				const data = parseBase64DataUrl({ dataUrl: block.url });
+				if (data) return { inlineData: {
+					mimeType: data.mime_type,
+					data: data.data
+				} };
+				else return { fileData: {
+					mimeType: block.mime_type ?? "",
+					fileUri: block.url
+				} };
+			}
+			if (block.source_type === "base64") return { inlineData: {
+				mimeType: block.mime_type ?? "",
+				data: block.data
+			} };
+			throw new Error(`Unsupported source type: ${block.source_type}`);
+		},
+		fromStandardAudioBlock(block) {
+			if (!isMultimodalModel) throw new Error("This model does not support audio");
+			if (block.source_type === "url") {
+				const data = parseBase64DataUrl({ dataUrl: block.url });
+				if (data) return { inlineData: {
+					mimeType: data.mime_type,
+					data: data.data
+				} };
+				else return { fileData: {
+					mimeType: block.mime_type ?? "",
+					fileUri: block.url
+				} };
+			}
+			if (block.source_type === "base64") return { inlineData: {
+				mimeType: block.mime_type ?? "",
+				data: block.data
+			} };
+			throw new Error(`Unsupported source type: ${block.source_type}`);
+		},
+		fromStandardFileBlock(block) {
+			if (!isMultimodalModel) throw new Error("This model does not support files");
+			if (block.source_type === "text") return { text: block.text };
+			if (block.source_type === "url") {
+				const data = parseBase64DataUrl({ dataUrl: block.url });
+				if (data) return { inlineData: {
+					mimeType: data.mime_type,
+					data: data.data
+				} };
+				else return { fileData: {
+					mimeType: block.mime_type ?? "",
+					fileUri: block.url
+				} };
+			}
+			if (block.source_type === "base64") return { inlineData: {
+				mimeType: block.mime_type ?? "",
+				data: block.data
+			} };
+			throw new Error(`Unsupported source type: ${block.source_type}`);
+		}
+	};
+}
+function _convertLangChainContentToPart(content, isMultimodalModel) {
+	if (isDataContentBlock(content)) return convertToProviderContentBlock(content, _getStandardContentBlockConverter(isMultimodalModel));
+	if (content.type === "text") return { text: content.text };
+	else if (content.type === "executableCode") return { executableCode: content.executableCode };
+	else if (content.type === "codeExecutionResult") return { codeExecutionResult: content.codeExecutionResult };
+	else if (content.type === "image_url") {
+		if (!isMultimodalModel) throw new Error(`This model does not support images`);
+		let source;
+		if (typeof content.image_url === "string") source = content.image_url;
+		else if (typeof content.image_url === "object" && "url" in content.image_url) source = content.image_url.url;
+		else throw new Error("Please provide image as base64 encoded data URL");
+		const [dm, data] = source.split(",");
+		if (!dm.startsWith("data:")) throw new Error("Please provide image as base64 encoded data URL");
+		const [mimeType, encoding] = dm.replace(/^data:/, "").split(";");
+		if (encoding !== "base64") throw new Error("Please provide image as base64 encoded data URL");
+		return { inlineData: {
+			data,
+			mimeType
+		} };
+	} else if (content.type === "media") return messageContentMedia(content);
+	else if (content.type === "image") return _multimodalContentBlockToPart(content, "image/png");
+	else if (content.type === "video") return _multimodalContentBlockToPart(content, "video/mp4");
+	else if (content.type === "audio") return _multimodalContentBlockToPart(content, "audio/mpeg");
+	else if (content.type === "file") return _multimodalContentBlockToPart(content, "application/octet-stream");
+	else if (content.type === "text-plain") {
+		if ("text" in content && typeof content.text === "string") return { text: content.text };
+		return _multimodalContentBlockToPart(content, "text/plain");
+	} else if (content.type === "tool_use") return { functionCall: {
+		name: content.name,
+		args: content.input
+	} };
+	else if (content.type === "tool_call") return { functionCall: {
+		name: content.name,
+		args: content.args
+	} };
+	else if (content.type?.includes("/") && content.type.split("/").length === 2 && "data" in content && typeof content.data === "string") return { inlineData: {
+		mimeType: content.type,
+		data: content.data
+	} };
+	else if (content.type === "thinking") {
+		const thinkingContent = content;
+		return {
+			text: thinkingContent.thinking,
+			thought: true,
+			...thinkingContent.signature ? { thoughtSignature: thinkingContent.signature } : {}
+		};
+	} else if ("functionCall" in content) return;
+	else if ("type" in content) throw new Error(`Unknown content type ${content.type}`);
+	else throw new Error(`Unknown content ${JSON.stringify(content)}`);
+}
+function convertMessageContentToParts(message, isMultimodalModel, previousMessages, model) {
+	if (isToolMessage(message)) {
+		const messageName = message.name ?? inferToolNameFromPreviousMessages(message, previousMessages);
+		if (messageName === void 0) throw new Error(`Google requires a tool name for each tool call response, and we could not infer a called tool name for ToolMessage "${message.id}" from your passed messages. Please populate a "name" field on that ToolMessage explicitly.`);
+		const result = Array.isArray(message.content) ? message.content.map((c) => _convertLangChainContentToPart(c, isMultimodalModel)).filter((p) => p !== void 0) : message.content;
+		if (message.status === "error") return [{ functionResponse: {
+			name: messageName,
+			response: { error: { details: result } }
+		} }];
+		return [{ functionResponse: {
+			name: messageName,
+			response: { result }
+		} }];
+	}
+	let functionCalls = [];
+	const messageParts = [];
+	if (typeof message.content === "string" && message.content) messageParts.push({ text: message.content });
+	if (Array.isArray(message.content)) messageParts.push(...message.content.map((c) => _convertLangChainContentToPart(c, isMultimodalModel)).filter((p) => p !== void 0));
+	const functionThoughtSignatures = message.additional_kwargs?.[_FUNCTION_CALL_THOUGHT_SIGNATURES_MAP_KEY];
+	if (isAIMessage(message) && message.tool_calls?.length) functionCalls = message.tool_calls.map((tc) => {
+		const thoughtSignature = iife(() => {
+			if (tc.id) {
+				const signature = functionThoughtSignatures?.[tc.id];
+				if (signature) return signature;
+			}
+			if (model?.includes("gemini-3")) return DUMMY_SIGNATURE;
+			return "";
+		});
+		return {
+			functionCall: {
+				name: tc.name,
+				args: tc.args
+			},
+			...thoughtSignature ? { thoughtSignature } : {}
+		};
+	});
+	return [...messageParts, ...functionCalls];
+}
+function convertBaseMessagesToContent(messages, isMultimodalModel, convertSystemMessageToHumanContent = false, model) {
+	return messages.reduce((acc, message, index) => {
+		if (!isBaseMessage(message)) throw new Error("Unsupported message input");
+		const author = getMessageAuthor(message);
+		if (author === "system" && index !== 0) throw new Error("System message should be the first one");
+		const role = convertAuthorToRole(author);
+		const prevContent = acc.content[acc.content.length];
+		if (!acc.mergeWithPreviousContent && prevContent && prevContent.role === role) throw new Error("Google Generative AI requires alternate messages between authors");
+		const parts = convertMessageContentToParts(message, isMultimodalModel, messages.slice(0, index), model);
+		if (acc.mergeWithPreviousContent) {
+			const prevContent = acc.content[acc.content.length - 1];
+			if (!prevContent) throw new Error("There was a problem parsing your system message. Please try a prompt without one.");
+			prevContent.parts = [...prevContent.parts ?? [], ...parts];
+			return {
+				mergeWithPreviousContent: false,
+				content: acc.content
+			};
+		}
+		let actualRole = role;
+		if (actualRole === "function" || actualRole === "system" && !convertSystemMessageToHumanContent) actualRole = "user";
+		const content = {
+			role: actualRole,
+			parts
+		};
+		return {
+			mergeWithPreviousContent: author === "system" && !convertSystemMessageToHumanContent,
+			content: [...acc.content, content]
+		};
+	}, {
+		content: [],
+		mergeWithPreviousContent: false
+	}).content;
+}
+function mapGenerateContentResultToChatResult(response, extra) {
+	if (!response.candidates || response.candidates.length === 0 || !response.candidates[0]) return {
+		generations: [],
+		llmOutput: { filters: response.promptFeedback }
+	};
+	const [candidate] = response.candidates;
+	const { content: candidateContent, ...generationInfo } = candidate;
+	const functionCalls = candidateContent?.parts?.reduce((acc, p) => {
+		if ("functionCall" in p && p.functionCall) acc.push({
+			...p,
+			id: "id" in p.functionCall && typeof p.functionCall.id === "string" ? p.functionCall.id : v4()
+		});
+		return acc;
+	}, []);
+	let content;
+	const parts = candidateContent?.parts;
+	if (Array.isArray(parts) && parts.length === 1 && "text" in parts[0] && parts[0].text && !parts[0].thought) content = parts[0].text;
+	else if (Array.isArray(parts) && parts.length > 0) content = parts.map((p) => {
+		if (p.thought && "text" in p && p.text) return {
+			type: "thinking",
+			thinking: p.text,
+			...p.thoughtSignature ? { signature: p.thoughtSignature } : {}
+		};
+		else if ("text" in p) return {
+			type: "text",
+			text: p.text
+		};
+		else if ("inlineData" in p) return {
+			type: "inlineData",
+			inlineData: p.inlineData
+		};
+		else if ("functionCall" in p) return {
+			type: "functionCall",
+			functionCall: p.functionCall
+		};
+		else if ("functionResponse" in p) return {
+			type: "functionResponse",
+			functionResponse: p.functionResponse
+		};
+		else if ("fileData" in p) return {
+			type: "fileData",
+			fileData: p.fileData
+		};
+		else if ("executableCode" in p) return {
+			type: "executableCode",
+			executableCode: p.executableCode
+		};
+		else if ("codeExecutionResult" in p) return {
+			type: "codeExecutionResult",
+			codeExecutionResult: p.codeExecutionResult
+		};
+		return p;
+	});
+	else content = [];
+	const functionThoughtSignatures = functionCalls?.reduce((acc, fc) => {
+		if ("thoughtSignature" in fc && typeof fc.thoughtSignature === "string") acc[fc.id] = fc.thoughtSignature;
+		return acc;
+	}, {});
+	let text = "";
+	if (typeof content === "string") text = content;
+	else if (Array.isArray(content) && content.length > 0) text = content.find((b) => "text" in b)?.text ?? text;
+	return {
+		generations: [{
+			text,
+			message: new AIMessage({
+				content: content ?? "",
+				tool_calls: functionCalls?.map((fc) => ({
+					type: "tool_call",
+					id: fc.id,
+					name: fc.functionCall?.name ?? "",
+					args: fc.functionCall?.args ?? {}
+				})),
+				additional_kwargs: {
+					...generationInfo,
+					[_FUNCTION_CALL_THOUGHT_SIGNATURES_MAP_KEY]: functionThoughtSignatures
+				},
+				response_metadata: { model_provider: "google-genai" },
+				usage_metadata: extra?.usageMetadata
+			}),
+			generationInfo
+		}],
+		llmOutput: { tokenUsage: {
+			promptTokens: extra?.usageMetadata?.input_tokens,
+			completionTokens: extra?.usageMetadata?.output_tokens,
+			totalTokens: extra?.usageMetadata?.total_tokens
+		} }
+	};
+}
+function convertResponseContentToChatGenerationChunk(response, extra) {
+	if (!response.candidates || response.candidates.length === 0) return null;
+	const [candidate] = response.candidates;
+	const { content: candidateContent, ...generationInfo } = candidate;
+	const functionCalls = candidateContent?.parts?.reduce((acc, p) => {
+		if ("functionCall" in p && p.functionCall) acc.push({
+			...p,
+			id: "id" in p.functionCall && typeof p.functionCall.id === "string" ? p.functionCall.id : v4()
+		});
+		return acc;
+	}, []);
+	let content;
+	const streamParts = candidateContent?.parts;
+	if (Array.isArray(streamParts) && streamParts.every((p) => "text" in p && !p.thought)) content = streamParts.map((p) => p.text).join("");
+	else if (Array.isArray(streamParts)) content = streamParts.map((p) => {
+		if (p.thought && "text" in p && p.text) return {
+			type: "thinking",
+			thinking: p.text,
+			...p.thoughtSignature ? { signature: p.thoughtSignature } : {}
+		};
+		else if ("text" in p) return {
+			type: "text",
+			text: p.text
+		};
+		else if ("inlineData" in p) return {
+			type: "inlineData",
+			inlineData: p.inlineData
+		};
+		else if ("functionCall" in p) return {
+			type: "functionCall",
+			functionCall: p.functionCall
+		};
+		else if ("functionResponse" in p) return {
+			type: "functionResponse",
+			functionResponse: p.functionResponse
+		};
+		else if ("fileData" in p) return {
+			type: "fileData",
+			fileData: p.fileData
+		};
+		else if ("executableCode" in p) return {
+			type: "executableCode",
+			executableCode: p.executableCode
+		};
+		else if ("codeExecutionResult" in p) return {
+			type: "codeExecutionResult",
+			codeExecutionResult: p.codeExecutionResult
+		};
+		return p;
+	});
+	else content = [];
+	let text = "";
+	if (content && typeof content === "string") text = content;
+	else if (Array.isArray(content)) text = content.find((b) => "text" in b)?.text ?? "";
+	const toolCallChunks = [];
+	if (functionCalls) toolCallChunks.push(...functionCalls.map((fc) => ({
+		type: "tool_call_chunk",
+		id: fc.id,
+		name: fc.functionCall?.name,
+		args: JSON.stringify(fc.functionCall?.args)
+	})));
+	const functionThoughtSignatures = functionCalls?.reduce((acc, fc) => {
+		if ("thoughtSignature" in fc && typeof fc.thoughtSignature === "string") acc[fc.id] = fc.thoughtSignature;
+		return acc;
+	}, {});
+	return new ChatGenerationChunk({
+		text,
+		message: new AIMessageChunk({
+			content: content || "",
+			name: !candidateContent ? void 0 : candidateContent.role,
+			tool_call_chunks: toolCallChunks,
+			additional_kwargs: { [_FUNCTION_CALL_THOUGHT_SIGNATURES_MAP_KEY]: functionThoughtSignatures },
+			response_metadata: { model_provider: "google-genai" },
+			usage_metadata: extra.usageMetadata
+		}),
+		generationInfo
+	});
+}
+function convertToGenerativeAITools(tools) {
+	if (tools.every((tool) => "functionDeclarations" in tool && Array.isArray(tool.functionDeclarations))) return tools;
+	return [{ functionDeclarations: tools.map((tool) => {
+		if (isLangChainTool(tool)) {
+			const jsonSchema = schemaToGenerativeAIParameters(tool.schema);
+			if (jsonSchema.type === "object" && Object.keys(jsonSchema.properties ?? {}).length === 0) return {
+				name: tool.name,
+				description: tool.description
+			};
+			assertNoEmptyStringEnums(jsonSchema, tool.name);
+			return {
+				name: tool.name,
+				description: tool.description,
+				parameters: jsonSchema
+			};
+		}
+		if (isOpenAITool(tool)) {
+			const params = jsonSchemaToGeminiParameters(tool.function.parameters);
+			assertNoEmptyStringEnums(params, tool.function.name);
+			return {
+				name: tool.function.name,
+				description: tool.function.description ?? `A function available to call.`,
+				parameters: params
+			};
+		}
+		return tool;
+	}) }];
+}
+function convertUsageMetadata(usageMetadata, model) {
+	const reasoningTokens = usageMetadata?.thoughtsTokenCount ?? 0;
+	const output = {
+		input_tokens: usageMetadata?.promptTokenCount ?? 0,
+		output_tokens: (usageMetadata?.candidatesTokenCount ?? 0) + reasoningTokens,
+		total_tokens: usageMetadata?.totalTokenCount ?? 0
+	};
+	if (reasoningTokens) output.output_token_details = {
+		...output.output_token_details,
+		reasoning: reasoningTokens
+	};
+	if (usageMetadata?.cachedContentTokenCount) {
+		output.input_token_details ??= {};
+		output.input_token_details.cache_read = usageMetadata.cachedContentTokenCount;
+	}
+	if (model.startsWith("gemini-3") && model.includes("pro")) {
+		const over200k = Math.max(0, (usageMetadata?.promptTokenCount ?? 0) - 2e5);
+		const cachedOver200k = Math.max(0, (usageMetadata?.cachedContentTokenCount ?? 0) - 2e5);
+		if (over200k) output.input_token_details = {
+			...output.input_token_details,
+			over_200k: over200k
+		};
+		if (cachedOver200k) output.input_token_details = {
+			...output.input_token_details,
+			cache_read_over_200k: cachedOver200k
+		};
+	}
+	return output;
+}
+//#endregion
+//#region src/output_parsers.ts
+var GoogleGenerativeAIToolsOutputParser = class extends BaseLLMOutputParser {
+	static lc_name() {
+		return "GoogleGenerativeAIToolsOutputParser";
+	}
+	lc_namespace = [
+		"langchain",
+		"google_genai",
+		"output_parsers"
+	];
+	returnId = false;
+	/** The type of tool calls to return. */
+	keyName;
+	/** Whether to return only the first tool call. */
+	returnSingle = false;
+	zodSchema;
+	serializableSchema;
+	constructor(params) {
+		super(params);
+		this.keyName = params.keyName;
+		this.returnSingle = params.returnSingle ?? this.returnSingle;
+		this.zodSchema = params.zodSchema;
+		this.serializableSchema = params.serializableSchema;
+	}
+	async _validateResult(result) {
+		if (this.serializableSchema !== void 0) {
+			const validated = await this.serializableSchema["~standard"].validate(result);
+			if (validated.issues) throw new OutputParserException(`Failed to parse. Text: "${JSON.stringify(result, null, 2)}". Error: ${JSON.stringify(validated.issues)}`, JSON.stringify(result, null, 2));
+			return validated.value;
+		}
+		if (this.zodSchema === void 0) return result;
+		const zodParsedResult = await interopSafeParseAsync(this.zodSchema, result);
+		if (zodParsedResult.success) return zodParsedResult.data;
+		else throw new OutputParserException(`Failed to parse. Text: "${JSON.stringify(result, null, 2)}". Error: ${JSON.stringify(zodParsedResult.error.issues)}`, JSON.stringify(result, null, 2));
+	}
+	async parseResult(generations) {
+		const tools = generations.flatMap((generation) => {
+			const { message } = generation;
+			if (!("tool_calls" in message) || !Array.isArray(message.tool_calls)) return [];
+			return message.tool_calls;
+		});
+		if (tools[0] === void 0) throw new Error("No parseable tool calls provided to GoogleGenerativeAIToolsOutputParser.");
+		const [tool] = tools;
+		return await this._validateResult(tool.args);
+	}
+};
+//#endregion
+//#region src/utils/tools.ts
+function convertToolsToGenAI(tools, extra) {
+	const genAITools = processTools(tools);
+	return {
+		tools: genAITools,
+		toolConfig: createToolConfig(genAITools, extra)
+	};
+}
+function processTools(tools) {
+	let functionDeclarationTools = [];
+	const genAITools = [];
+	tools.forEach((tool) => {
+		if (isLangChainTool(tool)) {
+			const [convertedTool] = convertToGenerativeAITools([tool]);
+			if (convertedTool.functionDeclarations) functionDeclarationTools.push(...convertedTool.functionDeclarations);
+		} else if (isOpenAITool(tool)) {
+			const { functionDeclarations } = convertOpenAIToolToGenAI(tool);
+			if (functionDeclarations) functionDeclarationTools.push(...functionDeclarations);
+			else throw new Error("Failed to convert OpenAI structured tool to GenerativeAI tool");
+		} else genAITools.push(normalizeGenAITool(tool));
+	});
+	if (genAITools.find((t) => "functionDeclarations" in t)) return genAITools.map((tool) => {
+		if (functionDeclarationTools?.length > 0 && "functionDeclarations" in tool) {
+			const newTool = { functionDeclarations: [...tool.functionDeclarations || [], ...functionDeclarationTools] };
+			functionDeclarationTools = [];
+			return newTool;
+		}
+		return tool;
+	});
+	return [...genAITools, ...functionDeclarationTools.length > 0 ? [{ functionDeclarations: functionDeclarationTools }] : []];
+}
+/**
+* Current Gemini models (2.x and newer) removed the legacy
+* `googleSearchRetrieval` tool (with its `dynamicRetrievalConfig`) and reject
+* it with `google_search_retrieval is not supported. Please use google_search
+* tool instead.`. Transparently rewrite it to the `googleSearch` tool so
+* existing code keeps working against the newest models.
+*/
+function normalizeGenAITool(tool) {
+	if (tool && "googleSearchRetrieval" in tool && !("googleSearch" in tool)) {
+		const { googleSearchRetrieval, ...rest } = tool;
+		return {
+			...rest,
+			googleSearch: {}
+		};
+	}
+	return tool;
+}
+function convertOpenAIToolToGenAI(tool) {
+	return { functionDeclarations: [{
+		name: tool.function.name,
+		description: tool.function.description,
+		parameters: removeAdditionalProperties(tool.function.parameters)
+	}] };
+}
+function createToolConfig(genAITools, extra) {
+	if (!genAITools.length || !extra) return void 0;
+	const { toolChoice, allowedFunctionNames } = extra;
+	const modeMap = {
+		any: FunctionCallingConfigMode.ANY,
+		auto: FunctionCallingConfigMode.AUTO,
+		none: FunctionCallingConfigMode.NONE
+	};
+	if (toolChoice && [
+		"any",
+		"auto",
+		"none"
+	].includes(toolChoice)) return { functionCallingConfig: {
+		mode: modeMap[toolChoice] ?? FunctionCallingConfigMode.MODE_UNSPECIFIED,
+		allowedFunctionNames
+	} };
+	if (typeof toolChoice === "string" || allowedFunctionNames) return { functionCallingConfig: {
+		mode: FunctionCallingConfigMode.ANY,
+		allowedFunctionNames: [...allowedFunctionNames ?? [], ...toolChoice && typeof toolChoice === "string" ? [toolChoice] : []]
+	} };
+}
+//#endregion
+//#region src/profiles.ts
+const PROFILES = {
+	"gemini-embedding-001": {
+		maxInputTokens: 2048,
+		imageInputs: false,
+		audioInputs: false,
+		pdfInputs: false,
+		videoInputs: false,
+		maxOutputTokens: 3072,
+		reasoningOutput: false,
+		imageOutputs: false,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: false,
+		structuredOutput: false
+	},
+	"gemini-2.5-flash-lite-preview-09-2025": {
+		maxInputTokens: 1048576,
+		imageInputs: true,
+		audioInputs: true,
+		pdfInputs: true,
+		videoInputs: true,
+		maxOutputTokens: 65536,
+		reasoningOutput: true,
+		imageOutputs: false,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: true
+	},
+	"gemini-2.5-pro-preview-06-05": {
+		maxInputTokens: 1048576,
+		imageInputs: true,
+		audioInputs: true,
+		pdfInputs: true,
+		videoInputs: true,
+		maxOutputTokens: 65536,
+		reasoningOutput: true,
+		imageOutputs: false,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: true
+	},
+	"gemini-2.5-flash-preview-04-17": {
+		maxInputTokens: 1048576,
+		imageInputs: true,
+		audioInputs: true,
+		pdfInputs: true,
+		videoInputs: true,
+		maxOutputTokens: 65536,
+		reasoningOutput: true,
+		imageOutputs: false,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: false
+	},
+	"gemini-2.5-flash-preview-09-2025": {
+		maxInputTokens: 1048576,
+		imageInputs: true,
+		audioInputs: true,
+		pdfInputs: true,
+		videoInputs: true,
+		maxOutputTokens: 65536,
+		reasoningOutput: true,
+		imageOutputs: false,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: true
+	},
+	"gemini-2.5-pro-preview-05-06": {
+		maxInputTokens: 1048576,
+		imageInputs: true,
+		audioInputs: true,
+		pdfInputs: true,
+		videoInputs: true,
+		maxOutputTokens: 65536,
+		reasoningOutput: true,
+		imageOutputs: false,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: true
+	},
+	"gemini-2.5-flash-preview-05-20": {
+		maxInputTokens: 1048576,
+		imageInputs: true,
+		audioInputs: true,
+		pdfInputs: true,
+		videoInputs: true,
+		maxOutputTokens: 65536,
+		reasoningOutput: true,
+		imageOutputs: false,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: true
+	},
+	"gemini-2.5-flash": {
+		maxInputTokens: 1048576,
+		imageInputs: true,
+		audioInputs: true,
+		pdfInputs: true,
+		videoInputs: true,
+		maxOutputTokens: 65536,
+		reasoningOutput: true,
+		imageOutputs: false,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: true
+	},
+	"gemini-live-2.5-flash": {
+		maxInputTokens: 128e3,
+		imageInputs: true,
+		audioInputs: true,
+		pdfInputs: false,
+		videoInputs: true,
+		maxOutputTokens: 8e3,
+		reasoningOutput: true,
+		imageOutputs: false,
+		audioOutputs: true,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: false
+	},
+	"gemini-3-flash-preview": {
+		maxInputTokens: 1048576,
+		imageInputs: true,
+		audioInputs: true,
+		pdfInputs: true,
+		videoInputs: true,
+		maxOutputTokens: 65536,
+		reasoningOutput: true,
+		imageOutputs: false,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: true
+	},
+	"gemini-3.5-flash": {
+		maxInputTokens: 1048576,
+		imageInputs: true,
+		audioInputs: true,
+		pdfInputs: true,
+		videoInputs: true,
+		maxOutputTokens: 65536,
+		reasoningOutput: true,
+		imageOutputs: false,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: true
+	},
+	"gemini-3.1-pro-preview": {
+		maxInputTokens: 1048576,
+		imageInputs: true,
+		audioInputs: true,
+		pdfInputs: true,
+		videoInputs: true,
+		maxOutputTokens: 65536,
+		reasoningOutput: true,
+		imageOutputs: false,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: true
+	},
+	"gemini-3.1-flash-lite": {
+		maxInputTokens: 1048576,
+		imageInputs: true,
+		audioInputs: true,
+		pdfInputs: true,
+		videoInputs: true,
+		maxOutputTokens: 65536,
+		reasoningOutput: true,
+		imageOutputs: false,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: true
+	},
+	"gemini-3.1-flash-lite-preview": {
+		maxInputTokens: 1048576,
+		imageInputs: true,
+		audioInputs: true,
+		pdfInputs: true,
+		videoInputs: true,
+		maxOutputTokens: 65536,
+		reasoningOutput: true,
+		imageOutputs: false,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: true
+	},
+	"gemini-pro-latest": {
+		maxInputTokens: 1048576,
+		imageInputs: true,
+		audioInputs: true,
+		pdfInputs: true,
+		videoInputs: true,
+		maxOutputTokens: 65536,
+		reasoningOutput: true,
+		imageOutputs: false,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: true
+	},
+	"gemini-live-2.5-flash-preview-native-audio": {
+		maxInputTokens: 131072,
+		imageInputs: false,
+		audioInputs: true,
+		pdfInputs: false,
+		videoInputs: true,
+		maxOutputTokens: 65536,
+		reasoningOutput: true,
+		imageOutputs: false,
+		audioOutputs: true,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: false
+	},
+	"gemini-2.5-flash-lite": {
+		maxInputTokens: 1048576,
+		imageInputs: true,
+		audioInputs: true,
+		pdfInputs: true,
+		videoInputs: true,
+		maxOutputTokens: 65536,
+		reasoningOutput: true,
+		imageOutputs: false,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: true
+	},
+	"gemini-2.5-flash-preview-tts": {
+		maxInputTokens: 8e3,
+		imageInputs: false,
+		audioInputs: false,
+		pdfInputs: false,
+		videoInputs: false,
+		maxOutputTokens: 16e3,
+		reasoningOutput: false,
+		imageOutputs: false,
+		audioOutputs: true,
+		videoOutputs: false,
+		toolCalling: false,
+		structuredOutput: false
+	},
+	"gemini-flash-latest": {
+		maxInputTokens: 1048576,
+		imageInputs: true,
+		audioInputs: true,
+		pdfInputs: true,
+		videoInputs: true,
+		maxOutputTokens: 65536,
+		reasoningOutput: true,
+		imageOutputs: false,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: true
+	},
+	"gemini-2.5-flash-lite-preview-06-17": {
+		maxInputTokens: 1048576,
+		imageInputs: true,
+		audioInputs: true,
+		pdfInputs: true,
+		videoInputs: true,
+		maxOutputTokens: 65536,
+		reasoningOutput: true,
+		imageOutputs: false,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: false
+	},
+	"gemini-2.5-flash-image": {
+		maxInputTokens: 32768,
+		imageInputs: true,
+		audioInputs: false,
+		pdfInputs: false,
+		videoInputs: false,
+		maxOutputTokens: 32768,
+		reasoningOutput: true,
+		imageOutputs: true,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: false,
+		structuredOutput: false
+	},
+	"gemini-2.5-pro-preview-tts": {
+		maxInputTokens: 8e3,
+		imageInputs: false,
+		audioInputs: false,
+		pdfInputs: false,
+		videoInputs: false,
+		maxOutputTokens: 16e3,
+		reasoningOutput: false,
+		imageOutputs: false,
+		audioOutputs: true,
+		videoOutputs: false,
+		toolCalling: false,
+		structuredOutput: false
+	},
+	"gemini-2.5-flash-image-preview": {
+		maxInputTokens: 32768,
+		imageInputs: true,
+		audioInputs: false,
+		pdfInputs: false,
+		videoInputs: false,
+		maxOutputTokens: 32768,
+		reasoningOutput: true,
+		imageOutputs: true,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: false,
+		structuredOutput: false
+	},
+	"gemini-1.5-flash-8b": {
+		maxInputTokens: 1e6,
+		imageInputs: true,
+		audioInputs: true,
+		pdfInputs: false,
+		videoInputs: true,
+		maxOutputTokens: 8192,
+		reasoningOutput: false,
+		imageOutputs: false,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: false
+	},
+	"gemini-3-pro-preview": {
+		maxInputTokens: 1e6,
+		imageInputs: true,
+		audioInputs: true,
+		pdfInputs: true,
+		videoInputs: true,
+		maxOutputTokens: 64e3,
+		reasoningOutput: true,
+		imageOutputs: false,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: true
+	},
+	"gemini-2.0-flash-lite": {
+		maxInputTokens: 1048576,
+		imageInputs: true,
+		audioInputs: true,
+		pdfInputs: true,
+		videoInputs: true,
+		maxOutputTokens: 8192,
+		reasoningOutput: false,
+		imageOutputs: false,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: true
+	},
+	"gemini-1.5-flash": {
+		maxInputTokens: 1e6,
+		imageInputs: true,
+		audioInputs: true,
+		pdfInputs: false,
+		videoInputs: true,
+		maxOutputTokens: 8192,
+		reasoningOutput: false,
+		imageOutputs: false,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: false
+	},
+	"gemini-flash-lite-latest": {
+		maxInputTokens: 1048576,
+		imageInputs: true,
+		audioInputs: true,
+		pdfInputs: true,
+		videoInputs: true,
+		maxOutputTokens: 65536,
+		reasoningOutput: true,
+		imageOutputs: false,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: true
+	},
+	"gemini-2.5-pro": {
+		maxInputTokens: 1048576,
+		imageInputs: true,
+		audioInputs: true,
+		pdfInputs: true,
+		videoInputs: true,
+		maxOutputTokens: 65536,
+		reasoningOutput: true,
+		imageOutputs: false,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: true
+	},
+	"gemini-2.0-flash": {
+		maxInputTokens: 1048576,
+		imageInputs: true,
+		audioInputs: true,
+		pdfInputs: true,
+		videoInputs: true,
+		maxOutputTokens: 8192,
+		reasoningOutput: false,
+		imageOutputs: false,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: true
+	},
+	"gemini-1.5-pro": {
+		maxInputTokens: 1e6,
+		imageInputs: true,
+		audioInputs: true,
+		pdfInputs: false,
+		videoInputs: true,
+		maxOutputTokens: 8192,
+		reasoningOutput: false,
+		imageOutputs: false,
+		audioOutputs: false,
+		videoOutputs: false,
+		toolCalling: true,
+		structuredOutput: false
+	}
+};
+//#endregion
+//#region src/chat_models.ts
+/**
+* Google Generative AI chat model integration.
+*
+* Setup:
+* Install `@intrvls/langchain-google-genai` and set an environment variable named `GOOGLE_API_KEY`.
+*
+* ```bash
+* npm install @intrvls/langchain-google-genai
+* export GOOGLE_API_KEY="your-api-key"
+* ```
+*
+* ## [Constructor args](https://api.js.langchain.com/classes/langchain_google_genai.ChatGoogleGenerativeAI.html#constructor)
+*
+* ## [Runtime args](https://api.js.langchain.com/interfaces/langchain_google_genai.GoogleGenerativeAIChatCallOptions.html)
+*
+* Runtime args can be passed as the second argument to any of the base runnable methods `.invoke`. `.stream`, `.batch`, etc.
+* They can also be passed via `.withConfig`, or the second arg in `.bindTools`, like shown in the examples below:
+*
+* ```typescript
+* // When calling `.withConfig`, call options should be passed via the first argument
+* const llmWithArgsBound = llm.withConfig({
+*   stop: ["\n"],
+* });
+*
+* // When calling `.bindTools`, call options should be passed via the second argument
+* const llmWithTools = llm.bindTools(
+*   [...],
+*   {
+*     stop: ["\n"],
+*   }
+* );
+* ```
+*
+* ## Examples
+*
+* <details open>
+* <summary><strong>Instantiate</strong></summary>
+*
+* ```typescript
+* import { ChatGoogleGenerativeAI } from '@intrvls/langchain-google-genai';
+*
+* const llm = new ChatGoogleGenerativeAI({
+*   model: "gemini-3.5-flash",
+*   temperature: 0,
+*   maxRetries: 2,
+*   // apiKey: "...",
+*   // other params...
+* });
+* ```
+* </details>
+*
+* <br />
+*
+* <details>
+* <summary><strong>Invoking</strong></summary>
+*
+* ```typescript
+* const input = `Translate "I love programming" into French.`;
+*
+* // Models also accept a list of chat messages or a formatted prompt
+* const result = await llm.invoke(input);
+* console.log(result);
+* ```
+*
+* ```txt
+* AIMessage {
+*   "content": "There are a few ways to translate \"I love programming\" into French, depending on the level of formality and nuance you want to convey:\n\n**Formal:**\n\n* **J'aime la programmation.** (This is the most literal and formal translation.)\n\n**Informal:**\n\n* **J'adore programmer.** (This is a more enthusiastic and informal translation.)\n* **J'aime beaucoup programmer.** (This is a slightly less enthusiastic but still informal translation.)\n\n**More specific:**\n\n* **J'aime beaucoup coder.** (This specifically refers to writing code.)\n* **J'aime beaucoup développer des logiciels.** (This specifically refers to developing software.)\n\nThe best translation will depend on the context and your intended audience. \n",
+*   "response_metadata": {
+*     "finishReason": "STOP",
+*     "index": 0,
+*     "safetyRatings": [
+*       {
+*         "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+*         "probability": "NEGLIGIBLE"
+*       },
+*       {
+*         "category": "HARM_CATEGORY_HATE_SPEECH",
+*         "probability": "NEGLIGIBLE"
+*       },
+*       {
+*         "category": "HARM_CATEGORY_HARASSMENT",
+*         "probability": "NEGLIGIBLE"
+*       },
+*       {
+*         "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+*         "probability": "NEGLIGIBLE"
+*       }
+*     ]
+*   },
+*   "usage_metadata": {
+*     "input_tokens": 10,
+*     "output_tokens": 149,
+*     "total_tokens": 159
+*   }
+* }
+* ```
+* </details>
+*
+* <br />
+*
+* <details>
+* <summary><strong>Streaming Chunks</strong></summary>
+*
+* ```typescript
+* for await (const chunk of await llm.stream(input)) {
+*   console.log(chunk);
+* }
+* ```
+*
+* ```txt
+* AIMessageChunk {
+*   "content": "There",
+*   "response_metadata": {
+*     "index": 0
+*   }
+*   "usage_metadata": {
+*     "input_tokens": 10,
+*     "output_tokens": 1,
+*     "total_tokens": 11
+*   }
+* }
+* AIMessageChunk {
+*   "content": " are a few ways to translate \"I love programming\" into French, depending on",
+* }
+* AIMessageChunk {
+*   "content": " the level of formality and nuance you want to convey:\n\n**Formal:**\n\n",
+* }
+* AIMessageChunk {
+*   "content": "* **J'aime la programmation.** (This is the most literal and formal translation.)\n\n**Informal:**\n\n* **J'adore programmer.** (This",
+* }
+* AIMessageChunk {
+*   "content": " is a more enthusiastic and informal translation.)\n* **J'aime beaucoup programmer.** (This is a slightly less enthusiastic but still informal translation.)\n\n**More",
+* }
+* AIMessageChunk {
+*   "content": " specific:**\n\n* **J'aime beaucoup coder.** (This specifically refers to writing code.)\n* **J'aime beaucoup développer des logiciels.** (This specifically refers to developing software.)\n\nThe best translation will depend on the context and",
+* }
+* AIMessageChunk {
+*   "content": " your intended audience. \n",
+* }
+* ```
+* </details>
+*
+* <br />
+*
+* <details>
+* <summary><strong>Aggregate Streamed Chunks</strong></summary>
+*
+* ```typescript
+* import { AIMessageChunk } from '@langchain/core/messages';
+* import { concat } from '@langchain/core/utils/stream';
+*
+* const stream = await llm.stream(input);
+* let full: AIMessageChunk | undefined;
+* for await (const chunk of stream) {
+*   full = !full ? chunk : concat(full, chunk);
+* }
+* console.log(full);
+* ```
+*
+* ```txt
+* AIMessageChunk {
+*   "content": "There are a few ways to translate \"I love programming\" into French, depending on the level of formality and nuance you want to convey:\n\n**Formal:**\n\n* **J'aime la programmation.** (This is the most literal and formal translation.)\n\n**Informal:**\n\n* **J'adore programmer.** (This is a more enthusiastic and informal translation.)\n* **J'aime beaucoup programmer.** (This is a slightly less enthusiastic but still informal translation.)\n\n**More specific:**\n\n* **J'aime beaucoup coder.** (This specifically refers to writing code.)\n* **J'aime beaucoup développer des logiciels.** (This specifically refers to developing software.)\n\nThe best translation will depend on the context and your intended audience. \n",
+*   "usage_metadata": {
+*     "input_tokens": 10,
+*     "output_tokens": 277,
+*     "total_tokens": 287
+*   }
+* }
+* ```
+* </details>
+*
+* <br />
+*
+* <details>
+* <summary><strong>Bind tools</strong></summary>
+*
+* ```typescript
+* import { z } from 'zod';
+*
+* const GetWeather = {
+*   name: "GetWeather",
+*   description: "Get the current weather in a given location",
+*   schema: z.object({
+*     location: z.string().describe("The city and state, e.g. San Francisco, CA")
+*   }),
+* }
+*
+* const GetPopulation = {
+*   name: "GetPopulation",
+*   description: "Get the current population in a given location",
+*   schema: z.object({
+*     location: z.string().describe("The city and state, e.g. San Francisco, CA")
+*   }),
+* }
+*
+* const llmWithTools = llm.bindTools([GetWeather, GetPopulation]);
+* const aiMsg = await llmWithTools.invoke(
+*   "Which city is hotter today and which is bigger: LA or NY?"
+* );
+* console.log(aiMsg.tool_calls);
+* ```
+*
+* ```txt
+* [
+*   {
+*     name: 'GetWeather',
+*     args: { location: 'Los Angeles, CA' },
+*     type: 'tool_call'
+*   },
+*   {
+*     name: 'GetWeather',
+*     args: { location: 'New York, NY' },
+*     type: 'tool_call'
+*   },
+*   {
+*     name: 'GetPopulation',
+*     args: { location: 'Los Angeles, CA' },
+*     type: 'tool_call'
+*   },
+*   {
+*     name: 'GetPopulation',
+*     args: { location: 'New York, NY' },
+*     type: 'tool_call'
+*   }
+* ]
+* ```
+* </details>
+*
+* <br />
+*
+* <details>
+* <summary><strong>Structured Output</strong></summary>
+*
+* ```typescript
+* const Joke = z.object({
+*   setup: z.string().describe("The setup of the joke"),
+*   punchline: z.string().describe("The punchline to the joke"),
+*   rating: z.number().optional().describe("How funny the joke is, from 1 to 10")
+* }).describe('Joke to tell user.');
+*
+* const structuredLlm = llm.withStructuredOutput(Joke, { name: "Joke" });
+* const jokeResult = await structuredLlm.invoke("Tell me a joke about cats");
+* console.log(jokeResult);
+* ```
+*
+* ```txt
+* {
+*   setup: "Why don\\'t cats play poker?",
+*   punchline: "Why don\\'t cats play poker? Because they always have an ace up their sleeve!"
+* }
+* ```
+* </details>
+*
+* <br />
+*
+* <details>
+* <summary><strong>Multimodal</strong></summary>
+*
+* ```typescript
+* import { HumanMessage } from '@langchain/core/messages';
+*
+* const imageUrl = "https://example.com/image.jpg";
+* const imageData = await fetch(imageUrl).then(res => res.arrayBuffer());
+* const base64Image = Buffer.from(imageData).toString('base64');
+*
+* const message = new HumanMessage({
+*   content: [
+*     { type: "text", text: "describe the weather in this image" },
+*     {
+*       type: "image_url",
+*       image_url: { url: `data:image/jpeg;base64,${base64Image}` },
+*     },
+*   ]
+* });
+*
+* const imageDescriptionAiMsg = await llm.invoke([message]);
+* console.log(imageDescriptionAiMsg.content);
+* ```
+*
+* ```txt
+* The weather in the image appears to be clear and sunny. The sky is mostly blue with a few scattered white clouds, indicating fair weather. The bright sunlight is casting shadows on the green, grassy hill, suggesting it is a pleasant day with good visibility. There are no signs of rain or stormy conditions.
+* ```
+* </details>
+*
+* <br />
+*
+* <details>
+* <summary><strong>Usage Metadata</strong></summary>
+*
+* ```typescript
+* const aiMsgForMetadata = await llm.invoke(input);
+* console.log(aiMsgForMetadata.usage_metadata);
+* ```
+*
+* ```txt
+* { input_tokens: 10, output_tokens: 149, total_tokens: 159 }
+* ```
+* </details>
+*
+* <br />
+*
+* <details>
+* <summary><strong>Response Metadata</strong></summary>
+*
+* ```typescript
+* const aiMsgForResponseMetadata = await llm.invoke(input);
+* console.log(aiMsgForResponseMetadata.response_metadata);
+* ```
+*
+* ```txt
+* {
+*   finishReason: 'STOP',
+*   index: 0,
+*   safetyRatings: [
+*     {
+*       category: 'HARM_CATEGORY_SEXUALLY_EXPLICIT',
+*       probability: 'NEGLIGIBLE'
+*     },
+*     {
+*       category: 'HARM_CATEGORY_HATE_SPEECH',
+*       probability: 'NEGLIGIBLE'
+*     },
+*     { category: 'HARM_CATEGORY_HARASSMENT', probability: 'NEGLIGIBLE' },
+*     {
+*       category: 'HARM_CATEGORY_DANGEROUS_CONTENT',
+*       probability: 'NEGLIGIBLE'
+*     }
+*   ]
+* }
+* ```
+* </details>
+*
+* <br />
+*
+* <details>
+* <summary><strong>Document Messages</strong></summary>
+*
+* This example will show you how to pass documents such as PDFs to Google
+* Generative AI through messages.
+*
+* ```typescript
+* const pdfPath = "/Users/my_user/Downloads/invoice.pdf";
+* const pdfBase64 = await fs.readFile(pdfPath, "base64");
+*
+* const response = await llm.invoke([
+*   ["system", "Use the provided documents to answer the question"],
+*   [
+*     "user",
+*     [
+*       {
+*         type: "application/pdf", // If the `type` field includes a single slash (`/`), it will be treated as inline data.
+*         data: pdfBase64,
+*       },
+*       {
+*         type: "text",
+*         text: "Summarize the contents of this PDF",
+*       },
+*     ],
+*   ],
+* ]);
+*
+* console.log(response.content);
+* ```
+*
+* ```txt
+* This is a billing invoice from Twitter Developers for X API Basic Access. The transaction date is January 7, 2025,
+* and the amount is $194.34, which has been paid. The subscription period is from January 7, 2025 21:02 to February 7, 2025 00:00 (UTC).
+* The tax is $0.00, with a tax rate of 0%. The total amount is $194.34. The payment was made using a Visa card ending in 7022,
+* expiring in 12/2026. The billing address is Brace Sproul, 1234 Main Street, San Francisco, CA, US 94103. The company being billed is
+* X Corp, located at 865 FM 1209 Building 2, Bastrop, TX, US 78602. Terms and conditions apply.
+* ```
+* </details>
+*
+* <br />
+*/
+/**
+* Whether the given model id is Gemini 3 or a later major version. Strips an
+* optional `models/` prefix and reads the major version number, so
+* `gemini-3.1-pro-preview`, `gemini-3.5-flash`, and a future `gemini-4-*` all
+* return true, while `gemini-2.5-flash` returns false.
+*/
+function isGemini3OrLater(model) {
+	const match = model.toLowerCase().replace(/^models\//, "").match(/gemini-(\d+)/);
+	return match ? Number(match[1]) >= 3 : false;
+}
+var ChatGoogleGenerativeAI = class extends BaseChatModel {
+	static lc_name() {
+		return "ChatGoogleGenerativeAI";
+	}
+	lc_serializable = true;
+	get lc_secrets() {
+		return { apiKey: "GOOGLE_API_KEY" };
+	}
+	lc_namespace = [
+		"langchain",
+		"chat_models",
+		"google_genai"
+	];
+	get lc_aliases() {
+		return { apiKey: "google_api_key" };
+	}
+	model;
+	temperature;
+	maxOutputTokens;
+	topP;
+	topK;
+	stopSequences = [];
+	safetySettings;
+	apiKey;
+	streaming = false;
+	json;
+	streamUsage = true;
+	convertSystemMessageToHumanContent;
+	thinkingConfig;
+	cachedContent;
+	client;
+	get _isMultimodalModel() {
+		return this.model.includes("vision") || this.model.startsWith("gemini-1.5") || this.model.startsWith("gemini-2") || this.model.startsWith("gemma-3-") && !this.model.startsWith("gemma-3-1b") || this.model.startsWith("gemini-3");
+	}
+	constructor(modelOrFields, fieldsArg) {
+		const fields = typeof modelOrFields === "string" ? {
+			...fieldsArg ?? {},
+			model: modelOrFields
+		} : modelOrFields;
+		super(fields);
+		this._addVersion("@intrvls/langchain-google-genai", "3.0.0-alpha.0");
+		this.model = fields.model.replace(/^models\//, "");
+		this.maxOutputTokens = fields.maxOutputTokens ?? this.maxOutputTokens;
+		if (this.maxOutputTokens && this.maxOutputTokens < 0) throw new Error("`maxOutputTokens` must be a positive integer");
+		this.temperature = fields.temperature ?? this.temperature;
+		if (this.temperature && (this.temperature < 0 || this.temperature > 2)) throw new Error("`temperature` must be in the range of [0.0,2.0]");
+		if (fields.temperature === void 0 && isGemini3OrLater(this.model)) this.temperature = 1;
+		this.topP = fields.topP ?? this.topP;
+		if (this.topP && this.topP < 0) throw new Error("`topP` must be a positive integer");
+		if (this.topP && this.topP > 1) throw new Error("`topP` must be below 1.");
+		this.topK = fields.topK ?? this.topK;
+		if (this.topK && this.topK < 0) throw new Error("`topK` must be a positive integer");
+		this.stopSequences = fields.stopSequences ?? this.stopSequences;
+		this.apiKey = fields.apiKey ?? getEnvironmentVariable("GOOGLE_API_KEY") ?? getEnvironmentVariable("GEMINI_API_KEY");
+		if (!this.apiKey) throw new Error("Please set an API key for Google GenerativeAI in the environment variable GOOGLE_API_KEY (or GEMINI_API_KEY) or in the `apiKey` field of the ChatGoogleGenerativeAI constructor");
+		this.safetySettings = fields.safetySettings ?? this.safetySettings;
+		if (this.safetySettings && this.safetySettings.length > 0) {
+			if (new Set(this.safetySettings.map((s) => s.category)).size !== this.safetySettings.length) throw new Error("The categories in `safetySettings` array must be unique");
+		}
+		this.streaming = fields.streaming ?? this.streaming;
+		this.json = fields.json;
+		this.thinkingConfig = fields.thinkingConfig ?? this.thinkingConfig;
+		this.cachedContent = fields.cachedContent ?? this.cachedContent;
+		this.client = new GoogleGenAI({
+			apiKey: this.apiKey,
+			httpOptions: {
+				apiVersion: fields.apiVersion,
+				baseUrl: fields.baseUrl,
+				headers: fields.customHeaders
+			}
+		});
+		this.streamUsage = fields.streamUsage ?? this.streamUsage;
+	}
+	get useSystemInstruction() {
+		return typeof this.convertSystemMessageToHumanContent === "boolean" ? !this.convertSystemMessageToHumanContent : this.computeUseSystemInstruction;
+	}
+	get computeUseSystemInstruction() {
+		if (this.model === "gemini-1.0-pro-001") return false;
+		else if (this.model.startsWith("gemini-pro-vision")) return false;
+		else if (this.model.startsWith("gemini-1.0-pro-vision")) return false;
+		else if (this.model === "gemini-pro") return false;
+		return true;
+	}
+	getLsParams(options) {
+		return {
+			ls_provider: "google_genai",
+			ls_model_name: this.model,
+			ls_model_type: "chat",
+			ls_temperature: this.temperature,
+			ls_max_tokens: this.maxOutputTokens,
+			ls_stop: options.stop
+		};
+	}
+	_combineLLMOutput() {
+		return [];
+	}
+	_llmType() {
+		return "googlegenerativeai";
+	}
+	bindTools(tools, kwargs) {
+		return this.withConfig({
+			tools: convertToolsToGenAI(tools)?.tools,
+			...kwargs
+		});
+	}
+	invocationParams(options) {
+		const toolsAndConfig = options?.tools?.length ? convertToolsToGenAI(options.tools, {
+			toolChoice: options.tool_choice,
+			allowedFunctionNames: options.allowedFunctionNames
+		}) : void 0;
+		return {
+			...toolsAndConfig?.tools ? { tools: toolsAndConfig.tools } : {},
+			...toolsAndConfig?.toolConfig ? { toolConfig: toolsAndConfig.toolConfig } : {},
+			...this.safetySettings ? { safetySettings: this.safetySettings } : {},
+			...this.cachedContent ? { cachedContent: this.cachedContent } : {},
+			stopSequences: this.stopSequences,
+			maxOutputTokens: this.maxOutputTokens,
+			temperature: this.temperature,
+			topP: this.topP,
+			topK: this.topK,
+			...this.json ? { responseMimeType: "application/json" } : {},
+			...this.thinkingConfig ? { thinkingConfig: this.thinkingConfig } : {},
+			...options?.responseSchema ? {
+				responseSchema: options.responseSchema,
+				responseMimeType: "application/json"
+			} : {}
+		};
+	}
+	_buildGenerateContentRequest(messages, options) {
+		const prompt = convertBaseMessagesToContent(messages, this._isMultimodalModel, this.useSystemInstruction, this.model);
+		let actualPrompt = prompt;
+		let systemInstruction;
+		if (prompt[0]?.role === "system") [systemInstruction, ...actualPrompt] = prompt;
+		const config = this.invocationParams(options);
+		return {
+			model: this.model,
+			contents: actualPrompt,
+			config: {
+				...config,
+				...systemInstruction ? { systemInstruction } : {},
+				...options.signal ? { abortSignal: options.signal } : {}
+			}
+		};
+	}
+	async _generate(messages, options, runManager) {
+		options.signal?.throwIfAborted();
+		if (this.streaming) {
+			const tokenUsage = {};
+			const stream = this._streamResponseChunks(messages, options, runManager);
+			const finalChunks = [];
+			for await (const chunk of stream) {
+				const index = chunk.generationInfo?.completion ?? 0;
+				if (finalChunks[index] === void 0) finalChunks[index] = chunk;
+				else finalChunks[index] = finalChunks[index].concat(chunk);
+			}
+			return {
+				generations: finalChunks.filter((c) => c !== void 0),
+				llmOutput: { estimatedTokenUsage: tokenUsage }
+			};
+		}
+		const res = await this.completionWithRetry(this._buildGenerateContentRequest(messages, options));
+		let usageMetadata;
+		if (res.usageMetadata) usageMetadata = convertUsageMetadata(res.usageMetadata, this.model);
+		const generationResult = mapGenerateContentResultToChatResult(res, { usageMetadata });
+		if (generationResult.generations?.length > 0) await runManager?.handleLLMNewToken(generationResult.generations[0]?.text ?? "");
+		return generationResult;
+	}
+	async *_streamResponseChunks(messages, options, runManager) {
+		const request = this._buildGenerateContentRequest(messages, options);
+		const stream = await this.caller.callWithOptions({ signal: options?.signal }, async () => {
+			return this.client.models.generateContentStream(request);
+		});
+		let usageMetadata;
+		let prevPromptTokenCount = 0;
+		let prevCandidatesTokenCount = 0;
+		let prevThoughtsTokenCount = 0;
+		let prevTotalTokenCount = 0;
+		let index = 0;
+		for await (const response of stream) {
+			if (options.signal?.aborted) return;
+			if ("usageMetadata" in response && response.usageMetadata !== void 0 && this.streamUsage !== false && options.streamUsage !== false) {
+				usageMetadata = convertUsageMetadata(response.usageMetadata, this.model);
+				const newPromptTokenCount = response.usageMetadata.promptTokenCount ?? 0;
+				usageMetadata.input_tokens = Math.max(0, newPromptTokenCount - prevPromptTokenCount);
+				prevPromptTokenCount = newPromptTokenCount;
+				const newCandidatesTokenCount = response.usageMetadata.candidatesTokenCount ?? 0;
+				const candidatesDelta = Math.max(0, newCandidatesTokenCount - prevCandidatesTokenCount);
+				prevCandidatesTokenCount = newCandidatesTokenCount;
+				const newThoughtsTokenCount = response.usageMetadata.thoughtsTokenCount ?? 0;
+				const reasoningDelta = Math.max(0, newThoughtsTokenCount - prevThoughtsTokenCount);
+				prevThoughtsTokenCount = newThoughtsTokenCount;
+				usageMetadata.output_tokens = candidatesDelta + reasoningDelta;
+				usageMetadata.output_token_details = reasoningDelta ? {
+					...usageMetadata.output_token_details,
+					reasoning: reasoningDelta
+				} : usageMetadata.output_token_details;
+				const newTotalTokenCount = response.usageMetadata.totalTokenCount ?? 0;
+				usageMetadata.total_tokens = Math.max(0, newTotalTokenCount - prevTotalTokenCount);
+				prevTotalTokenCount = newTotalTokenCount;
+			}
+			const chunk = convertResponseContentToChatGenerationChunk(response, {
+				usageMetadata,
+				index
+			});
+			index += 1;
+			if (!chunk) continue;
+			yield chunk;
+			await runManager?.handleLLMNewToken(chunk.text ?? "");
+		}
+	}
+	async completionWithRetry(request, options) {
+		return this.caller.callWithOptions({ signal: options?.signal }, async () => {
+			try {
+				return await this.client.models.generateContent(request);
+			} catch (e) {
+				if (e.message?.includes("400 Bad Request")) e.status = 400;
+				throw e;
+			}
+		});
+	}
+	/**
+	* Return profiling information for the model.
+	*
+	* Provides information about the model's capabilities and constraints,
+	* including token limits, multimodal support, and advanced features like
+	* tool calling and structured output.
+	*
+	* @returns {ModelProfile} An object describing the model's capabilities and constraints
+	*
+	* @example
+	* ```typescript
+	* const model = new ChatGoogleGenerativeAI({ model: "gemini-2.5-flash" });
+	* const profile = model.profile;
+	* console.log(profile.maxInputTokens); // 1048576
+	* console.log(profile.imageInputs); // true
+	* ```
+	*/
+	get profile() {
+		return PROFILES[this.model] ?? {};
+	}
+	withStructuredOutput(outputSchema, config) {
+		const schema = outputSchema;
+		const name = config?.name;
+		const method = config?.method;
+		const includeRaw = config?.includeRaw;
+		if (method === "jsonMode") throw new Error(`ChatGoogleGenerativeAI only supports "jsonSchema" or "functionCalling" as a method.`);
+		let llm;
+		let outputParser;
+		if (method === "functionCalling") {
+			let functionName = name ?? "extract";
+			let geminiFunctionDeclaration;
+			if (isInteropZodSchema(schema) || isSerializableSchema(schema)) {
+				const jsonSchema = schemaToGenerativeAIParameters(schema);
+				geminiFunctionDeclaration = {
+					name: functionName,
+					description: jsonSchema.description ?? "A function available to call.",
+					parameters: jsonSchema
+				};
+			} else if (typeof schema.name === "string" && typeof schema.parameters === "object" && schema.parameters != null) {
+				geminiFunctionDeclaration = schema;
+				geminiFunctionDeclaration.parameters = removeAdditionalProperties(schema.parameters);
+				functionName = schema.name;
+			} else geminiFunctionDeclaration = {
+				name: functionName,
+				description: schema.description ?? "",
+				parameters: removeAdditionalProperties(schema)
+			};
+			const tools = [{ functionDeclarations: [geminiFunctionDeclaration] }];
+			llm = this.bindTools(tools).withConfig({ allowedFunctionNames: [functionName] });
+			outputParser = createFunctionCallingParser(schema, functionName, GoogleGenerativeAIToolsOutputParser);
+		} else {
+			const jsonSchema = schemaToGenerativeAIParameters(schema);
+			llm = this.withConfig({ responseSchema: jsonSchema });
+			outputParser = createContentParser(schema);
+		}
+		return assembleStructuredOutputPipeline(llm, outputParser, includeRaw, includeRaw ? "StructuredOutputRunnable" : "ChatGoogleGenerativeAIStructuredOutput");
+	}
+};
+//#endregion
+//#region src/embeddings.ts
+/**
+* Class that extends the Embeddings class and provides methods for
+* generating embeddings using the Google Palm API.
+* @example
+* ```typescript
+* const model = new GoogleGenerativeAIEmbeddings({
+*   apiKey: "<YOUR API KEY>",
+*   modelName: "embedding-001",
+* });
+*
+* // Embed a single query
+* const res = await model.embedQuery(
+*   "What would be a good company name for a company that makes colorful socks?"
+* );
+* console.log({ res });
+*
+* // Embed multiple documents
+* const documentRes = await model.embedDocuments(["Hello world", "Bye bye"]);
+* console.log({ documentRes });
+* ```
+*/
+var GoogleGenerativeAIEmbeddings = class extends Embeddings {
+	apiKey;
+	modelName = "gemini-embedding-001";
+	model = "gemini-embedding-001";
+	taskType;
+	title;
+	stripNewLines = true;
+	maxBatchSize = 100;
+	client;
+	constructor(fields) {
+		super(fields ?? {});
+		this.modelName = fields?.model?.replace(/^models\//, "") ?? fields?.modelName?.replace(/^models\//, "") ?? this.modelName;
+		this.model = this.modelName;
+		this.taskType = fields?.taskType ?? this.taskType;
+		this.title = fields?.title ?? this.title;
+		if (this.title && this.taskType !== "RETRIEVAL_DOCUMENT") throw new Error("title can only be sepcified with TaskType.RETRIEVAL_DOCUMENT");
+		this.apiKey = fields?.apiKey ?? getEnvironmentVariable("GOOGLE_API_KEY") ?? getEnvironmentVariable("GEMINI_API_KEY");
+		if (!this.apiKey) throw new Error("Please set an API key for Google GenerativeAI in the environment variable GOOGLE_API_KEY (or GEMINI_API_KEY) or in the `apiKey` field of the GoogleGenerativeAIEmbeddings constructor");
+		this.client = new GoogleGenAI({
+			apiKey: this.apiKey,
+			httpOptions: { baseUrl: fields?.baseUrl }
+		});
+	}
+	_cleanText(text) {
+		return this.stripNewLines ? text.replace(/\n/g, " ") : text;
+	}
+	get _embedConfig() {
+		return {
+			taskType: this.taskType,
+			title: this.title
+		};
+	}
+	async _embedQueryContent(text) {
+		return (await this.client.models.embedContent({
+			model: this.model,
+			contents: [this._cleanText(text)],
+			config: this._embedConfig
+		})).embeddings?.[0]?.values ?? [];
+	}
+	async _embedDocumentsContent(documents) {
+		const batchEmbedChunks = chunkArray(documents, this.maxBatchSize);
+		return (await Promise.allSettled(batchEmbedChunks.map((chunk) => this.client.models.embedContent({
+			model: this.model,
+			contents: chunk.map((doc) => this._cleanText(doc)),
+			config: this._embedConfig
+		})))).flatMap((res, idx) => {
+			if (res.status === "fulfilled") return (res.value.embeddings ?? []).map((e) => e.values ?? []);
+			else return Array(batchEmbedChunks[idx].length).fill([]);
+		});
+	}
+	/**
+	* Method that takes a document as input and returns a promise that
+	* resolves to an embedding for the document. It calls the _embedText
+	* method with the document as the input.
+	* @param document Document for which to generate an embedding.
+	* @returns Promise that resolves to an embedding for the input document.
+	*/
+	embedQuery(document) {
+		return this.caller.call(this._embedQueryContent.bind(this), document);
+	}
+	/**
+	* Method that takes an array of documents as input and returns a promise
+	* that resolves to a 2D array of embeddings for each document. It calls
+	* the _embedText method for each document in the array.
+	* @param documents Array of documents for which to generate embeddings.
+	* @returns Promise that resolves to a 2D array of embeddings for each input document.
+	*/
+	embedDocuments(documents) {
+		return this.caller.call(this._embedDocumentsContent.bind(this), documents);
+	}
+};
+//#endregion
+export { ChatGoogleGenerativeAI, GoogleGenerativeAIEmbeddings };
+
+//# sourceMappingURL=index.mjs.map