@librechat/agents 3.4.6 → 3.5.0

package/dist/esm/messages/format.mjs

@@ -7,12 +7,6 @@ import { normalizeAnthropicToolCallId } from "../llm/anthropic/utils/message_inp
 import { emitAgentLog } from "../utils/events.mjs";
 import { AIMessage, AIMessageChunk, HumanMessage, SystemMessage, ToolMessage } from "@langchain/core/messages";
 //#region src/messages/format.ts
-/**
-* Formats a message with media content (images, documents, videos, audios) to API payload format.
-*
-* @param params - The parameters for formatting.
-* @returns - The formatted message.
-*/
 const formatMediaMessage = ({ message, endpoint, mediaParts }) => {
 	const result = {
 		...message,
@@ -42,12 +36,6 @@ function withMessageRole(message, role) {
 	});
 	return roleMessage;
 }
-/**
-* Formats a message to OpenAI payload format based on the provided options.
-*
-* @param params - The parameters for formatting.
-* @returns - The formatted message.
-*/
 const formatMessage = ({ message, userName, endpoint, assistantName, langChain = false }) => {
 	let { role: _role, _name, sender, text, content: _content, lc_id } = message;
 	if (lc_id && lc_id[2] && !langChain) _role = {
@@ -90,13 +78,6 @@ const formatMessage = ({ message, userName, endpoint, assistantName, langChain =
 	else if (role === "assistant") return withMessageRole(new AIMessage(toLangChainMessageFields(formattedMessage)), "assistant");
 	else return withMessageRole(new SystemMessage(toLangChainMessageFields(formattedMessage)), "system");
 };
-/**
-* Formats an array of messages for LangChain.
-*
-* @param messages - The array of messages to format.
-* @param formatOptions - The options for formatting each message.
-* @returns - The array of formatted LangChain messages.
-*/
 const formatLangChainMessages = (messages, formatOptions) => {
 	return messages.map((msg) => {
 		return formatMessage({
@@ -106,12 +87,6 @@ const formatLangChainMessages = (messages, formatOptions) => {
 		});
 	});
 };
-/**
-* Formats a LangChain message object by merging properties from `lc_kwargs` or `kwargs` and `additional_kwargs`.
-*
-* @param message - The message object to format.
-* @returns - The formatted LangChain message.
-*/
 const formatFromLangChain = (message) => {
 	const { additional_kwargs = {}, ...message_kwargs } = message.lc_kwargs ?? message.kwargs ?? {};
 	return {
@@ -181,25 +156,11 @@ function formatToolCallOutput(output) {
 	if (output == null) return "";
 	return compactToolContent(output, HARD_MAX_TOOL_RESULT_CHARS).content;
 }
-/**
-* Content for the synthetic assistant turn that separates a trailing steer
-* from the next user turn. Non-empty by necessity — see the push site.
-*/
 const STEER_ANCHOR_PLACEHOLDER = "_";
-/**
-* True when an assistant message replayed as a steer and nothing followed it,
-* so the emitted run ends on the steer's `HumanMessage`.
-*/
 function endsWithSteerMessage(formatted) {
 	if (formatted.length === 0) return false;
 	return formatted[formatted.length - 1].additional_kwargs.source === "steer";
 }
-/**
-* Helper function to format an assistant message
-* @param message The message to format
-* @param options Optional formatting options
-* @returns Array of formatted messages
-*/
 function formatAssistantMessage(message, options) {
 	const formattedMessages = [];
 	const appendFormattedMessage = (formattedMessage) => {
@@ -355,13 +316,6 @@ function formatAssistantMessage(message, options) {
 					}
 					currentContent = [];
 				} else if (shouldPreserveReasoningContent && pendingReasoningContent) {
-					/**
-					* Reasoning directly preceding a steer has no `currentContent`
-					* flush to consume it and the anchor resets below — emit an anchor
-					* AIMessage now (createAIMessage folds the pending reasoning into
-					* `additional_kwargs.reasoning_content`) or the persisted
-					* assistant reasoning silently vanishes on replay.
-					*/
 					lastAIMessage = createAIMessage("");
 					appendFormattedMessage(lastAIMessage);
 				}
@@ -374,9 +328,6 @@ function formatAssistantMessage(message, options) {
 					}
 				}), "user"));
 				lastAIMessage = null;
-				/** The steer splits the assistant message: the post-steer segment
-				*  starts with fresh reasoning state (pre-steer reasoning was either
-				*  flushed above or intentionally dropped when not preserving). */
 				hasReasoning = false;
 				pendingReasoningContent = "";
 			} else if (part.type === "error" || part.type === "agent_update" || part.type === "summary" || part.type === "activity_label") continue;
@@ -407,13 +358,6 @@ function getSourceMessageId(message) {
 	const normalized = candidate.trim();
 	return normalized.length > 0 ? normalized : void 0;
 }
-/**
-* Keeps the first formatted message backward-compatible with its persisted
-* source id and preserves source correlation on every derived message.
-* Derived ids remain unset so the reducer can assign collision-free identities
-* during its existing pass. This also prevents invented provider-shaped ids
-* from leaking into provider request payloads.
-*/
 function stampSourceMessageIdentity(message, sourceMessageId, derivedIndex = 0) {
 	if (sourceMessageId == null) return;
 	message.additional_kwargs.sourceMessageId = sourceMessageId;
@@ -421,10 +365,6 @@ function stampSourceMessageIdentity(message, sourceMessageId, derivedIndex = 0)
 	message.id = sourceMessageId;
 	message.lc_kwargs.id = sourceMessageId;
 }
-/**
-* Labels all agent content for parallel patterns (fan-out/fan-in)
-* Groups consecutive content by agent and wraps with clear labels
-*/
 function labelAllAgentContent(contentParts, agentIdMap, agentNames) {
 	const result = [];
 	let currentAgentId;
@@ -458,17 +398,11 @@ function labelAllAgentContent(contentParts, agentIdMap, agentNames) {
 	};
 	for (let i = 0; i < contentParts.length; i++) {
 		const part = contentParts[i];
-		/** UI-only progress headers are not agent content and must not disturb
-		*  agent state: a label with no `agentIdMap` entry would otherwise read
-		*  as an agent change and flush the buffer mid-agent, splitting one
-		*  agent's contiguous content into two labeled blocks. Skipped before
-		*  any state transition below (mirrors the transfer path). */
 		if (part.type === "activity_label") continue;
 		const agentId = agentIdMap[i];
 		if (agentId !== currentAgentId && currentAgentId !== void 0) flushAgentBuffer();
 		currentAgentId = agentId;
 		if (part.type === "steer") {
-			/** User speech is never agent content — see the transfer path above. */
 			flushAgentBuffer();
 			result.push(part);
 			continue;
@@ -478,17 +412,6 @@ function labelAllAgentContent(contentParts, agentIdMap, agentNames) {
 	flushAgentBuffer();
 	return result;
 }
-/**
-* Groups content parts by agent and formats them with agent labels
-* This preprocesses multi-agent content to prevent identity confusion
-*
-* @param contentParts - The content parts from a run
-* @param agentIdMap - Map of content part index to agent ID
-* @param agentNames - Optional map of agent ID to display name
-* @param options - Configuration options
-* @param options.labelNonTransferContent - If true, labels all agent transitions (for parallel patterns)
-* @returns Modified content parts with agent labels where appropriate
-*/
 const labelContentByAgent = (contentParts, agentIdMap, agentNames, options) => {
 	if (!agentIdMap || Object.keys(agentIdMap).length === 0) return contentParts;
 	if (options?.labelNonTransferContent === true) return labelAllAgentContent(contentParts, agentIdMap, agentNames);
@@ -529,11 +452,6 @@ const labelContentByAgent = (contentParts, agentIdMap, agentNames, options) => {
 	};
 	for (let i = 0; i < contentParts.length; i++) {
 		const part = contentParts[i];
-		/** UI-only progress headers are not agent content and must not disturb
-		*  agent state: a label with no `agentIdMap` entry would otherwise look
-		*  like an agent change, flushing the buffer and resetting an open
-		*  transfer capture so the transferred agent's following chunks lose
-		*  their frame. Skipped before any state transition below. */
 		if (part.type === "activity_label") continue;
 		const agentId = agentIdMap[i];
 		const isTransferTool = (part.type === "tool_call" && part.tool_call?.name?.startsWith("lc_transfer_to_")) ?? false;
@@ -546,16 +464,6 @@ const labelContentByAgent = (contentParts, agentIdMap, agentNames, options) => {
 			transferToolCallId = part.tool_call?.id;
 			currentAgentId = void 0;
 		} else if (part.type === "steer") {
-			/**
-			* User speech is never agent content: flush the buffer in place and
-			* pass the steer through verbatim so `formatAssistantMessage` replays
-			* it as a user turn. Folding it into a labeled transfer summary would
-			* both drop the user's words and misattribute them to the agent.
-			* The steer also CLOSES any open transfer capture — `flushAgentBuffer`
-			* no-ops on an empty buffer, and leaving the capture live would fold
-			* post-steer agent content into the pre-steer transfer output,
-			* replaying it BEFORE the user's redirect.
-			*/
 			flushAgentBuffer();
 			transferToolCallIndex = void 0;
 			transferToolCallId = void 0;
@@ -566,13 +474,11 @@ const labelContentByAgent = (contentParts, agentIdMap, agentNames, options) => {
 	flushAgentBuffer();
 	return result;
 };
-/** Extracts tool names from a tool_search output JSON string. */
 function extractToolNamesFromSearchOutput(output) {
 	try {
 		const parsed = JSON.parse(output);
 		if (typeof parsed === "object" && parsed !== null && Array.isArray(parsed.tools)) return parsed.tools.map((t) => t.name).filter((name) => typeof name === "string");
 	} catch {
-		/** Output may have warnings prepended, try to find JSON within it */
 		const jsonMatch = output.match(/\{[\s\S]*\}/);
 		if (jsonMatch) try {
 			const parsed = JSON.parse(jsonMatch[0]);
@@ -582,7 +488,6 @@ function extractToolNamesFromSearchOutput(output) {
 	return [];
 }
 function resolveCoverageIndex(coverage, indexBySourceId, summaryMessageIndex) {
-	/** Persisted JSON, so the declared string type is not a runtime guarantee. */
 	if (typeof coverage?.retainedFromMessageId !== "string") return;
 	const retainedFromMessageId = coverage.retainedFromMessageId.trim();
 	if (retainedFromMessageId === "") return;
@@ -591,8 +496,6 @@ function resolveCoverageIndex(coverage, indexBySourceId, summaryMessageIndex) {
 }
 function scanSummaryBlocks(payload) {
 	let boundary;
-	/** Filled as the scan advances, so a coverage lookup only ever resolves to a
-	*  message already passed — no second pass over the payload. */
 	const indexBySourceId = /* @__PURE__ */ new Map();
 	for (let i = 0; i < payload.length; i++) {
 		const message = payload[i];
@@ -626,10 +529,6 @@ function scanSummaryBlocks(payload) {
 }
 function applySummaryBoundary(message, messageIndex, summaryBoundary) {
 	if (!summaryBoundary) return message;
-	/** The boundary names the first retained message, so it is exclusive: that
-	*  message and everything after it — the recency tail included — stays
-	*  verbatim, and only genuinely covered history is dropped. Summary parts on
-	*  surviving messages are filtered later by `formatAssistantMessage`. */
 	if (summaryBoundary.mode === "coverage") return messageIndex < summaryBoundary.messageIndex ? null : message;
 	if (messageIndex < summaryBoundary.messageIndex) return null;
 	if (messageIndex !== summaryBoundary.messageIndex || !Array.isArray(message.content)) return message;
@@ -638,11 +537,6 @@ function applySummaryBoundary(message, messageIndex, summaryBoundary) {
 		content: message.content.slice(summaryBoundary.contentIndex + 1)
 	};
 }
-/**
-* Whether `formatAssistantMessage` filters this part out of the emitted message.
-* Such a part contributes no prompt tokens, so measuring it as zero characters
-* is accurate — it must not be mistaken for content the heuristic cannot see.
-*/
 function isDroppedByFormatting(part) {
 	if (part == null) return true;
 	if (part.type === "summary" || part.type === "error" || part.type === "agent_update" || part.type === "activity_label") return true;
@@ -654,19 +548,6 @@ function measureValueChars(value) {
 	const measured = serializeStructuredValueBounded(value, 0).originalChars;
 	return measured === Number.MAX_SAFE_INTEGER ? HARD_MAX_TOOL_RESULT_CHARS : Math.min(measured, HARD_MAX_TOOL_RESULT_CHARS);
 }
-/**
-* Whether a retained part's whole prompt cost is the text the char heuristic
-* reads, making it safe to represent in a character ratio.
-*
-* An allowlist, not a denylist. Media, resources, and tool calls carry cost that
-* is unrelated to their serialized length — a short image URL nested in
-* `tool_call.output` stands in for a fixed four-figure media charge — and
-* rejecting those case by case has repeatedly missed a nesting level. Listing
-* the two shapes whose characters `contentPartCharLength` actually reads makes
-* every other shape, present or future, ineligible by default: the ratio is
-* skipped and the entry keeps its original count, which prunes early rather than
-* exceeding the window.
-*/
 function isCharRatioEligible(part) {
 	if (part == null) return false;
 	return part.type === "text" || part.type === "thinking";
@@ -677,8 +558,6 @@ function contentPartCharLength(part) {
 	if (typeof record.text === "string") len += record.text.length;
 	if (typeof record.thinking === "string") len += record.thinking.length;
 	len += measureValueChars(record.input);
-	/** Tool calls nest their payload a level down, so measuring only the
-	*  top-level fields scores an entire tool turn as zero characters. */
 	const { tool_call: toolCall } = record;
 	if (toolCall != null && typeof toolCall === "object") {
 		const call = toolCall;
@@ -688,7 +567,6 @@ function contentPartCharLength(part) {
 	}
 	return len;
 }
-/** Extracts the skillName from a skill tool_call's args (string or object). */
 function extractSkillName(args) {
 	let parsed;
 	if (typeof args === "string") try {
@@ -698,33 +576,9 @@ function extractSkillName(args) {
 	const name = parsed?.skillName;
 	return typeof name === "string" && name !== "" ? name : void 0;
 }
-/**
-* Formats an array of messages for LangChain, handling tool calls and creating ToolMessage instances.
-*
-* @param payload - The array of messages to format.
-* @param indexTokenCountMap - Optional map of message indices to token counts.
-* @param tools - Optional set of tool names that are allowed in the request.
-* @param skills - Optional map of skill name to body for reconstructing skill HumanMessages.
-* @param options - Optional formatting options (provider, skipSkillBodyNames).
-* @returns - Object containing formatted messages and updated indexTokenCountMap if provided.
-*/
 const formatAgentMessages = (payload, indexTokenCountMap, tools, skills, options) => {
 	const messages = [];
-	/**
-	* A steer ended the previous payload entry, so the next message emitted —
-	* whichever entry finally produces one — must be separated from it by an
-	* assistant turn. Held rather than emitted so an entry that produces
-	* nothing cannot leave the anchor stranded as the final turn.
-	*/
 	let pendingSteerAnchor = false;
-	/**
-	* Emits the deferred anchor ahead of `next` — the message about to be
-	* pushed. When that message is itself an assistant turn, it already IS the
-	* separation the anchor exists to synthesize, so the intent is simply
-	* discharged: emitting the placeholder anyway would put two assistant turns
-	* back to back, which strict-alternation providers can reject and nothing downstream
-	* repairs (`coalesceAdjacentUserTurns` merges user turns only).
-	*/
 	const flushSteerAnchor = (next) => {
 		if (!pendingSteerAnchor) return;
 		pendingSteerAnchor = false;
@@ -735,11 +589,6 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools, skills, options
 	let boundaryTokenAdjustment;
 	const indexMapping = {};
 	const { boundary: summaryBoundary } = scanSummaryBlocks(payload);
-	/**
-	* Create a mutable copy of the tools set that can be expanded dynamically.
-	* When we encounter tool_search results, we add discovered tools to this set,
-	* making their subsequent tool calls valid.
-	*/
 	const discoveredTools = tools ? new Set(tools) : void 0;
 	for (let i = 0; i < payload.length; i++) {
 		const rawMessage = payload[i];
@@ -772,12 +621,6 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools, skills, options
 			continue;
 		}
 		const startMessageIndex = messages.length;
-		/**
-		* If tools set is provided, process tool_calls:
-		* - Keep valid tool_calls (tools in the set or dynamically discovered)
-		* - Convert invalid tool_calls to string representation for context preservation
-		* - Dynamically expand the set when tool_search results are encountered
-		*/
 		let processedMessage = message;
 		let pendingSkillNames;
 		if (discoveredTools) {
@@ -791,16 +634,11 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools, skills, options
 						filteredContent.push(part);
 						continue;
 					}
-					/** Skip malformed tool_call entries */
 					if (part.tool_call == null || part.tool_call.name == null || part.tool_call.name === "") {
 						if (typeof part.tool_call?.id === "string" && part.tool_call.id !== "") invalidToolCallIds.add(part.tool_call.id);
 						continue;
 					}
 					const toolName = part.tool_call.name;
-					/**
-					* If this is a tool_search result with output, extract discovered tool names
-					* and add them to the discoveredTools set for subsequent validation.
-					*/
 					if (toolName === "tool_search" && typeof part.tool_call.output === "string" && part.tool_call.output !== "") {
 						const extracted = extractToolNamesFromSearchOutput(part.tool_call.output);
 						for (const name of extracted) discoveredTools.add(name);
@@ -812,22 +650,18 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools, skills, options
 							if (skillName) (pendingSkillNames ??= /* @__PURE__ */ new Set()).add(skillName);
 						}
 					} else {
-						/** Invalid tool - convert to string for context preservation */
 						if (typeof part.tool_call.id === "string" && part.tool_call.id !== "") invalidToolCallIds.add(part.tool_call.id);
 						const output = part.tool_call.output ?? "";
 						invalidToolStrings.push(`Tool: ${toolName}, ${output}`);
 					}
 				}
-				/** Remove tool_call_ids references to invalid tools from text parts */
 				if (invalidToolCallIds.size > 0) {
 					for (const part of filteredContent) if (part.type === "text" && Array.isArray(part.tool_call_ids)) {
 						part.tool_call_ids = part.tool_call_ids.filter((id) => !invalidToolCallIds.has(id));
 						if (part.tool_call_ids.length === 0) delete part.tool_call_ids;
 					}
 				}
-				/** Append invalid tool strings to the content for context preservation */
 				if (invalidToolStrings.length > 0) {
-					/** Find the last text part or create one */
 					let lastTextPartIndex = -1;
 					for (let j = filteredContent.length - 1; j >= 0; j--) if (filteredContent[j].type === "text") {
 						lastTextPartIndex = j;
@@ -841,21 +675,17 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools, skills, options
 							...lastTextPart,
 							["text"]: existingText ? `${existingText}\n${invalidToolText}` : invalidToolText
 						};
-					} else
- /** No text part exists, create one */
-					filteredContent.push({
+					} else filteredContent.push({
 						type: "text",
 						["text"]: invalidToolText
 					});
 				}
-				/** Use filtered content if we made any changes */
 				if (filteredContent.length !== content.length || invalidToolStrings.length > 0) processedMessage = {
 					...message,
 					content: filteredContent
 				};
 			}
 		}
-		/** When tools filtering is off, still detect skill tool_calls for body reconstruction */
 		if (!discoveredTools && skills?.size != null && skills.size > 0) {
 			const content = processedMessage.content;
 			if (Array.isArray(content)) for (const part of content) {
@@ -870,41 +700,6 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools, skills, options
 			provider: options?.provider,
 			sourceMessageId
 		});
-		/**
-		* A steer that ends an assistant message leaves the replay on a
-		* `HumanMessage`. The next payload message is itself a user turn, so the
-		* sequence would reach the provider as two adjacent user turns — rejected
-		* by strict-alternation providers. Anchor it with a placeholder assistant
-		* turn.
-		*
-		* The placeholder must be NON-EMPTY. A string-content assistant message
-		* with no tool calls passes through `_convertMessagesToAnthropicPayload`
-		* verbatim — the empty-text repair there only covers array content and
-		* tool-call turns — so an empty anchor would reach Anthropic as
-		* `{role: 'assistant', content: ''}` and trade one invalid sequence for
-		* another. Same single-underscore convention the Anthropic converter
-		* already uses when it has to synthesize a non-empty block.
-		*
-		* Deferred rather than decided by lookahead. `i < payload.length - 1` only
-		* proves a later ENTRY exists, not that it EMITS: entries with empty
-		* content, and entries dropped by `applySummaryBoundary`, are skipped
-		* silently. A trailing steer followed only by those would get the anchor
-		* as the FINAL turn — an assistant prefill with no request after it, which
-		* the model may simply never answer. So the intent is recorded and flushed
-		* only when a message actually follows.
-		*
-		* Pushed AFTER source identity stamping above, deliberately. The anchor is
-		* synthetic rather than derived from the persisted assistant entry, so it
-		* must not claim that entry's source metadata. Left unstamped, it reaches
-		* the reducer with a null id and is assigned a fresh one.
-		* `endsWithSteerMessage` reads only `additional_kwargs.source`, so the
-		* deferral cannot change which messages get anchored.
-		*/
-		/**
-		* Guarded on emission: an assistant entry whose blocks all filtered away
-		* emits nothing, and flushing for it would strand the anchor as the final
-		* turn — the pending flag stays set for whichever entry emits next.
-		*/
 		if (formattedMessages.length > 0) flushSteerAnchor(formattedMessages[0]);
 		messages.push(...formattedMessages);
 		if (endsWithSteerMessage(formattedMessages)) pendingSteerAnchor = true;
@@ -933,52 +728,17 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools, skills, options
 		const resultIndices = indexMapping[originalIndex] || [];
 		let tokenCount = indexTokenCountMap[originalIndex];
 		if (tokenCount === void 0) continue;
-		/**
-		* Coverage mode deliberately leaves the count alone, even though the entry
-		* holding the block is charged for summary text that `formatAssistantMessage`
-		* filters out and `summary.tokenCount` accounts separately.
-		*
-		* Discounting it needs the summary's cost in the same units as
-		* `indexTokenCountMap`, and that figure is not obtainable here: this
-		* function receives no tokenizer, and a count recorded at write time is in
-		* the writing run's units — `Run.create` derives its counter from the model
-		* in play, and a consumer may supply its own — so a conversation continued
-		* on a different model would subtract across encodings. Attempts to proxy
-		* it (character ratios, provider identity) all under-count some shape,
-		* which risks an over-context request; over-counting merely prunes early.
-		* Fixing it properly means passing the reader a tokenizer, which is a
-		* consumer-facing change and out of scope here.
-		*/
 		if (summaryBoundary?.mode === "positional" && originalIndex === summaryBoundary.messageIndex && Array.isArray(payload[originalIndex].content)) {
 			const content = payload[originalIndex].content;
 			const { contentIndex } = summaryBoundary;
 			if (contentIndex >= 0 && contentIndex < content.length - 1) {
 				let totalCharLen = 0;
 				let remainingCharLen = 0;
-				/**
-				* The ratio applies only when *every* part of the entry is one whose
-				* token cost tracks its character length. A single ineligible part
-				* cancels the discount, whichever side of the boundary it sits on.
-				*
-				* Both sides can break it, in opposite directions. A retained image has
-				* its fixed cost scaled away, collapsing the entry. A removed base64
-				* payload inflates the denominator — serializing to a huge length while
-				* the counter charges a fixed estimate — dragging retained text below
-				* its real cost. Either way the request can exceed the window.
-				*
-				* Telling a text-bearing tool payload from a media-bearing one means
-				* recursing into arbitrary nested output, which has already missed a
-				* level twice here. Cancelling instead keeps the original count: an
-				* over-count that prunes early rather than overflowing. Entries of
-				* plain text and reasoning — the common shape — still proportion.
-				*/
 				let everyRetainedPartMeasurable = true;
 				for (let p = 0; p < content.length; p++) {
 					const part = content[p];
 					const retained = p > contentIndex;
 					if (isDroppedByFormatting(part)) {
-						/** Removed summary text is real removed content: it is read as
-						*  plain text and belongs in the denominator. */
 						if (!retained && part.type === "summary") totalCharLen += contentPartCharLength(part);
 						continue;
 					}
@@ -1060,14 +820,6 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools, skills, options
 		boundaryTokenAdjustment
 	};
 };
-/**
-* Adds a value at key 0 for system messages and shifts all key indices by one in an indexTokenCountMap.
-* This is useful when adding a system message at the beginning of a conversation.
-*
-* @param indexTokenCountMap - The original map of message indices to token counts
-* @param instructionsTokenCount - The token count for the system message to add at index 0
-* @returns A new map with the system message at index 0 and all other indices shifted by 1
-*/
 function shiftIndexTokenCountMap(indexTokenCountMap, instructionsTokenCount) {
 	const shiftedMap = {};
 	shiftedMap[0] = instructionsTokenCount;
@@ -1077,7 +829,6 @@ function shiftIndexTokenCountMap(indexTokenCountMap, instructionsTokenCount) {
 	}
 	return shiftedMap;
 }
-/** Checks whether a BaseMessage is a tool-role message. */
 const isToolMessage$1 = (m) => m instanceof ToolMessage || "role" in m && m.role === "tool";
 const PORTABLE_FOLDED_MEDIA_TYPES = new Set(["image", "image_url"]);
 const MAX_FOLDED_BLOCK_CHARS = 8e3;
@@ -1101,11 +852,6 @@ function readFoldedDataProperty(value, key) {
 		return;
 	}
 }
-/**
-* Adds one logical line without first concatenating caller-controlled strings.
-* The shared budget covers every synthetic message emitted by one transform,
-* so many individually bounded blocks cannot build an unbounded aggregate.
-*/
 function appendFoldedLine(textChunks, budget, pieces) {
 	if (budget.remainingChars <= 0) {
 		budget.truncated = true;
@@ -1162,15 +908,9 @@ function appendSyntheticProviderContextMessage(result, parts) {
 	result.push(markSyntheticProviderContext(withMessageRole(new HumanMessage({ content: toLangChainContent(parts) }), "user")));
 	return true;
 }
-/**
-* Identifies provider-context placeholders created by this module without
-* trusting user-controlled content prefixes or leaking marker metadata onto
-* the provider wire.
-*/
 function isSyntheticProviderContextMessage(message) {
 	return syntheticProviderContextMessages.has(message);
 }
-/** Flushes accumulated text chunks into `parts` as a single text block. */
 function flushTextChunks(textChunks, parts) {
 	if (textChunks.length === 0) return;
 	parts.push({
@@ -1179,17 +919,6 @@ function flushTextChunks(textChunks, parts) {
 	});
 	textChunks.length = 0;
 }
-/**
-* Appends a single message's content to the running `textChunks` / `parts`
-* accumulators. Portable image blocks are shallow-copied into `parts` so
-* binary data never becomes text tokens. Provider-specific media/resource
-* blocks are retained as bounded text so a folded cross-provider history
-* cannot contain an unsupported native block or JSON-expand without limit.
-*
-* When `content` is an array containing tool_use blocks, `tool_calls` is NOT
-* additionally serialized (avoiding double output).  `tool_calls` is used as
-* a fallback when `content` is a plain string or an array with no tool_use.
-*/
 function appendMessageContent(msg, role, textChunks, parts, budget) {
 	const { content } = msg;
 	if (typeof content === "string") {
@@ -1316,32 +1045,6 @@ function appendToolCalls(msg, role, textChunks, budget) {
 		]);
 	}
 }
-/**
-* Ensures compatibility when switching from a non-thinking agent to a thinking-enabled agent.
-* Converts AI messages with tool calls (that lack thinking/reasoning blocks) into buffer strings,
-* avoiding the thinking block signature requirement.
-*
-* Recognizes the following as valid thinking/reasoning blocks:
-* - ContentTypes.THINKING (Anthropic)
-* - ContentTypes.REASONING_CONTENT (Bedrock)
-* - ContentTypes.REASONING (VertexAI / Google)
-* - 'redacted_thinking'
-*
-* @param messages - Array of messages to process
-* @param provider - The provider being used (unused but kept for future compatibility)
-* @param config - Optional RunnableConfig for structured agent logging
-* @param runStartIndex - Index in `messages` where the CURRENT run's own
-*   appended AI/Tool messages begin (i.e. anything at this index or later
-*   was just produced by this run's own iterations, not historical
-*   context). When provided, AI messages at or after this index are
-*   never converted to `[Previous agent context]` placeholders — Claude
-*   can validly skip a thinking block before a tool_use (cf. PR #116),
-*   so the agent's own in-run iterations must not be misclassified as
-*   foreign history. Without the signal the function falls back to its
-*   prior heuristic (`chainHasThinkingBlock`), preserving backward
-*   compatibility for callers that don't yet pass the boundary.
-* @returns The messages array with tool sequences converted to buffer strings if necessary
-*/
 function ensureThinkingBlockInMessages(messages, _provider, config, runStartIndex) {
 	if (messages.length === 0) return messages;
 	let lastHumanIndex = -1;
@@ -1406,15 +1109,6 @@ function ensureThinkingBlockInMessages(messages, _provider, config, runStartInde
 	}
 	return result;
 }
-/** Whether a message carries tool content a tool-less agent cannot legally
-*  send. Covers every representation a provider converter will serialize back
-*  into a request: a ToolMessage, parsed `AIMessage.tool_calls`, raw
-*  `additional_kwargs.tool_calls` (OpenAI keeps calls here when the parsed
-*  array is empty), and `tool_use` / `tool_call` / `tool_result` content
-*  blocks (`@langchain/aws` and the Anthropic converter map these to Converse
-*  `toolUse` / `toolResult`). Missing the parent AI message is not just a
-*  passthrough: folding its ToolMessage alone would leave an orphan
-*  `assistant(tool_calls) -> user(...)` sequence. */
 function messageHasToolContent(msg) {
 	if (isToolMessage$1(msg)) return true;
 	const aiMsg = msg;
@@ -1427,37 +1121,11 @@ function messageHasToolContent(msg) {
 	}
 	return false;
 }
-/** Whether a message carries a tool RESULT: a ToolMessage, or a message whose
-*  content includes a `tool_result` block (the shape when a call/result pair is
-*  split as `AIMessage(tool_call)` + `HumanMessage(tool_result)`). Such a result
-*  belongs with the preceding tool call, so it is absorbed into the same fold
-*  and labelled as tool output. */
 function isToolResultMessage(msg) {
 	if (isToolMessage$1(msg)) return true;
 	if (Array.isArray(msg.content)) return msg.content.some((block) => typeof block === "object" && readFoldedDataProperty(block, "type") === "tool_result");
 	return false;
 }
-/**
-* Folds tool_use / tool_result content into plain text for an agent that binds
-* no tools.
-*
-* In a multi-agent graph, a tool-less destination still inherits the prior
-* agent's conversation history, which can contain toolUse/toolResult blocks.
-* Because it binds no tools, the model is invoked with no tool schema — and
-* Bedrock's Converse API rejects any request that carries toolUse/toolResult
-* blocks without a top-level toolConfig ("The toolConfig field must be defined
-* when using toolUse and toolResult content blocks"). Adding a dummy toolConfig
-* is not an option: AWS requires at least one tool, and it would expose a
-* capability the destination was intentionally denied.
-*
-* Each tool-call turn plus its trailing tool results (ToolMessages or
-* `tool_result` content blocks) is collapsed into a single `[Previous tool
-* interaction]` HumanMessage that preserves the tool name, arguments and result
-* as text (image blocks are kept as-is). Runs in a single pass: non-tool
-* messages pass through, `result` is allocated lazily on the first fold, and the
-* original array is returned unchanged when it holds no tool content (the common
-* fresh-tool-less-agent case).
-*/
 function foldToolBlocksForToollessAgent(messages, config) {
 	let result = null;
 	let foldedCount = 0;
@@ -1470,7 +1138,6 @@ function foldToolBlocksForToollessAgent(messages, config) {
 			i++;
 			continue;
 		}
-		/** First fold — copy the untouched prefix once, then append from here. */
 		if (result === null) result = messages.slice(0, i);
 		const parts = [];
 		const textChunks = [];
@@ -1491,17 +1158,6 @@ function foldToolBlocksForToollessAgent(messages, config) {
 	emitAgentLog(config, "warn", "format", `foldToolBlocksForToollessAgent: folded ${foldedCount} tool message(s) into text for a tool-less agent`);
 	return result;
 }
-/**
-* Walks backwards from `currentIndex` through the message array to check
-* whether an earlier AI message in the same "chain" (no HumanMessage boundary)
-* contains a thinking/reasoning block.
-*
-* A "chain" is a contiguous sequence of AI + Tool messages with no intervening
-* HumanMessage. Bedrock reasoning models produce reasoning on the first AI
-* response, then issue follow-up tool calls with `content: ""` and no
-* reasoning block. These follow-ups are part of the same thinking-enabled
-* turn and should not be converted.
-*/
 function chainHasThinkingBlock(messages, currentIndex) {
 	for (let k = currentIndex - 1; k >= 0; k--) {
 		const prev = messages[k];