@langchain/google 0.2.12 → 0.2.14

package/dist/converters/interactions/messages.cjs

@@ -0,0 +1,766 @@
+const require_errors = require("../../utils/errors.cjs");
+const require_messages = require("../generate_content/messages.cjs");
+let _langchain_core_messages = require("@langchain/core/messages");
+// src/converters/interactions/messages.ts
+/**
+* Converts a single LangChain `BaseMessage` into `Gemini.Part[]` by delegating
+* to the existing GenerateContent message converters.
+*
+* When `message` is a `ToolMessage`, `convertMessagesToGeminiContents` requires
+* the preceding `AIMessage` that issued the matching `tool_call_id` to be present
+* in the input array so it can resolve the function name (and avoid throwing
+* `ToolCallNotFoundError`). Pass the full `messages` conversation array when
+* converting a `ToolMessage` so the matching `AIMessage` can be included as
+* context; if none is found (e.g., a standalone `ToolMessage`), a minimal
+* synthetic `AIMessage` is provided as a fallback. Only the `Gemini.Part[]`
+* produced for `message` itself is returned.
+*
+* @param message - The individual message to convert into `Gemini.Part[]`.
+* @param messages - Optional full conversation history used to look up the
+*   matching `AIMessage` when `message` is a `ToolMessage`.
+*/
+function convertSingleMessageToGeminiParts(message, messages) {
+	if (_langchain_core_messages.SystemMessage.isInstance(message)) return require_messages.convertMessagesToGeminiSystemInstruction([message])?.parts ?? [];
+	if (_langchain_core_messages.ToolMessage.isInstance(message)) {
+		const aiMsg = messages?.filter(_langchain_core_messages.AIMessage.isInstance).find((msg) => msg.tool_calls?.find((tc) => tc.id === message.tool_call_id));
+		const fallbackAiMsg = !aiMsg && message.tool_call_id ? new _langchain_core_messages.AIMessage({ tool_calls: [{
+			type: "tool_call",
+			id: message.tool_call_id,
+			name: message.name ?? "unknown",
+			args: {}
+		}] }) : void 0;
+		const contextMessages = [...aiMsg ? [aiMsg] : fallbackAiMsg ? [fallbackAiMsg] : [], message];
+		const contents = require_messages.convertMessagesToGeminiContents(contextMessages);
+		return contents[contents.length - 1]?.parts ?? [];
+	}
+	return require_messages.convertMessagesToGeminiContents([message]).flatMap((c) => c.parts ?? []);
+}
+/**
+* Extracts and concatenates leading `SystemMessage` instances into the
+* Interactions API `system_instruction` string.
+*/
+function convertMessagesToInteractionsSystemInstruction(messages) {
+	const chunks = [];
+	for (let i = 0; i < messages.length; i++) {
+		const message = messages[i];
+		if (_langchain_core_messages.SystemMessage.isInstance(message)) {
+			const parts = convertSingleMessageToGeminiParts(message);
+			for (const part of parts) if (typeof part.text === "string" && part.text.length > 0) chunks.push(part.text);
+		} else break;
+	}
+	return chunks.length > 0 ? chunks.join("\n") : void 0;
+}
+/**
+* Maps a GenerateContent `Part.MediaResolution` or string into an Interactions `MediaResolution`.
+*/
+function mapPartResolutionToInteractions(partResolution, defaultResolution) {
+	const rawLevel = typeof partResolution === "string" ? partResolution : partResolution?.level;
+	if (rawLevel) {
+		const lower = rawLevel.toLowerCase();
+		if (lower === "media_resolution_low" || lower === "low") return "low";
+		if (lower === "media_resolution_medium" || lower === "medium") return "medium";
+		if (lower === "media_resolution_high" || lower === "high") return "high";
+		if (lower === "media_resolution_ultra_high" || lower === "ultra_high") return "ultra_high";
+	}
+	return defaultResolution;
+}
+/**
+* Converts a single `Gemini.Part` (produced by `convertMessageToGeminiParts`) into an
+* Interactions API `Content` item (`TextContent`, `ImageContent`, `AudioContent`,
+* `DocumentContent`, or `VideoContent`).
+*/
+function convertGeminiPartToInteractionsContent(part, defaultMediaResolution) {
+	if (typeof part.text === "string") return {
+		type: "text",
+		text: part.text
+	};
+	if (part.inlineData) {
+		const mimeType = part.inlineData.mimeType || "application/octet-stream";
+		const data = part.inlineData.data;
+		const resolution = mapPartResolutionToInteractions(part.mediaResolution, defaultMediaResolution);
+		if (mimeType.startsWith("image/")) return {
+			type: "image",
+			mime_type: mimeType,
+			data,
+			...resolution ? { resolution } : {}
+		};
+		if (mimeType.startsWith("audio/")) return {
+			type: "audio",
+			mime_type: mimeType,
+			data
+		};
+		if (mimeType.startsWith("video/")) return {
+			type: "video",
+			mime_type: mimeType,
+			data,
+			...resolution ? { resolution } : {}
+		};
+		return {
+			type: "document",
+			mime_type: mimeType,
+			data
+		};
+	}
+	if (part.fileData) {
+		const mimeType = part.fileData.mimeType || "application/octet-stream";
+		const uri = part.fileData.fileUri;
+		const resolution = mapPartResolutionToInteractions(part.mediaResolution, defaultMediaResolution);
+		if (mimeType.startsWith("image/")) return {
+			type: "image",
+			mime_type: mimeType,
+			uri,
+			...resolution ? { resolution } : {}
+		};
+		if (mimeType.startsWith("audio/")) return {
+			type: "audio",
+			mime_type: mimeType,
+			uri
+		};
+		if (mimeType.startsWith("video/")) return {
+			type: "video",
+			mime_type: mimeType,
+			uri,
+			...resolution ? { resolution } : {}
+		};
+		return {
+			type: "document",
+			mime_type: mimeType,
+			uri
+		};
+	}
+}
+/**
+* Converts an Interactions API `Content` item into a `Gemini.Part` so that
+* downstream `convertGeminiPartToContentBlock` produces identical LangChain
+* `AIMessage` content blocks to `GenerateContentApiHandler`.
+*/
+function convertInteractionsContentToGeminiPart(content, thoughtSignature) {
+	const sigSpread = thoughtSignature ? { thoughtSignature } : {};
+	switch (content.type) {
+		case "text": return {
+			text: content.text,
+			...sigSpread
+		};
+		case "image":
+		case "audio":
+		case "video":
+		case "document": {
+			const mimeType = content.mime_type || `${content.type}/unknown`;
+			if (content.data) return {
+				inlineData: {
+					mimeType,
+					data: content.data
+				},
+				...sigSpread
+			};
+			if (content.uri) return {
+				fileData: {
+					mimeType,
+					fileUri: content.uri
+				},
+				...sigSpread
+			};
+			return;
+		}
+		default: return;
+	}
+}
+/**
+* Converts an array of LangChain `BaseMessage`s into an array of Interactions API `Step`s.
+*
+* ### ThoughtStep & `thoughtSignature` Round-Trip Design
+*
+* In the Interactions API, model reasoning and cryptographic thought signatures are
+* represented as standalone `{ type: "thought", signature, summary? }` steps in the
+* step sequence, rather than inline `{ thought: true, thoughtSignature }` fields on
+* text or tool-call parts.
+*
+* When converting an `AIMessage` back into Interactions `Step`s for multi-turn history:
+* 1. If the `AIMessage` contains reasoning blocks (`v1` `{ type: "reasoning", reasoning }`
+*    or `v0` `{ type: "text", thought: true, text, thoughtSignature }`), each reasoning
+*    block is emitted as a `{ type: "thought", signature, summary: [{ type: "text", text }] }` step.
+* 2. In the Interactions API, Gemini 2.5 / 3 models also emit signature-only `ThoughtStep`s
+*    (`{ type: "thought", signature }` with no `summary`) before `ModelOutputStep` or
+*    `FunctionCallStep` when `thinking_summaries` is not enabled. On inbound conversion
+*    (`convertInteractionToAIMessage`), we stash those signatures on:
+*    - `aiMessage.additional_kwargs.originalTextContentBlock.thoughtSignature` (or non-thought
+*      text content blocks), and
+*    - `aiMessage.tool_calls[i].thoughtSignature`.
+*    When converting that `AIMessage` back to `Step`s here, if a `thoughtSignature` is present
+*    on the text block or tool call and has NOT already been emitted by a preceding `ThoughtStep`,
+*    we emit `{ type: "thought", signature }` immediately before the corresponding
+*    `{ type: "model_output" }` or `{ type: "function_call" }` step.
+*/
+function convertMessagesToInteractionsInput(messages, defaultMediaResolution) {
+	const steps = [];
+	let isLeadingSystemMessages = true;
+	for (let i = 0; i < messages.length; i++) {
+		const message = messages[i];
+		if (isLeadingSystemMessages && _langchain_core_messages.SystemMessage.isInstance(message)) continue;
+		isLeadingSystemMessages = false;
+		if (_langchain_core_messages.AIMessage.isInstance(message)) {
+			const parts = convertSingleMessageToGeminiParts(message);
+			const modelOutputContents = [];
+			const emittedSignatures = /* @__PURE__ */ new Set();
+			let pendingOutputSignature;
+			const flushModelOutput = () => {
+				if (modelOutputContents.length > 0) {
+					if (pendingOutputSignature && !emittedSignatures.has(pendingOutputSignature)) {
+						const lastStep = steps[steps.length - 1];
+						if (lastStep?.type === "thought" && !lastStep.signature) lastStep.signature = pendingOutputSignature;
+						else steps.push({
+							type: "thought",
+							signature: pendingOutputSignature
+						});
+						emittedSignatures.add(pendingOutputSignature);
+					}
+					steps.push({
+						type: "model_output",
+						content: [...modelOutputContents]
+					});
+					modelOutputContents.length = 0;
+					pendingOutputSignature = void 0;
+				}
+			};
+			let callIndex = 0;
+			for (const part of parts) if (part.thought) {
+				flushModelOutput();
+				const summaryContent = [];
+				if (typeof part.text === "string" && part.text.length > 0) summaryContent.push({
+					type: "text",
+					text: part.text
+				});
+				if (part.thoughtSignature) emittedSignatures.add(part.thoughtSignature);
+				steps.push({
+					type: "thought",
+					...part.thoughtSignature ? { signature: part.thoughtSignature } : {},
+					...summaryContent.length > 0 ? { summary: summaryContent } : {}
+				});
+			} else if (part.executableCode) {
+				flushModelOutput();
+				steps.push({
+					type: "code_execution_call",
+					id: `code_exec_${callIndex++}`,
+					arguments: {
+						code: part.executableCode.code,
+						language: "python"
+					},
+					...part.thoughtSignature ? { signature: part.thoughtSignature } : {}
+				});
+			} else if (part.codeExecutionResult) {
+				flushModelOutput();
+				steps.push({
+					type: "code_execution_result",
+					call_id: `code_exec_${Math.max(0, callIndex - 1)}`,
+					result: part.codeExecutionResult.output ?? "",
+					is_error: part.codeExecutionResult.outcome !== "OUTCOME_OK" && part.codeExecutionResult.outcome !== "OUTCOME_UNSPECIFIED" && Boolean(part.codeExecutionResult.outcome),
+					...part.thoughtSignature ? { signature: part.thoughtSignature } : {}
+				});
+			} else if (part.functionCall) {
+				flushModelOutput();
+				const originalToolCall = message.tool_calls?.[callIndex];
+				const id = part.functionCall.id || originalToolCall?.id || `call_${callIndex}`;
+				const sig = part.thoughtSignature || originalToolCall?.thoughtSignature;
+				if (sig && !emittedSignatures.has(sig)) {
+					const lastStep = steps[steps.length - 1];
+					if (lastStep?.type === "thought" && !lastStep.signature) lastStep.signature = sig;
+					else steps.push({
+						type: "thought",
+						signature: sig
+					});
+					emittedSignatures.add(sig);
+				}
+				steps.push({
+					type: "function_call",
+					id,
+					name: part.functionCall.name,
+					arguments: part.functionCall.args ?? {}
+				});
+				callIndex++;
+			} else {
+				if (part.thoughtSignature && !pendingOutputSignature) pendingOutputSignature = part.thoughtSignature;
+				const converted = convertGeminiPartToInteractionsContent(part, defaultMediaResolution);
+				if (converted) modelOutputContents.push(converted);
+			}
+			flushModelOutput();
+			if (pendingOutputSignature && !emittedSignatures.has(pendingOutputSignature)) {
+				steps.push({
+					type: "thought",
+					signature: pendingOutputSignature
+				});
+				emittedSignatures.add(pendingOutputSignature);
+			}
+		} else if (_langchain_core_messages.ToolMessage.isInstance(message)) {
+			const callId = message.tool_call_id || message.additional_kwargs?.tool_call_id || "unknown";
+			const name = message.name || message.additional_kwargs?.name || messages.filter(_langchain_core_messages.AIMessage.isInstance).flatMap((m) => m.tool_calls ?? []).find((tc) => tc.id === callId)?.name;
+			const isError = message.status === "error" ? true : void 0;
+			let result;
+			if (typeof message.content === "string") try {
+				const parsed = JSON.parse(message.content);
+				if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) result = parsed;
+				else result = message.content;
+			} catch {
+				result = message.content;
+			}
+			else if (Array.isArray(message.content)) {
+				const parts = convertSingleMessageToGeminiParts(message, messages);
+				if (parts.some((p) => !("functionResponse" in p))) {
+					const contents = [];
+					for (const part of parts) if (part.functionResponse?.response) {
+						const resp = part.functionResponse.response;
+						if (typeof resp === "object" && resp !== null && "result" in resp && Object.keys(resp).length === 1) {
+							if (typeof resp.result === "string") contents.push({
+								type: "text",
+								text: resp.result
+							});
+							else if (Array.isArray(resp.result)) for (const item of resp.result) if (typeof item === "string") contents.push({
+								type: "text",
+								text: item
+							});
+							else if (typeof item === "object" && item !== null && "text" in item && typeof item.text === "string") contents.push({
+								type: "text",
+								text: item.text
+							});
+							else contents.push({
+								type: "text",
+								text: JSON.stringify(item)
+							});
+							else contents.push({
+								type: "text",
+								text: JSON.stringify(resp.result)
+							});
+						} else contents.push({
+							type: "text",
+							text: JSON.stringify(resp)
+						});
+					} else {
+						const converted = convertGeminiPartToInteractionsContent(part, defaultMediaResolution);
+						if (converted) contents.push(converted);
+					}
+					result = contents.length > 0 ? contents : "";
+				} else result = parts.find((p) => "functionResponse" in p && Boolean(p.functionResponse?.response))?.functionResponse?.response ?? { result: message.content };
+			} else if (typeof message.content === "object" && message.content !== null) result = { result: message.content };
+			else result = String(message.content ?? "");
+			steps.push({
+				type: "function_result",
+				call_id: callId,
+				...name ? { name } : {},
+				...typeof isError === "boolean" ? { is_error: isError } : {},
+				result
+			});
+		} else {
+			const parts = convertSingleMessageToGeminiParts(message);
+			const contents = [];
+			for (const part of parts) {
+				const converted = convertGeminiPartToInteractionsContent(part, defaultMediaResolution);
+				if (converted) contents.push(converted);
+			}
+			if (contents.length > 0) steps.push({
+				type: "user_input",
+				content: contents
+			});
+		}
+	}
+	return steps;
+}
+/**
+* Converts Interactions API `ModalityTokens[]` into a modality record (`text`, `image`, `audio`, etc.)
+* compatible with LangChain's `InputTokenDetails` / `OutputTokenDetails`.
+*/
+function convertInteractionsModalityTokensToRecord(modalityTokens) {
+	const ret = {};
+	for (const item of modalityTokens ?? []) if (item.modality && typeof item.tokens === "number") {
+		const key = item.modality.toLowerCase();
+		ret[key] = (ret[key] ?? 0) + item.tokens;
+	}
+	return ret;
+}
+/**
+* Converts an Interactions API `Usage` object into LangChain's `UsageMetadata`.
+*/
+function convertInteractionsUsageToUsageMetadata(usage) {
+	if (!usage) return;
+	const inputMods = convertInteractionsModalityTokensToRecord(usage.input_tokens_by_modality);
+	const outputMods = convertInteractionsModalityTokensToRecord(usage.output_tokens_by_modality);
+	const cacheRead = usage.total_cached_tokens;
+	const toolUse = usage.total_tool_use_tokens;
+	const inputTokenDetails = {
+		...typeof cacheRead === "number" ? { cache_read: cacheRead } : {},
+		...typeof toolUse === "number" ? { tool_use: toolUse } : {},
+		...inputMods
+	};
+	const reasoning = usage.total_thought_tokens;
+	const outputTokenDetails = {
+		...typeof reasoning === "number" ? { reasoning } : {},
+		...outputMods
+	};
+	const rawInput = usage.total_input_tokens ?? 0;
+	const rawOutput = usage.total_output_tokens ?? 0;
+	const rawThought = usage.total_thought_tokens ?? 0;
+	const rawToolUse = usage.total_tool_use_tokens ?? 0;
+	const inputTokens = typeof usage.total_tokens === "number" && rawInput + rawToolUse + rawOutput + rawThought === usage.total_tokens ? rawInput + rawToolUse : rawInput;
+	const outputTokens = typeof usage.total_tokens === "number" && rawInput + rawOutput === usage.total_tokens && rawThought > 0 ? rawOutput : rawOutput + rawThought;
+	return {
+		input_tokens: inputTokens,
+		output_tokens: outputTokens,
+		total_tokens: usage.total_tokens ?? inputTokens + outputTokens,
+		...Object.keys(inputTokenDetails).length > 0 ? { input_token_details: inputTokenDetails } : {},
+		...Object.keys(outputTokenDetails).length > 0 ? { output_token_details: outputTokenDetails } : {}
+	};
+}
+/**
+* Normalizes an item from `interaction.steps` or legacy `interaction.outputs`
+* into a `Gemini.Interactions.Step`.
+*/
+function normalizeInteractionStep(item) {
+	if (item.type === "text" || item.type === "image" || item.type === "audio" || item.type === "document" || item.type === "video") return {
+		type: "model_output",
+		content: [item]
+	};
+	return item;
+}
+/**
+* Synthesizes GenerateContent-compatible `groundingMetadata`, `citationMetadata`,
+* `groundingSupport`, and `urlContextMetadata` from Interactions API annotations
+* and built-in tool steps (`google_search_*`, `google_maps_*`, `file_search_*`, `url_context_*`).
+*/
+function synthesizeMetadataFromInteractions(options) {
+	const { textSegments, builtInToolSteps } = options;
+	const webSearchQueries = [];
+	const groundingChunks = [];
+	const groundingSupports = [];
+	const citationSources = [];
+	const urlMetadataList = [];
+	let searchEntryPointRenderedContent;
+	const urlToChunkIndex = /* @__PURE__ */ new Map();
+	for (const step of builtInToolSteps) if (step.type === "google_search_call") {
+		for (const q of step.arguments?.queries ?? []) if (q && !webSearchQueries.includes(q)) webSearchQueries.push(q);
+	} else if (step.type === "google_search_result") for (const item of step.result ?? []) {
+		const rawItem = item;
+		if (rawItem.rendered_content && !searchEntryPointRenderedContent) searchEntryPointRenderedContent = rawItem.rendered_content;
+		if (rawItem.url || rawItem.title) {
+			const chunkIndex = groundingChunks.length;
+			groundingChunks.push({ web: {
+				...rawItem.url ? { uri: rawItem.url } : {},
+				...rawItem.title ? { title: rawItem.title } : {}
+			} });
+			if (rawItem.url && !urlToChunkIndex.has(rawItem.url)) urlToChunkIndex.set(rawItem.url, chunkIndex);
+		}
+	}
+	else if (step.type === "google_maps_call") {
+		for (const q of step.arguments?.queries ?? []) if (q && !webSearchQueries.includes(q)) webSearchQueries.push(q);
+	} else if (step.type === "google_maps_result") for (const item of step.result ?? []) for (const place of item.places ?? []) {
+		const chunkIndex = groundingChunks.length;
+		groundingChunks.push({ maps: {
+			...place.url ? { uri: place.url } : {},
+			...place.name ? { title: place.name } : {},
+			...place.place_id ? { placeId: place.place_id } : {}
+		} });
+		if (place.url && !urlToChunkIndex.has(place.url)) urlToChunkIndex.set(place.url, chunkIndex);
+	}
+	else if (step.type === "file_search_result") for (const item of step.result ?? []) groundingChunks.push({ retrievedContext: {
+		...item.title ? { title: item.title } : {},
+		...item.text ? { text: item.text } : {},
+		...item.file_search_store ? { fileSearchStore: item.file_search_store } : {}
+	} });
+	else if (step.type === "url_context_result") for (const item of step.result ?? []) {
+		let status = "URL_RETRIEVAL_STATUS_UNSPECIFIED";
+		switch (item.status) {
+			case "success":
+				status = "URL_RETRIEVAL_STATUS_SUCCESS";
+				break;
+			case "error":
+				status = "URL_RETRIEVAL_STATUS_ERROR";
+				break;
+			case "paywall":
+				status = "URL_RETRIEVAL_STATUS_PAYWALL";
+				break;
+			case "unsafe":
+				status = "URL_RETRIEVAL_STATUS_UNSAFE";
+				break;
+			default: status = "URL_RETRIEVAL_STATUS_UNSPECIFIED";
+		}
+		urlMetadataList.push({
+			...item.url ? { retrievedUrl: item.url } : {},
+			urlRetrievalStatus: status
+		});
+		if (item.url && !urlToChunkIndex.has(item.url)) {
+			const chunkIndex = groundingChunks.length;
+			groundingChunks.push({ web: { uri: item.url } });
+			urlToChunkIndex.set(item.url, chunkIndex);
+		}
+	}
+	for (let partIndex = 0; partIndex < textSegments.length; partIndex++) {
+		const seg = textSegments[partIndex];
+		for (const annotation of seg.annotations ?? []) if (annotation.type === "url_citation") {
+			citationSources.push({
+				...typeof annotation.start_index === "number" ? { startIndex: annotation.start_index } : {},
+				...typeof annotation.end_index === "number" ? { endIndex: annotation.end_index } : {},
+				...annotation.url ? { uri: annotation.url } : {}
+			});
+			let chunkIdx = annotation.url ? urlToChunkIndex.get(annotation.url) : void 0;
+			if (chunkIdx === void 0 && (annotation.url || annotation.title)) {
+				chunkIdx = groundingChunks.length;
+				groundingChunks.push({ web: {
+					...annotation.url ? { uri: annotation.url } : {},
+					...annotation.title ? { title: annotation.title } : {}
+				} });
+				if (annotation.url) urlToChunkIndex.set(annotation.url, chunkIdx);
+			}
+			groundingSupports.push({
+				segment: {
+					partIndex,
+					...typeof annotation.start_index === "number" ? { startIndex: annotation.start_index } : {},
+					...typeof annotation.end_index === "number" ? { endIndex: annotation.end_index } : {}
+				},
+				...chunkIdx !== void 0 ? { groundingChunkIndices: [chunkIdx] } : {}
+			});
+		} else if (annotation.type === "place_citation") {
+			citationSources.push({
+				...typeof annotation.start_index === "number" ? { startIndex: annotation.start_index } : {},
+				...typeof annotation.end_index === "number" ? { endIndex: annotation.end_index } : {},
+				...annotation.url ? { uri: annotation.url } : {}
+			});
+			let chunkIdx = annotation.url ? urlToChunkIndex.get(annotation.url) : void 0;
+			if (chunkIdx === void 0 && (annotation.url || annotation.name || annotation.place_id)) {
+				chunkIdx = groundingChunks.length;
+				groundingChunks.push({ maps: {
+					...annotation.url ? { uri: annotation.url } : {},
+					...annotation.name ? { title: annotation.name } : {},
+					...annotation.place_id ? { placeId: annotation.place_id } : {}
+				} });
+				if (annotation.url) urlToChunkIndex.set(annotation.url, chunkIdx);
+			}
+			groundingSupports.push({
+				segment: {
+					partIndex,
+					...typeof annotation.start_index === "number" ? { startIndex: annotation.start_index } : {},
+					...typeof annotation.end_index === "number" ? { endIndex: annotation.end_index } : {}
+				},
+				...chunkIdx !== void 0 ? { groundingChunkIndices: [chunkIdx] } : {}
+			});
+		} else if (annotation.type === "file_citation") citationSources.push({
+			...typeof annotation.start_index === "number" ? { startIndex: annotation.start_index } : {},
+			...typeof annotation.end_index === "number" ? { endIndex: annotation.end_index } : {},
+			...annotation.document_uri ? { uri: annotation.document_uri } : {}
+		});
+	}
+	const groundingMetadata = webSearchQueries.length > 0 || groundingChunks.length > 0 || groundingSupports.length > 0 || Boolean(searchEntryPointRenderedContent) ? {
+		...webSearchQueries.length > 0 ? { webSearchQueries } : {},
+		...groundingChunks.length > 0 ? { groundingChunks } : {},
+		...groundingSupports.length > 0 ? { groundingSupports } : {},
+		...searchEntryPointRenderedContent ? { searchEntryPoint: { renderedContent: searchEntryPointRenderedContent } } : {}
+	} : void 0;
+	const groundingSupport = groundingMetadata?.groundingSupports?.filter((s) => (s?.segment?.partIndex ?? 0) === 0);
+	const citationMetadata = citationSources.length > 0 ? { citationSources } : void 0;
+	const urlContextMetadata = urlMetadataList.length > 0 ? { urlMetadata: urlMetadataList } : void 0;
+	return {
+		...groundingMetadata ? {
+			groundingMetadata,
+			grounding_metadata: groundingMetadata,
+			groundingSupport: groundingSupport ?? []
+		} : {},
+		...citationMetadata ? {
+			citationMetadata,
+			citation_metadata: citationMetadata
+		} : {},
+		...urlContextMetadata ? {
+			urlContextMetadata,
+			url_context_metadata: urlContextMetadata
+		} : {}
+	};
+}
+/**
+* Converts an Interactions API `Interaction` response into a LangChain `AIMessage`
+* along with `finishReason` and `usageMetadata`.
+*
+* ### ThoughtStep & `thoughtSignature` Inbound Mapping
+*
+* In `convertGeminiCandidateToAIMessage` (GenerateContent):
+* - A `Gemini.Part` with `thought: true` is treated as content-bearing (`!!p.thought === true`),
+*   which causes `AIMessage.content` to remain an array of content blocks (so the user can inspect
+*   the reasoning block alongside the text block).
+* - A `Gemini.Part` with `{ text: "Hello", thoughtSignature: "sig..." }` (or a trailing
+*   metadata-only `{ thoughtSignature: "sig..." }` part with `thought` undefined) is NOT a
+*   reasoning block: if there is a single text part, `AIMessage.content` collapses to the plain
+*   string `"Hello"` and `additional_kwargs.originalTextContentBlock` preserves
+*   `{ type: "text", text: "Hello", thoughtSignature: "sig..." }`.
+* - A `Gemini.Part` with `{ functionCall: {...}, thoughtSignature: "sig..." }` attaches
+*   `thoughtSignature` directly to `aiMessage.tool_calls[i].thoughtSignature`.
+*
+* In the Interactions API, the model emits `{ type: "thought", signature: "sig...", summary?: [...] }`:
+* - Even when `thinking_summaries` is NOT enabled (`summary` is undefined or empty), Gemini 2.5 / 3
+*   still emits a `ThoughtStep` containing `signature` before a `ModelOutputStep` or `FunctionCallStep`.
+* - Therefore:
+*   1. If `step.summary` is non-empty, we emit `Gemini.Part`(s) with `thought: true` and
+*      `thoughtSignature: step.signature`. This produces a reasoning block in `AIMessage.content`
+*      and `AIMessage.contentBlocks`.
+*   2. If `step.summary` is empty/undefined (signature-only), we do NOT emit a `{ thought: true }`
+*      part (which would prevent `AIMessage.content` from collapsing to a plain string!). Instead,
+*      we hold `pendingThoughtSignature = step.signature` and attach `thoughtSignature` to the
+*      next `FunctionCallStep` part or `ModelOutputStep` part (or as a metadata-only
+*      `{ thoughtSignature }` part if no step follows).
+*/
+function convertInteractionToAIMessage(interaction) {
+	const steps = (interaction.steps ?? interaction.outputs ?? []).map(normalizeInteractionStep);
+	const geminiParts = [];
+	const textSegments = [];
+	const builtInToolSteps = [];
+	let pendingThoughtSignature;
+	let pendingFunctionCallSignature;
+	for (const step of steps) switch (step.type) {
+		case "thought": {
+			const textSummaries = (step.summary ?? []).filter((c) => c.type === "text" && typeof c.text === "string" && c.text.length > 0);
+			if (textSummaries.length > 0) {
+				for (let i = 0; i < textSummaries.length; i++) {
+					const isLast = i === textSummaries.length - 1;
+					geminiParts.push({
+						text: textSummaries[i].text,
+						thought: true,
+						...isLast && step.signature ? { thoughtSignature: step.signature } : {}
+					});
+				}
+				pendingThoughtSignature = void 0;
+				pendingFunctionCallSignature = step.signature;
+			} else if (step.signature) {
+				pendingThoughtSignature = step.signature;
+				pendingFunctionCallSignature = step.signature;
+			}
+			break;
+		}
+		case "model_output": {
+			if (step.error?.message) throw new require_errors.GoogleError(`Google Interactions API model output error (${step.error.code ?? "unknown"}): ${step.error.message}`);
+			const contents = typeof step.content === "string" ? [{
+				type: "text",
+				text: step.content
+			}] : step.content ?? [];
+			for (const contentItem of contents) {
+				if (contentItem.type === "text") textSegments.push({
+					text: contentItem.text,
+					annotations: contentItem.annotations
+				});
+				const part = convertInteractionsContentToGeminiPart(contentItem, pendingThoughtSignature);
+				if (part) {
+					geminiParts.push(part);
+					pendingThoughtSignature = void 0;
+					pendingFunctionCallSignature = void 0;
+				}
+			}
+			break;
+		}
+		case "function_call": {
+			const fcSignature = pendingThoughtSignature ?? pendingFunctionCallSignature;
+			geminiParts.push({
+				functionCall: {
+					id: step.id,
+					name: step.name,
+					args: step.arguments ?? {}
+				},
+				...fcSignature ? { thoughtSignature: fcSignature } : {}
+			});
+			pendingThoughtSignature = void 0;
+			pendingFunctionCallSignature = void 0;
+			break;
+		}
+		case "code_execution_call":
+			geminiParts.push({
+				executableCode: {
+					code: step.arguments?.code ?? "",
+					language: "PYTHON"
+				},
+				...step.signature || pendingThoughtSignature ? { thoughtSignature: step.signature ?? pendingThoughtSignature } : {}
+			});
+			pendingThoughtSignature = void 0;
+			break;
+		case "code_execution_result":
+			geminiParts.push({
+				codeExecutionResult: {
+					output: step.result ?? "",
+					outcome: step.is_error ? "OUTCOME_FAILED" : "OUTCOME_OK"
+				},
+				...step.signature || pendingThoughtSignature ? { thoughtSignature: step.signature ?? pendingThoughtSignature } : {}
+			});
+			pendingThoughtSignature = void 0;
+			break;
+		case "google_search_call":
+		case "google_search_result":
+		case "google_maps_call":
+		case "google_maps_result":
+		case "file_search_call":
+		case "file_search_result":
+		case "url_context_call":
+		case "url_context_result":
+		case "mcp_server_tool_call":
+		case "mcp_server_tool_result":
+		case "processing_call":
+		case "processing_result":
+		case "retrieval_call":
+		case "retrieval_result": builtInToolSteps.push(step);
+	}
+	if (pendingThoughtSignature) geminiParts.push({ thoughtSignature: pendingThoughtSignature });
+	const blockContent = geminiParts.map((part) => require_messages.convertGeminiPartToContentBlock(part)).filter((block) => block !== null);
+	let content = blockContent;
+	let originalTextContentBlock;
+	const hasContentPayload = (p) => p.type !== "text" || typeof p.text === "string" && p.text.length > 0 || !!p.thought;
+	const contentBearingParts = blockContent.filter(hasContentPayload);
+	if (blockContent.length === 1 && blockContent[0].type === "text") {
+		originalTextContentBlock = blockContent[0];
+		content = blockContent[0].text;
+	} else if (contentBearingParts.length === 1 && contentBearingParts[0].type === "text" && !contentBearingParts[0].thought) {
+		const textPart = contentBearingParts[0];
+		const sigSource = blockContent.find((p) => p !== textPart && p.thoughtSignature);
+		originalTextContentBlock = sigSource ? {
+			...textPart,
+			thoughtSignature: sigSource.thoughtSignature
+		} : textPart;
+		content = textPart.text;
+	} else if (blockContent.length === 0) content = "";
+	const toolCalls = require_messages.convertGeminiPartsToToolCalls(geminiParts);
+	const usageMetadata = convertInteractionsUsageToUsageMetadata(interaction.usage);
+	const synthesized = synthesizeMetadataFromInteractions({
+		textSegments,
+		builtInToolSteps
+	});
+	let finishReason;
+	if (interaction.status === "completed") finishReason = "STOP";
+	else if (interaction.status === "requires_action") finishReason = "STOP";
+	else if (interaction.status) finishReason = interaction.status.toUpperCase();
+	const responseMetadata = {
+		model_provider: "google",
+		...interaction.model ? { model_name: interaction.model } : {},
+		...finishReason ? { finishReason } : {},
+		...synthesized,
+		...builtInToolSteps.length > 0 ? { interactionSteps: builtInToolSteps } : {},
+		interaction: {
+			...interaction.id ? { id: interaction.id } : {},
+			...interaction.status ? { status: interaction.status } : {},
+			...interaction.role ? { role: interaction.role } : {},
+			...interaction.previous_interaction_id ? { previous_interaction_id: interaction.previous_interaction_id } : {}
+		}
+	};
+	const additionalKwargs = {
+		...finishReason ? { finishReason } : {},
+		...originalTextContentBlock ? { originalTextContentBlock } : {}
+	};
+	return {
+		message: new _langchain_core_messages.AIMessage({
+			content,
+			tool_calls: toolCalls,
+			additional_kwargs: additionalKwargs,
+			usage_metadata: usageMetadata,
+			response_metadata: responseMetadata
+		}),
+		finishReason,
+		usageMetadata
+	};
+}
+exports.convertGeminiPartToInteractionsContent = convertGeminiPartToInteractionsContent;
+exports.convertInteractionToAIMessage = convertInteractionToAIMessage;
+exports.convertInteractionsContentToGeminiPart = convertInteractionsContentToGeminiPart;
+exports.convertInteractionsUsageToUsageMetadata = convertInteractionsUsageToUsageMetadata;
+exports.convertMessagesToInteractionsInput = convertMessagesToInteractionsInput;
+exports.convertMessagesToInteractionsSystemInstruction = convertMessagesToInteractionsSystemInstruction;
+exports.normalizeInteractionStep = normalizeInteractionStep;
+exports.synthesizeMetadataFromInteractions = synthesizeMetadataFromInteractions;
+
+//# sourceMappingURL=messages.cjs.map