@librechat/agents 3.2.32 → 3.2.34

package/dist/esm/messages/cache.mjs

@@ -1,463 +1,352 @@
-import { BaseMessage, ToolMessage, SystemMessage, HumanMessage, AIMessage } from '@langchain/core/messages';
-import { toLangChainContent } from './langchain.mjs';
-import { ContentTypes } from '../common/enum.mjs';
-import { withMessageRole } from './format.mjs';
-
+import "../common/enum.mjs";
+import { toLangChainContent } from "./langchain.mjs";
+import { withMessageRole } from "./format.mjs";
+import { AIMessage, BaseMessage, HumanMessage, SystemMessage, ToolMessage } from "@langchain/core/messages";
+//#region src/messages/cache.ts
 /**
- * Deep clones a message's content to prevent mutation of the original.
- */
+* Deep clones a message's content to prevent mutation of the original.
+*/
 function deepCloneContent(content) {
-    if (typeof content === 'string') {
-        return content;
-    }
-    if (Array.isArray(content)) {
-        return content.map((block) => ({ ...block }));
-    }
-    return content;
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) return content.map((block) => ({ ...block }));
+	return content;
 }
 /**
- * Clones a message with new content. For LangChain BaseMessage instances,
- * constructs a proper class instance so that `instanceof` checks are preserved
- * in downstream code (e.g., ensureThinkingBlockInMessages).
- * For plain objects (AnthropicMessage), uses object spread.
- */
+* Clones a message with new content. For LangChain BaseMessage instances,
+* constructs a proper class instance so that `instanceof` checks are preserved
+* in downstream code (e.g., ensureThinkingBlockInMessages).
+* For plain objects (AnthropicMessage), uses object spread.
+*/
 function cloneMessage(message, content) {
-    if (message instanceof BaseMessage) {
-        const baseParams = {
-            content: toLangChainContent(content),
-            additional_kwargs: { ...message.additional_kwargs },
-            response_metadata: { ...message.response_metadata },
-            id: message.id,
-            name: message.name,
-        };
-        const msgType = message.getType();
-        switch (msgType) {
-            case 'ai':
-                return withMessageRole(new AIMessage({
-                    ...baseParams,
-                    tool_calls: message.tool_calls,
-                }), 'assistant');
-            case 'human':
-                return withMessageRole(new HumanMessage(baseParams), 'user');
-            case 'system':
-                return withMessageRole(new SystemMessage(baseParams), 'system');
-            case 'tool':
-                return withMessageRole(new ToolMessage({
-                    ...baseParams,
-                    tool_call_id: message.tool_call_id,
-                }), 'tool');
-        }
-    }
-    const { lc_kwargs: _lc_kwargs, lc_serializable: _lc_serializable, lc_namespace: _lc_namespace, ...rest } = message;
-    const cloned = { ...rest, content };
-    // LangChain messages don't have a direct 'role' property - derive it from getType()
-    if ('getType' in message &&
-        typeof message.getType === 'function' &&
-        !('role' in cloned)) {
-        const msgType = message.getType();
-        const roleMap = {
-            human: 'user',
-            ai: 'assistant',
-            system: 'system',
-            tool: 'tool',
-        };
-        cloned.role = roleMap[msgType] || msgType;
-    }
-    return cloned;
+	if (message instanceof BaseMessage) {
+		const baseParams = {
+			content: toLangChainContent(content),
+			additional_kwargs: { ...message.additional_kwargs },
+			response_metadata: { ...message.response_metadata },
+			id: message.id,
+			name: message.name
+		};
+		switch (message.getType()) {
+			case "ai": return withMessageRole(new AIMessage({
+				...baseParams,
+				tool_calls: message.tool_calls
+			}), "assistant");
+			case "human": return withMessageRole(new HumanMessage(baseParams), "user");
+			case "system": return withMessageRole(new SystemMessage(baseParams), "system");
+			case "tool": return withMessageRole(new ToolMessage({
+				...baseParams,
+				tool_call_id: message.tool_call_id
+			}), "tool");
+			default: break;
+		}
+	}
+	const { lc_kwargs: _lc_kwargs, lc_serializable: _lc_serializable, lc_namespace: _lc_namespace, ...rest } = message;
+	const cloned = {
+		...rest,
+		content
+	};
+	if ("getType" in message && typeof message.getType === "function" && !("role" in cloned)) {
+		const msgType = message.getType();
+		cloned.role = {
+			human: "user",
+			ai: "assistant",
+			system: "system",
+			tool: "tool"
+		}[msgType] || msgType;
+	}
+	return cloned;
 }
 function stripAnthropicCacheControlFromBlocks(content) {
-    let modified = false;
-    const strippedContent = content.map((block) => {
-        if (!('cache_control' in block)) {
-            return block;
-        }
-        const cloned = { ...block };
-        delete cloned.cache_control;
-        modified = true;
-        return cloned;
-    });
-    return { content: strippedContent, modified };
+	let modified = false;
+	return {
+		content: content.map((block) => {
+			if (!("cache_control" in block)) return block;
+			const cloned = { ...block };
+			delete cloned.cache_control;
+			modified = true;
+			return cloned;
+		}),
+		modified
+	};
 }
 function sanitizeBedrockSystemMessage(message) {
-    const content = message.content;
-    if (!Array.isArray(content)) {
-        return message;
-    }
-    const stripped = stripAnthropicCacheControlFromBlocks(content);
-    if (!stripped.modified) {
-        return message;
-    }
-    return cloneMessage(message, stripped.content);
+	const content = message.content;
+	if (!Array.isArray(content)) return message;
+	const stripped = stripAnthropicCacheControlFromBlocks(content);
+	if (!stripped.modified) return message;
+	return cloneMessage(message, stripped.content);
 }
 /**
- * Anthropic API: Adds cache control to the appropriate user messages in the payload.
- * Strips ALL existing cache control (both Anthropic and Bedrock formats) from all messages,
- * then adds fresh cache control to the last 2 user messages in a single backward pass.
- * This ensures we don't accumulate stale cache points across multiple turns.
- * Returns a new array - only clones messages that require modification.
- * @param messages - The array of message objects.
- * @returns - A new array of message objects with cache control added.
- */
+* Anthropic API: Adds cache control to the appropriate user messages in the payload.
+* Strips ALL existing cache control (both Anthropic and Bedrock formats) from all messages,
+* then adds fresh cache control to the last 2 user messages in a single backward pass.
+* This ensures we don't accumulate stale cache points across multiple turns.
+* Returns a new array - only clones messages that require modification.
+* @param messages - The array of message objects.
+* @returns - A new array of message objects with cache control added.
+*/
 function addCacheControl(messages) {
-    if (!Array.isArray(messages) || messages.length < 2) {
-        return messages;
-    }
-    const updatedMessages = [...messages];
-    let userMessagesModified = 0;
-    for (let i = updatedMessages.length - 1; i >= 0; i--) {
-        const originalMessage = updatedMessages[i];
-        const content = originalMessage.content;
-        const isUserMessage = ('getType' in originalMessage && originalMessage.getType() === 'human') ||
-            ('role' in originalMessage && originalMessage.role === 'user');
-        const hasArrayContent = Array.isArray(content);
-        const needsCacheAdd = userMessagesModified < 2 &&
-            isUserMessage &&
-            !isSyntheticMetaMessage(originalMessage) &&
-            (typeof content === 'string' || hasArrayContent);
-        // Skip messages that don't need any work
-        if (!needsCacheAdd && !hasArrayContent) {
-            continue;
-        }
-        let workingContent;
-        let modified = false;
-        if (hasArrayContent) {
-            // Single pass: clone blocks, strip cache markers and cache points,
-            // find last text block index for cache insertion — all at once.
-            const src = content;
-            workingContent = [];
-            let lastTextIndex = -1;
-            for (let j = 0; j < src.length; j++) {
-                const block = src[j];
-                if (isCachePoint(block)) {
-                    modified = true;
-                    continue; // skip cache point blocks
-                }
-                const cloned = { ...block };
-                if ('cache_control' in cloned) {
-                    delete cloned.cache_control;
-                    modified = true;
-                }
-                if ('type' in cloned && cloned.type === 'text') {
-                    lastTextIndex = workingContent.length;
-                }
-                workingContent.push(cloned);
-            }
-            if (!modified && !needsCacheAdd) {
-                continue; // nothing to strip and no cache to add
-            }
-            // Add cache control to the last text block for user messages
-            if (needsCacheAdd && lastTextIndex >= 0) {
-                workingContent[lastTextIndex].cache_control = {
-                    type: 'ephemeral',
-                };
-                userMessagesModified++;
-            }
-        }
-        else if (typeof content === 'string' && needsCacheAdd) {
-            workingContent = [
-                { type: 'text', text: content, cache_control: { type: 'ephemeral' } },
-            ];
-            userMessagesModified++;
-        }
-        else {
-            continue;
-        }
-        updatedMessages[i] = cloneMessage(originalMessage, workingContent);
-    }
-    return updatedMessages;
+	if (!Array.isArray(messages) || messages.length < 2) return messages;
+	const updatedMessages = [...messages];
+	let userMessagesModified = 0;
+	for (let i = updatedMessages.length - 1; i >= 0; i--) {
+		const originalMessage = updatedMessages[i];
+		const content = originalMessage.content;
+		const isUserMessage = "getType" in originalMessage && originalMessage.getType() === "human" || "role" in originalMessage && originalMessage.role === "user";
+		const hasArrayContent = Array.isArray(content);
+		const needsCacheAdd = userMessagesModified < 2 && isUserMessage && !isSyntheticMetaMessage(originalMessage) && (typeof content === "string" || hasArrayContent);
+		if (!needsCacheAdd && !hasArrayContent) continue;
+		let workingContent;
+		let modified = false;
+		if (hasArrayContent) {
+			const src = content;
+			workingContent = [];
+			let lastTextIndex = -1;
+			for (let j = 0; j < src.length; j++) {
+				const block = src[j];
+				if (isCachePoint(block)) {
+					modified = true;
+					continue;
+				}
+				const cloned = { ...block };
+				if ("cache_control" in cloned) {
+					delete cloned.cache_control;
+					modified = true;
+				}
+				if ("type" in cloned && cloned.type === "text") lastTextIndex = workingContent.length;
+				workingContent.push(cloned);
+			}
+			if (!modified && !needsCacheAdd) continue;
+			if (needsCacheAdd && lastTextIndex >= 0) {
+				workingContent[lastTextIndex].cache_control = { type: "ephemeral" };
+				userMessagesModified++;
+			}
+		} else if (typeof content === "string" && needsCacheAdd) {
+			workingContent = [{
+				type: "text",
+				text: content,
+				cache_control: { type: "ephemeral" }
+			}];
+			userMessagesModified++;
+		} else continue;
+		updatedMessages[i] = cloneMessage(originalMessage, workingContent);
+	}
+	return updatedMessages;
 }
 /**
- * Checks if a content block is a cache point
- */
+* Checks if a content block is a cache point
+*/
 function isCachePoint(block) {
-    return 'cachePoint' in block && !('type' in block);
+	return "cachePoint" in block && !("type" in block);
 }
 function getMessageRole(message) {
-    if (message instanceof BaseMessage) {
-        return message.getType();
-    }
-    if ('role' in message && typeof message.role === 'string') {
-        return message.role;
-    }
-    return undefined;
+	if (message instanceof BaseMessage) return message.getType();
+	if ("role" in message && typeof message.role === "string") return message.role;
 }
-const SKILL_MESSAGE_SOURCE = 'skill';
+const SKILL_MESSAGE_SOURCE = "skill";
 /**
- * Synthetic skill/meta messages (reconstructed skill bodies, primed SKILL.md
- * instructions) are re-injected every turn and are not stable conversation
- * turns. They must not anchor a fresh prompt-cache marker — doing so pins the
- * cache to a volatile/duplicated prefix. Stale markers are still stripped from
- * them; only the *adding* of new markers is suppressed. Detected via
- * `additional_kwargs.isMeta === true` or `additional_kwargs.source === 'skill'`.
- */
+* Synthetic skill/meta messages (reconstructed skill bodies, primed SKILL.md
+* instructions) are re-injected every turn and are not stable conversation
+* turns. They must not anchor a fresh prompt-cache marker — doing so pins the
+* cache to a volatile/duplicated prefix. Stale markers are still stripped from
+* them; only the *adding* of new markers is suppressed. Detected via
+* `additional_kwargs.isMeta === true` or `additional_kwargs.source === 'skill'`.
+*/
 function isSyntheticMetaMessage(message) {
-    const { additional_kwargs: kwargs } = message;
-    if (kwargs == null) {
-        return false;
-    }
-    return kwargs.isMeta === true || kwargs.source === SKILL_MESSAGE_SOURCE;
+	const { additional_kwargs: kwargs } = message;
+	if (kwargs == null) return false;
+	return kwargs.isMeta === true || kwargs.source === SKILL_MESSAGE_SOURCE;
 }
 function isCacheableConversationMessage(message) {
-    const role = getMessageRole(message);
-    return (role === 'human' || role === 'user' || role === 'ai' || role === 'assistant');
+	const role = getMessageRole(message);
+	return role === "human" || role === "user" || role === "ai" || role === "assistant";
 }
 function isAssistantConversationMessage(message) {
-    const role = getMessageRole(message);
-    return role === 'ai' || role === 'assistant';
+	const role = getMessageRole(message);
+	return role === "ai" || role === "assistant";
 }
 function hasCacheMarker(message) {
-    return (Array.isArray(message.content) &&
-        message.content.some((block) => 'cache_control' in block));
+	return Array.isArray(message.content) && message.content.some((block) => "cache_control" in block);
 }
 function addCacheControlToRecentMessages(messages, maxCachePoints, canUseMessage) {
-    if (!Array.isArray(messages) ||
-        messages.length === 0 ||
-        maxCachePoints <= 0) {
-        return messages;
-    }
-    const updatedMessages = [...messages];
-    let cachePointsAdded = 0;
-    for (let i = updatedMessages.length - 1; i >= 0; i--) {
-        const originalMessage = updatedMessages[i];
-        const content = originalMessage.content;
-        const hasArrayContent = Array.isArray(content);
-        const canAddCache = cachePointsAdded < maxCachePoints &&
-            canUseMessage(originalMessage) &&
-            !isSyntheticMetaMessage(originalMessage);
-        if (!canAddCache && !hasArrayContent) {
-            continue;
-        }
-        let workingContent;
-        let modified = false;
-        if (hasArrayContent) {
-            const src = content;
-            workingContent = [];
-            let lastNonEmptyTextIndex = -1;
-            for (let j = 0; j < src.length; j++) {
-                const block = src[j];
-                if (isCachePoint(block)) {
-                    modified = true;
-                    continue;
-                }
-                const cloned = { ...block };
-                if ('cache_control' in cloned) {
-                    delete cloned.cache_control;
-                    modified = true;
-                }
-                if ('type' in cloned && cloned.type === 'text') {
-                    const text = cloned.text;
-                    if (text != null && text.trim() !== '') {
-                        lastNonEmptyTextIndex = workingContent.length;
-                    }
-                }
-                workingContent.push(cloned);
-            }
-            if (canAddCache && lastNonEmptyTextIndex >= 0) {
-                workingContent[lastNonEmptyTextIndex].cache_control = {
-                    type: 'ephemeral',
-                };
-                cachePointsAdded++;
-                modified = true;
-            }
-            if (!modified) {
-                continue;
-            }
-        }
-        else if (typeof content === 'string' &&
-            content.trim() !== '' &&
-            canAddCache) {
-            workingContent = [
-                { type: 'text', text: content, cache_control: { type: 'ephemeral' } },
-            ];
-            cachePointsAdded++;
-        }
-        else {
-            continue;
-        }
-        updatedMessages[i] = cloneMessage(originalMessage, workingContent);
-    }
-    return updatedMessages;
+	if (!Array.isArray(messages) || messages.length === 0 || maxCachePoints <= 0) return messages;
+	const updatedMessages = [...messages];
+	let cachePointsAdded = 0;
+	for (let i = updatedMessages.length - 1; i >= 0; i--) {
+		const originalMessage = updatedMessages[i];
+		const content = originalMessage.content;
+		const hasArrayContent = Array.isArray(content);
+		const canAddCache = cachePointsAdded < maxCachePoints && canUseMessage(originalMessage) && !isSyntheticMetaMessage(originalMessage);
+		if (!canAddCache && !hasArrayContent) continue;
+		let workingContent;
+		let modified = false;
+		if (hasArrayContent) {
+			const src = content;
+			workingContent = [];
+			let lastNonEmptyTextIndex = -1;
+			for (let j = 0; j < src.length; j++) {
+				const block = src[j];
+				if (isCachePoint(block)) {
+					modified = true;
+					continue;
+				}
+				const cloned = { ...block };
+				if ("cache_control" in cloned) {
+					delete cloned.cache_control;
+					modified = true;
+				}
+				if ("type" in cloned && cloned.type === "text") {
+					const text = cloned.text;
+					if (text != null && text.trim() !== "") lastNonEmptyTextIndex = workingContent.length;
+				}
+				workingContent.push(cloned);
+			}
+			if (canAddCache && lastNonEmptyTextIndex >= 0) {
+				workingContent[lastNonEmptyTextIndex].cache_control = { type: "ephemeral" };
+				cachePointsAdded++;
+				modified = true;
+			}
+			if (!modified) continue;
+		} else if (typeof content === "string" && content.trim() !== "" && canAddCache) {
+			workingContent = [{
+				type: "text",
+				text: content,
+				cache_control: { type: "ephemeral" }
+			}];
+			cachePointsAdded++;
+		} else continue;
+		updatedMessages[i] = cloneMessage(originalMessage, workingContent);
+	}
+	return updatedMessages;
 }
 function addCacheControlToStablePrefixMessages(messages, maxCachePoints) {
-    const assistantMarked = addCacheControlToRecentMessages(messages, maxCachePoints, isAssistantConversationMessage);
-    if (assistantMarked.some(hasCacheMarker)) {
-        return assistantMarked;
-    }
-    return addCacheControlToRecentMessages(messages, maxCachePoints, isCacheableConversationMessage);
+	const assistantMarked = addCacheControlToRecentMessages(messages, maxCachePoints, isAssistantConversationMessage);
+	if (assistantMarked.some(hasCacheMarker)) return assistantMarked;
+	return addCacheControlToRecentMessages(messages, maxCachePoints, isCacheableConversationMessage);
 }
 /**
- * Checks if a message's content has Anthropic cache_control fields.
- */
+* Checks if a message's content has Anthropic cache_control fields.
+*/
 function hasAnthropicCacheControl(content) {
-    for (let i = 0; i < content.length; i++) {
-        if ('cache_control' in content[i])
-            return true;
-    }
-    return false;
+	for (let i = 0; i < content.length; i++) if ("cache_control" in content[i]) return true;
+	return false;
 }
 /**
- * Removes all Anthropic cache_control fields from messages
- * Used when switching from Anthropic to Bedrock provider
- * Returns a new array - only clones messages that require modification.
- */
+* Removes all Anthropic cache_control fields from messages
+* Used when switching from Anthropic to Bedrock provider
+* Returns a new array - only clones messages that require modification.
+*/
 function stripAnthropicCacheControl(messages) {
-    if (!Array.isArray(messages)) {
-        return messages;
-    }
-    const updatedMessages = [...messages];
-    for (let i = 0; i < updatedMessages.length; i++) {
-        const originalMessage = updatedMessages[i];
-        const content = originalMessage.content;
-        if (!Array.isArray(content) || !hasAnthropicCacheControl(content)) {
-            continue;
-        }
-        const clonedContent = deepCloneContent(content);
-        for (let j = 0; j < clonedContent.length; j++) {
-            const block = clonedContent[j];
-            if ('cache_control' in block) {
-                delete block.cache_control;
-            }
-        }
-        updatedMessages[i] = cloneMessage(originalMessage, clonedContent);
-    }
-    return updatedMessages;
+	if (!Array.isArray(messages)) return messages;
+	const updatedMessages = [...messages];
+	for (let i = 0; i < updatedMessages.length; i++) {
+		const originalMessage = updatedMessages[i];
+		const content = originalMessage.content;
+		if (!Array.isArray(content) || !hasAnthropicCacheControl(content)) continue;
+		const clonedContent = deepCloneContent(content);
+		for (let j = 0; j < clonedContent.length; j++) {
+			const block = clonedContent[j];
+			if ("cache_control" in block) delete block.cache_control;
+		}
+		updatedMessages[i] = cloneMessage(originalMessage, clonedContent);
+	}
+	return updatedMessages;
 }
 /**
- * Checks if a message's content has Bedrock cachePoint blocks.
- */
+* Checks if a message's content has Bedrock cachePoint blocks.
+*/
 function hasBedrockCachePoint(content) {
-    for (let i = 0; i < content.length; i++) {
-        if (isCachePoint(content[i]))
-            return true;
-    }
-    return false;
+	for (let i = 0; i < content.length; i++) if (isCachePoint(content[i])) return true;
+	return false;
 }
 /**
- * Removes all Bedrock cachePoint blocks from messages
- * Used when switching from Bedrock to Anthropic provider
- * Returns a new array - only clones messages that require modification.
- */
+* Removes all Bedrock cachePoint blocks from messages
+* Used when switching from Bedrock to Anthropic provider
+* Returns a new array - only clones messages that require modification.
+*/
 function stripBedrockCacheControl(messages) {
-    if (!Array.isArray(messages)) {
-        return messages;
-    }
-    const updatedMessages = [...messages];
-    for (let i = 0; i < updatedMessages.length; i++) {
-        const originalMessage = updatedMessages[i];
-        const content = originalMessage.content;
-        if (!Array.isArray(content) || !hasBedrockCachePoint(content)) {
-            continue;
-        }
-        const clonedContent = deepCloneContent(content).filter((block) => !isCachePoint(block));
-        updatedMessages[i] = cloneMessage(originalMessage, clonedContent);
-    }
-    return updatedMessages;
+	if (!Array.isArray(messages)) return messages;
+	const updatedMessages = [...messages];
+	for (let i = 0; i < updatedMessages.length; i++) {
+		const originalMessage = updatedMessages[i];
+		const content = originalMessage.content;
+		if (!Array.isArray(content) || !hasBedrockCachePoint(content)) continue;
+		updatedMessages[i] = cloneMessage(originalMessage, deepCloneContent(content).filter((block) => !isCachePoint(block)));
+	}
+	return updatedMessages;
 }
 /**
- * Adds Bedrock Converse API cache points to the latest two user messages.
- * Inserts `{ cachePoint: { type: 'default' } }` as a separate content block
- * immediately after the last text block in each targeted message.
- * Strips ALL existing cache control (both Bedrock and Anthropic formats) from all messages,
- * then adds fresh cache points to the latest two non-tool user messages in a single backward pass.
- * This ensures we don't accumulate stale cache points across multiple turns.
- * Returns a new array - only clones messages that require modification.
- * @param messages - The array of message objects.
- * @returns - A new array of message objects with cache points added.
- */
+* Adds Bedrock Converse API cache points to the latest two user messages.
+* Inserts `{ cachePoint: { type: 'default' } }` as a separate content block
+* immediately after the last text block in each targeted message.
+* Strips ALL existing cache control (both Bedrock and Anthropic formats) from all messages,
+* then adds fresh cache points to the latest two non-tool user messages in a single backward pass.
+* This ensures we don't accumulate stale cache points across multiple turns.
+* Returns a new array - only clones messages that require modification.
+* @param messages - The array of message objects.
+* @returns - A new array of message objects with cache points added.
+*/
 function addBedrockCacheControl(messages) {
-    if (!Array.isArray(messages) || messages.length === 0) {
-        return messages;
-    }
-    const updatedMessages = [...messages];
-    let cachePointsAdded = 0;
-    for (let i = updatedMessages.length - 1; i >= 0; i--) {
-        const originalMessage = updatedMessages[i];
-        const messageType = 'getType' in originalMessage &&
-            typeof originalMessage.getType === 'function'
-            ? originalMessage.getType()
-            : undefined;
-        const messageRole = 'role' in originalMessage && typeof originalMessage.role === 'string'
-            ? originalMessage.role
-            : undefined;
-        const isSystemMessage = messageType === 'system' || messageRole === 'system';
-        if (isSystemMessage) {
-            updatedMessages[i] = sanitizeBedrockSystemMessage(originalMessage);
-            continue;
-        }
-        const isToolMessage = messageType === 'tool' || messageRole === 'tool';
-        const isUserMessage = messageType === 'human' || messageRole === 'user';
-        const content = originalMessage.content;
-        const hasSerializationProps = 'lc_kwargs' in originalMessage ||
-            'lc_serializable' in originalMessage ||
-            'lc_namespace' in originalMessage;
-        const hasArrayContent = Array.isArray(content);
-        const isEmptyString = typeof content === 'string' && content === '';
-        const needsCacheAdd = cachePointsAdded < 2 &&
-            isUserMessage &&
-            !isToolMessage &&
-            !isEmptyString &&
-            !isSyntheticMetaMessage(originalMessage) &&
-            (typeof content === 'string' || hasArrayContent);
-        if (!needsCacheAdd && !hasArrayContent && !hasSerializationProps) {
-            continue;
-        }
-        let workingContent;
-        let modified = hasSerializationProps;
-        if (hasArrayContent) {
-            // Single pass: clone blocks, strip cache markers, find last
-            // non-empty text block for cache point insertion — all at once.
-            const src = content;
-            workingContent = [];
-            let lastNonEmptyTextIndex = -1;
-            for (let j = 0; j < src.length; j++) {
-                const block = src[j];
-                if (isCachePoint(block)) {
-                    modified = true;
-                    continue;
-                }
-                const cloned = { ...block };
-                if ('cache_control' in cloned) {
-                    delete cloned.cache_control;
-                    modified = true;
-                }
-                const type = cloned.type;
-                if (type === ContentTypes.TEXT || type === 'text') {
-                    const text = cloned.text;
-                    if (text != null && text.trim() !== '') {
-                        lastNonEmptyTextIndex = workingContent.length;
-                    }
-                }
-                workingContent.push(cloned);
-            }
-            if (!modified && !needsCacheAdd) {
-                continue;
-            }
-            // Insert cache point after the last non-empty text block.
-            // Skip if no cacheable text content exists (whitespace-only messages).
-            if (needsCacheAdd && lastNonEmptyTextIndex >= 0) {
-                workingContent.splice(lastNonEmptyTextIndex + 1, 0, {
-                    cachePoint: { type: 'default' },
-                });
-                cachePointsAdded++;
-            }
-        }
-        else if (typeof content === 'string' && needsCacheAdd) {
-            workingContent = [
-                { type: ContentTypes.TEXT, text: content },
-                { cachePoint: { type: 'default' } },
-            ];
-            cachePointsAdded++;
-        }
-        else if (typeof content === 'string' && hasSerializationProps) {
-            workingContent = content;
-        }
-        else {
-            continue;
-        }
-        updatedMessages[i] = cloneMessage(originalMessage, workingContent);
-    }
-    return updatedMessages;
+	if (!Array.isArray(messages) || messages.length === 0) return messages;
+	const updatedMessages = [...messages];
+	let cachePointsAdded = 0;
+	for (let i = updatedMessages.length - 1; i >= 0; i--) {
+		const originalMessage = updatedMessages[i];
+		const messageType = "getType" in originalMessage && typeof originalMessage.getType === "function" ? originalMessage.getType() : void 0;
+		const messageRole = "role" in originalMessage && typeof originalMessage.role === "string" ? originalMessage.role : void 0;
+		if (messageType === "system" || messageRole === "system") {
+			updatedMessages[i] = sanitizeBedrockSystemMessage(originalMessage);
+			continue;
+		}
+		const isToolMessage = messageType === "tool" || messageRole === "tool";
+		const isUserMessage = messageType === "human" || messageRole === "user";
+		const content = originalMessage.content;
+		const hasSerializationProps = "lc_kwargs" in originalMessage || "lc_serializable" in originalMessage || "lc_namespace" in originalMessage;
+		const hasArrayContent = Array.isArray(content);
+		const needsCacheAdd = cachePointsAdded < 2 && isUserMessage && !isToolMessage && !(typeof content === "string" && content === "") && !isSyntheticMetaMessage(originalMessage) && (typeof content === "string" || hasArrayContent);
+		if (!needsCacheAdd && !hasArrayContent && !hasSerializationProps) continue;
+		let workingContent;
+		let modified = hasSerializationProps;
+		if (hasArrayContent) {
+			const src = content;
+			workingContent = [];
+			let lastNonEmptyTextIndex = -1;
+			for (let j = 0; j < src.length; j++) {
+				const block = src[j];
+				if (isCachePoint(block)) {
+					modified = true;
+					continue;
+				}
+				const cloned = { ...block };
+				if ("cache_control" in cloned) {
+					delete cloned.cache_control;
+					modified = true;
+				}
+				const type = cloned.type;
+				if (type === "text" || type === "text") {
+					const text = cloned.text;
+					if (text != null && text.trim() !== "") lastNonEmptyTextIndex = workingContent.length;
+				}
+				workingContent.push(cloned);
+			}
+			if (!modified && !needsCacheAdd) continue;
+			if (needsCacheAdd && lastNonEmptyTextIndex >= 0) {
+				workingContent.splice(lastNonEmptyTextIndex + 1, 0, { cachePoint: { type: "default" } });
+				cachePointsAdded++;
+			}
+		} else if (typeof content === "string" && needsCacheAdd) {
+			workingContent = [{
+				type: "text",
+				text: content
+			}, { cachePoint: { type: "default" } }];
+			cachePointsAdded++;
+		} else if (typeof content === "string" && hasSerializationProps) workingContent = content;
+		else continue;
+		updatedMessages[i] = cloneMessage(originalMessage, workingContent);
+	}
+	return updatedMessages;
 }
-
+//#endregion
 export { addBedrockCacheControl, addCacheControl, addCacheControlToStablePrefixMessages, stripAnthropicCacheControl, stripBedrockCacheControl };
-//# sourceMappingURL=cache.mjs.map
+
+//# sourceMappingURL=cache.mjs.map