@librechat/agents 3.2.32 → 3.2.33

package/dist/esm/messages/format.mjs

@@ -1,1456 +1,975 @@
-import { HumanMessage, AIMessage, AIMessageChunk, SystemMessage, ToolMessage } from '@langchain/core/messages';
-import { normalizeAnthropicToolCallId } from '../llm/anthropic/utils/message_inputs.mjs';
-import { toLangChainContent, toLangChainMessageFields } from './langchain.mjs';
-import { ContentTypes, Constants, Providers } from '../common/enum.mjs';
-import { emitAgentLog } from '../utils/events.mjs';
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
+import "../common/enum.mjs";
+import "../common/index.mjs";
+import { toLangChainContent, toLangChainMessageFields } from "./langchain.mjs";
+import { normalizeAnthropicToolCallId } from "../llm/anthropic/utils/message_inputs.mjs";
+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, }) => {
-    // Create a new object to avoid mutating the input
-    const result = {
-        ...message,
-        content: [],
-    };
-    if (endpoint === Providers.ANTHROPIC) {
-        result.content = [
-            ...mediaParts,
-            { type: ContentTypes.TEXT, text: message.content },
-        ];
-        return result;
-    }
-    result.content = [
-        { type: ContentTypes.TEXT, text: message.content },
-        ...mediaParts,
-    ];
-    return result;
+* 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,
+		content: []
+	};
+	if (endpoint === "anthropic") {
+		result.content = [...mediaParts, {
+			type: "text",
+			text: message.content
+		}];
+		return result;
+	}
+	result.content = [{
+		type: "text",
+		text: message.content
+	}, ...mediaParts];
+	return result;
 };
 function withMessageRole(message, role) {
-    const roleMessage = message;
-    if (roleMessage.role === role) {
-        return roleMessage;
-    }
-    Object.defineProperty(roleMessage, 'role', {
-        value: role,
-        writable: true,
-        enumerable: false,
-        configurable: true,
-    });
-    return roleMessage;
+	const roleMessage = message;
+	if (roleMessage.role === role) return roleMessage;
+	Object.defineProperty(roleMessage, "role", {
+		value: role,
+		writable: true,
+		enumerable: false,
+		configurable: true
+	});
+	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, }) => {
-    // eslint-disable-next-line prefer-const
-    let { role: _role, _name, sender, text, content: _content, lc_id } = message;
-    if (lc_id && lc_id[2] && !langChain) {
-        const roleMapping = {
-            SystemMessage: 'system',
-            HumanMessage: 'user',
-            AIMessage: 'assistant',
-        };
-        _role = roleMapping[lc_id[2]] || _role;
-    }
-    const role = _role ??
-        (sender != null && sender && sender.toLowerCase() === 'user'
-            ? 'user'
-            : 'assistant');
-    const content = _content ?? text ?? '';
-    const formattedMessage = {
-        role,
-        content,
-    };
-    // Set name fields first
-    if (_name != null && _name) {
-        formattedMessage.name = _name;
-    }
-    if (userName != null && userName && formattedMessage.role === 'user') {
-        formattedMessage.name = userName;
-    }
-    if (assistantName != null &&
-        assistantName &&
-        formattedMessage.role === 'assistant') {
-        formattedMessage.name = assistantName;
-    }
-    if (formattedMessage.name != null && formattedMessage.name) {
-        // Conform to API regex: ^[a-zA-Z0-9_-]{1,64}$
-        // https://community.openai.com/t/the-format-of-the-name-field-in-the-documentation-is-incorrect/175684/2
-        formattedMessage.name = formattedMessage.name.replace(/[^a-zA-Z0-9_-]/g, '_');
-        if (formattedMessage.name.length > 64) {
-            formattedMessage.name = formattedMessage.name.substring(0, 64);
-        }
-    }
-    const { image_urls, documents, videos, audios } = message;
-    const mediaParts = [];
-    if (Array.isArray(documents) && documents.length > 0) {
-        mediaParts.push(...documents);
-    }
-    if (Array.isArray(videos) && videos.length > 0) {
-        mediaParts.push(...videos);
-    }
-    if (Array.isArray(audios) && audios.length > 0) {
-        mediaParts.push(...audios);
-    }
-    if (Array.isArray(image_urls) && image_urls.length > 0) {
-        mediaParts.push(...image_urls);
-    }
-    if (mediaParts.length > 0 && role === 'user') {
-        const mediaMessage = formatMediaMessage({
-            message: {
-                ...formattedMessage,
-                content: typeof formattedMessage.content === 'string'
-                    ? formattedMessage.content
-                    : '',
-            },
-            mediaParts,
-            endpoint,
-        });
-        if (!langChain) {
-            return mediaMessage;
-        }
-        return withMessageRole(new HumanMessage(toLangChainMessageFields(mediaMessage)), 'user');
-    }
-    if (!langChain) {
-        return formattedMessage;
-    }
-    if (role === 'user') {
-        return withMessageRole(new HumanMessage(toLangChainMessageFields(formattedMessage)), 'user');
-    }
-    else if (role === 'assistant') {
-        return withMessageRole(new AIMessage(toLangChainMessageFields(formattedMessage)), 'assistant');
-    }
-    else {
-        return withMessageRole(new SystemMessage(toLangChainMessageFields(formattedMessage)), 'system');
-    }
+* 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 = {
+		SystemMessage: "system",
+		HumanMessage: "user",
+		AIMessage: "assistant"
+	}[lc_id[2]] || _role;
+	const role = _role ?? (sender != null && sender && sender.toLowerCase() === "user" ? "user" : "assistant");
+	const formattedMessage = {
+		role,
+		content: _content ?? text ?? ""
+	};
+	if (_name != null && _name) formattedMessage.name = _name;
+	if (userName != null && userName && formattedMessage.role === "user") formattedMessage.name = userName;
+	if (assistantName != null && assistantName && formattedMessage.role === "assistant") formattedMessage.name = assistantName;
+	if (formattedMessage.name != null && formattedMessage.name) {
+		formattedMessage.name = formattedMessage.name.replace(/[^a-zA-Z0-9_-]/g, "_");
+		if (formattedMessage.name.length > 64) formattedMessage.name = formattedMessage.name.substring(0, 64);
+	}
+	const { image_urls, documents, videos, audios } = message;
+	const mediaParts = [];
+	if (Array.isArray(documents) && documents.length > 0) mediaParts.push(...documents);
+	if (Array.isArray(videos) && videos.length > 0) mediaParts.push(...videos);
+	if (Array.isArray(audios) && audios.length > 0) mediaParts.push(...audios);
+	if (Array.isArray(image_urls) && image_urls.length > 0) mediaParts.push(...image_urls);
+	if (mediaParts.length > 0 && role === "user") {
+		const mediaMessage = formatMediaMessage({
+			message: {
+				...formattedMessage,
+				content: typeof formattedMessage.content === "string" ? formattedMessage.content : ""
+			},
+			mediaParts,
+			endpoint
+		});
+		if (!langChain) return mediaMessage;
+		return withMessageRole(new HumanMessage(toLangChainMessageFields(mediaMessage)), "user");
+	}
+	if (!langChain) return formattedMessage;
+	if (role === "user") return withMessageRole(new HumanMessage(toLangChainMessageFields(formattedMessage)), "user");
+	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.
- */
+* 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) => {
-        const formatted = formatMessage({
-            ...formatOptions,
-            message: msg,
-            langChain: true,
-        });
-        return formatted;
-    });
+	return messages.map((msg) => {
+		return formatMessage({
+			...formatOptions,
+			message: msg,
+			langChain: true
+		});
+	});
 };
 /**
- * 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.
- */
+* 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 kwargs = message.lc_kwargs ?? message.kwargs ?? {};
-    const { additional_kwargs = {}, ...message_kwargs } = kwargs;
-    return {
-        ...message_kwargs,
-        ...additional_kwargs,
-    };
+	const { additional_kwargs = {}, ...message_kwargs } = message.lc_kwargs ?? message.kwargs ?? {};
+	return {
+		...message_kwargs,
+		...additional_kwargs
+	};
 };
 function extractReasoningContent(part) {
-    if (part == null || typeof part !== 'object') {
-        return '';
-    }
-    if (part.type === ContentTypes.THINK) {
-        const think = part.think;
-        return typeof think === 'string' ? think : '';
-    }
-    if (part.type === ContentTypes.THINKING) {
-        const thinking = part.thinking;
-        return typeof thinking === 'string' ? thinking : '';
-    }
-    if (part.type === ContentTypes.REASONING) {
-        const reasoning = part.reasoning;
-        return typeof reasoning === 'string' ? reasoning : '';
-    }
-    if (part.type === ContentTypes.REASONING_CONTENT) {
-        const reasoningText = part.reasoningText;
-        return typeof reasoningText.text === 'string' ? reasoningText.text : '';
-    }
-    return '';
+	if (part == null || typeof part !== "object") return "";
+	if (part.type === "think") {
+		const think = part.think;
+		return typeof think === "string" ? think : "";
+	}
+	if (part.type === "thinking") {
+		const thinking = part.thinking;
+		return typeof thinking === "string" ? thinking : "";
+	}
+	if (part.type === "reasoning") {
+		const reasoning = part.reasoning;
+		return typeof reasoning === "string" ? reasoning : "";
+	}
+	if (part.type === "reasoning_content") {
+		const reasoningText = part.reasoningText;
+		return typeof reasoningText.text === "string" ? reasoningText.text : "";
+	}
+	return "";
 }
 function parseServerToolInput(args) {
-    if (typeof args === 'string') {
-        try {
-            const parsed = JSON.parse(args);
-            return parsed != null &&
-                typeof parsed === 'object' &&
-                !Array.isArray(parsed)
-                ? parsed
-                : {};
-        }
-        catch {
-            return {};
-        }
-    }
-    return args != null && typeof args === 'object' ? args : {};
+	if (typeof args === "string") try {
+		const parsed = JSON.parse(args);
+		return parsed != null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+	} catch {
+		return {};
+	}
+	return args != null && typeof args === "object" ? args : {};
 }
 function getTextContent(part) {
-    const { text } = part;
-    return typeof text === 'string' ? text : '';
+	const { text } = part;
+	return typeof text === "string" ? text : "";
 }
 function hasMeaningfulAssistantContent(part) {
-    if (part.type === ContentTypes.TEXT) {
-        return getTextContent(part).trim().length > 0;
-    }
-    if (part.type === ContentTypes.TOOL_CALL ||
-        part.type === ContentTypes.ERROR ||
-        part.type === ContentTypes.AGENT_UPDATE ||
-        part.type === ContentTypes.SUMMARY) {
-        return false;
-    }
-    if (part.type === ContentTypes.THINK ||
-        part.type === ContentTypes.THINKING ||
-        part.type === ContentTypes.REASONING ||
-        part.type === ContentTypes.REASONING_CONTENT ||
-        part.type === 'redacted_thinking') {
-        return extractReasoningContent(part).trim().length > 0;
-    }
-    return part.type != null && part.type !== '';
+	if (part.type === "text") return getTextContent(part).trim().length > 0;
+	if (part.type === "tool_call" || part.type === "error" || part.type === "agent_update" || part.type === "summary") return false;
+	if (part.type === "think" || part.type === "thinking" || part.type === "reasoning" || part.type === "reasoning_content" || part.type === "redacted_thinking") return extractReasoningContent(part).trim().length > 0;
+	return part.type != null && part.type !== "";
 }
 function getToolUseId(part) {
-    if (!('tool_use_id' in part) || typeof part.tool_use_id !== 'string') {
-        return undefined;
-    }
-    return part.tool_use_id;
+	if (!("tool_use_id" in part) || typeof part.tool_use_id !== "string") return;
+	return part.tool_use_id;
 }
 function isValidServerToolResult(part) {
-    const toolUseId = getToolUseId(part);
-    if (toolUseId?.startsWith(Constants.ANTHROPIC_SERVER_TOOL_PREFIX) !== true ||
-        !('content' in part)) {
-        return false;
-    }
-    const { content } = part;
-    return (Array.isArray(content) ||
-        (content != null &&
-            typeof content === 'object' &&
-            'type' in content &&
-            content.type === 'web_search_tool_result_error'));
+	if (getToolUseId(part)?.startsWith("srvtoolu_") !== true || !("content" in part)) return false;
+	const { content } = part;
+	return Array.isArray(content) || content != null && typeof content === "object" && "type" in content && content.type === "web_search_tool_result_error";
 }
 function getToolCallId(part) {
-    if (part.type !== ContentTypes.TOOL_CALL) {
-        return undefined;
-    }
-    const id = part.tool_call?.id;
-    return typeof id === 'string' && id !== '' ? id : undefined;
+	if (part.type !== "tool_call") return;
+	const id = part.tool_call?.id;
+	return typeof id === "string" && id !== "" ? id : void 0;
 }
 function hasToolCallOutput(part) {
-    if (part.type !== ContentTypes.TOOL_CALL) {
-        return false;
-    }
-    const output = part.tool_call?.output;
-    return output != null && output !== '';
+	if (part.type !== "tool_call") return false;
+	const output = part.tool_call?.output;
+	return output != null && output !== "";
 }
 /**
- * Helper function to format an assistant message
- * @param message The message to format
- * @param options Optional formatting options
- * @returns Array of formatted messages
- */
+* 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 = [];
-    let currentContent = [];
-    let lastAIMessage = null;
-    let hasReasoning = false;
-    let pendingReasoningContent = '';
-    const emittedServerToolUseIds = new Set();
-    const pendingServerToolUses = new Map();
-    const shouldPreserveReasoningContent = options?.preserveReasoningContent === true;
-    const serverToolResultIds = new Set();
-    const preferredToolCallParts = new Map();
-    const takePendingReasoningContent = () => {
-        if (!shouldPreserveReasoningContent || !pendingReasoningContent) {
-            return undefined;
-        }
-        const reasoningContent = pendingReasoningContent;
-        pendingReasoningContent = '';
-        return reasoningContent;
-    };
-    const createAIMessage = (content) => {
-        const reasoningContent = takePendingReasoningContent();
-        return withMessageRole(new AIMessage({
-            content,
-            ...(reasoningContent != null && {
-                additional_kwargs: { reasoning_content: reasoningContent },
-            }),
-        }), 'assistant');
-    };
-    const attachPendingReasoningContent = (aiMessage) => {
-        const reasoningContent = takePendingReasoningContent();
-        if (reasoningContent == null) {
-            return;
-        }
-        aiMessage.additional_kwargs.reasoning_content =
-            typeof aiMessage.additional_kwargs.reasoning_content === 'string'
-                ? `${aiMessage.additional_kwargs.reasoning_content}${reasoningContent}`
-                : reasoningContent;
-    };
-    const flushPendingServerToolUse = (toolUseId) => {
-        for (const [id, content] of pendingServerToolUses) {
-            pendingServerToolUses.delete(id);
-            if (id === toolUseId) {
-                currentContent.push(content);
-                emittedServerToolUseIds.add(id);
-                return;
-            }
-        }
-    };
-    if (Array.isArray(message.content)) {
-        const contentParts = message.content;
-        for (const part of contentParts) {
-            if (part == null) {
-                continue;
-            }
-            if (isValidServerToolResult(part)) {
-                serverToolResultIds.add(getToolUseId(part) ?? '');
-            }
-            if (options?.provider === Providers.ANTHROPIC) {
-                const toolCallId = getToolCallId(part);
-                if (toolCallId == null) {
-                    continue;
-                }
-                const preferredPart = preferredToolCallParts.get(toolCallId);
-                if (preferredPart == null ||
-                    (!hasToolCallOutput(preferredPart) && hasToolCallOutput(part))) {
-                    preferredToolCallParts.set(toolCallId, part);
-                }
-            }
-        }
-        for (const part of contentParts) {
-            if (part == null) {
-                continue;
-            }
-            const toolUseId = getToolUseId(part);
-            if (toolUseId != null) {
-                const isServerToolResult = isValidServerToolResult(part);
-                if (toolUseId.startsWith(Constants.ANTHROPIC_SERVER_TOOL_PREFIX) &&
-                    !isServerToolResult) {
-                    continue;
-                }
-                flushPendingServerToolUse(toolUseId);
-                if (isServerToolResult) {
-                    currentContent.push(part);
-                    continue;
-                }
-            }
-            else if (hasMeaningfulAssistantContent(part)) {
-                for (const id of pendingServerToolUses.keys()) {
-                    if (!serverToolResultIds.has(id)) {
-                        pendingServerToolUses.delete(id);
-                    }
-                }
-            }
-            if (part.type === ContentTypes.TEXT && part.tool_call_ids) {
-                /*
-                If there's pending content, it needs to be aggregated as a single string to prepare for tool calls.
-                For Anthropic models, the "tool_calls" field on a message is only respected if content is a string.
-                */
-                if (currentContent.length > 0) {
-                    if (currentContent.some((content) => content.type !== ContentTypes.TEXT)) {
-                        currentContent.push(part);
-                        lastAIMessage = createAIMessage(toLangChainContent(currentContent));
-                        formattedMessages.push(lastAIMessage);
-                        currentContent = [];
-                        continue;
-                    }
-                    let content = currentContent.reduce((acc, curr) => {
-                        if (curr.type === ContentTypes.TEXT) {
-                            return `${acc}${getTextContent(curr)}\n`;
-                        }
-                        return acc;
-                    }, '');
-                    content = `${content}\n${getTextContent(part)}`.trim();
-                    lastAIMessage = createAIMessage(content);
-                    formattedMessages.push(lastAIMessage);
-                    currentContent = [];
-                    continue;
-                }
-                // Create a new AIMessage with this text and prepare for tool calls
-                lastAIMessage = createAIMessage(getTextContent(part));
-                formattedMessages.push(lastAIMessage);
-            }
-            else if (part.type === ContentTypes.TOOL_CALL) {
-                // Skip malformed tool call entries without tool_call property
-                if (part.tool_call == null) {
-                    continue;
-                }
-                const toolCallId = getToolCallId(part);
-                if (options?.provider === Providers.ANTHROPIC &&
-                    toolCallId != null &&
-                    preferredToolCallParts.get(toolCallId) !== part) {
-                    continue;
-                }
-                // Note: `tool_calls` list is defined when constructed by `AIMessage` class, and outputs should be excluded from it
-                const { output, args: _args, ..._tool_call } = part.tool_call;
-                // Skip invalid tool calls that have no name AND no output
-                if (_tool_call.name == null ||
-                    (_tool_call.name === '' && (output == null || output === ''))) {
-                    continue;
-                }
-                if (options?.provider === Providers.ANTHROPIC &&
-                    typeof _tool_call.id === 'string' &&
-                    _tool_call.id.startsWith(Constants.ANTHROPIC_SERVER_TOOL_PREFIX)) {
-                    if (!serverToolResultIds.has(_tool_call.id) &&
-                        options.preserveUnpairedServerToolUses !== true) {
-                        continue;
-                    }
-                    if (emittedServerToolUseIds.has(_tool_call.id) ||
-                        pendingServerToolUses.has(_tool_call.id)) {
-                        continue;
-                    }
-                    pendingServerToolUses.set(_tool_call.id, {
-                        type: 'server_tool_use',
-                        id: _tool_call.id,
-                        name: _tool_call.name,
-                        input: parseServerToolInput(_args),
-                    });
-                    continue;
-                }
-                if (!lastAIMessage) {
-                    // "Heal" the payload by creating an AIMessage to precede the tool call
-                    lastAIMessage = createAIMessage('');
-                    formattedMessages.push(lastAIMessage);
-                }
-                else {
-                    attachPendingReasoningContent(lastAIMessage);
-                }
-                const tool_call = _tool_call;
-                // TODO: investigate; args as dictionary may need to be providers-or-tool-specific
-                let args = _args;
-                try {
-                    if (typeof _args === 'string') {
-                        args = JSON.parse(_args);
-                    }
-                }
-                catch {
-                    if (typeof _args === 'string') {
-                        args = { input: _args };
-                    }
-                }
-                tool_call.args = args;
-                if (options?.provider === Providers.ANTHROPIC &&
-                    Array.isArray(lastAIMessage.content)) {
-                    const content = lastAIMessage.content;
-                    content.push({
-                        type: 'tool_use',
-                        id: normalizeAnthropicToolCallId(tool_call.id ?? ''),
-                        name: tool_call.name,
-                        input: args,
-                    });
-                    lastAIMessage.content = content;
-                }
-                else {
-                    if (!lastAIMessage.tool_calls) {
-                        lastAIMessage.tool_calls = [];
-                    }
-                    lastAIMessage.tool_calls.push(tool_call);
-                }
-                formattedMessages.push(withMessageRole(new ToolMessage({
-                    tool_call_id: tool_call.id ?? '',
-                    name: tool_call.name,
-                    content: output != null ? output : '',
-                }), 'tool'));
-            }
-            else if (part.type === ContentTypes.THINK ||
-                part.type === ContentTypes.THINKING ||
-                part.type === ContentTypes.REASONING ||
-                part.type === ContentTypes.REASONING_CONTENT ||
-                part.type === 'redacted_thinking') {
-                hasReasoning = true;
-                pendingReasoningContent += extractReasoningContent(part);
-                continue;
-            }
-            else if (part.type === ContentTypes.ERROR ||
-                part.type === ContentTypes.AGENT_UPDATE ||
-                part.type === ContentTypes.SUMMARY) {
-                continue;
-            }
-            else {
-                if (part.type === ContentTypes.TEXT && !getTextContent(part).trim()) {
-                    continue;
-                }
-                currentContent.push(part);
-            }
-        }
-        for (const content of pendingServerToolUses.values()) {
-            currentContent.push(content);
-        }
-    }
-    if (hasReasoning && currentContent.length > 0) {
-        let content = '';
-        for (const part of currentContent) {
-            if (part.type !== ContentTypes.TEXT) {
-                formattedMessages.push(createAIMessage(toLangChainContent(currentContent)));
-                return formattedMessages;
-            }
-            content += `${getTextContent(part)}\n`;
-        }
-        content = content.trim();
-        if (content) {
-            formattedMessages.push(createAIMessage(content));
-        }
-    }
-    else if (currentContent.length > 0) {
-        formattedMessages.push(createAIMessage(toLangChainContent(currentContent)));
-    }
-    return formattedMessages;
+	const formattedMessages = [];
+	let currentContent = [];
+	let lastAIMessage = null;
+	let hasReasoning = false;
+	let pendingReasoningContent = "";
+	const emittedServerToolUseIds = /* @__PURE__ */ new Set();
+	const pendingServerToolUses = /* @__PURE__ */ new Map();
+	const shouldPreserveReasoningContent = options?.preserveReasoningContent === true;
+	const serverToolResultIds = /* @__PURE__ */ new Set();
+	const preferredToolCallParts = /* @__PURE__ */ new Map();
+	const takePendingReasoningContent = () => {
+		if (!shouldPreserveReasoningContent || !pendingReasoningContent) return;
+		const reasoningContent = pendingReasoningContent;
+		pendingReasoningContent = "";
+		return reasoningContent;
+	};
+	const createAIMessage = (content) => {
+		const reasoningContent = takePendingReasoningContent();
+		return withMessageRole(new AIMessage({
+			content,
+			...reasoningContent != null && { additional_kwargs: { reasoning_content: reasoningContent } }
+		}), "assistant");
+	};
+	const attachPendingReasoningContent = (aiMessage) => {
+		const reasoningContent = takePendingReasoningContent();
+		if (reasoningContent == null) return;
+		aiMessage.additional_kwargs.reasoning_content = typeof aiMessage.additional_kwargs.reasoning_content === "string" ? `${aiMessage.additional_kwargs.reasoning_content}${reasoningContent}` : reasoningContent;
+	};
+	const flushPendingServerToolUse = (toolUseId) => {
+		for (const [id, content] of pendingServerToolUses) {
+			pendingServerToolUses.delete(id);
+			if (id === toolUseId) {
+				currentContent.push(content);
+				emittedServerToolUseIds.add(id);
+				return;
+			}
+		}
+	};
+	if (Array.isArray(message.content)) {
+		const contentParts = message.content;
+		for (const part of contentParts) {
+			if (part == null) continue;
+			if (isValidServerToolResult(part)) serverToolResultIds.add(getToolUseId(part) ?? "");
+			if (options?.provider === "anthropic") {
+				const toolCallId = getToolCallId(part);
+				if (toolCallId == null) continue;
+				const preferredPart = preferredToolCallParts.get(toolCallId);
+				if (preferredPart == null || !hasToolCallOutput(preferredPart) && hasToolCallOutput(part)) preferredToolCallParts.set(toolCallId, part);
+			}
+		}
+		for (const part of contentParts) {
+			if (part == null) continue;
+			const toolUseId = getToolUseId(part);
+			if (toolUseId != null) {
+				const isServerToolResult = isValidServerToolResult(part);
+				if (toolUseId.startsWith("srvtoolu_") && !isServerToolResult) continue;
+				flushPendingServerToolUse(toolUseId);
+				if (isServerToolResult) {
+					currentContent.push(part);
+					continue;
+				}
+			} else if (hasMeaningfulAssistantContent(part)) {
+				for (const id of pendingServerToolUses.keys()) if (!serverToolResultIds.has(id)) pendingServerToolUses.delete(id);
+			}
+			if (part.type === "text" && part.tool_call_ids) {
+				if (currentContent.length > 0) {
+					if (currentContent.some((content) => content.type !== "text")) {
+						currentContent.push(part);
+						lastAIMessage = createAIMessage(toLangChainContent(currentContent));
+						formattedMessages.push(lastAIMessage);
+						currentContent = [];
+						continue;
+					}
+					let content = currentContent.reduce((acc, curr) => {
+						if (curr.type === "text") return `${acc}${getTextContent(curr)}\n`;
+						return acc;
+					}, "");
+					content = `${content}\n${getTextContent(part)}`.trim();
+					lastAIMessage = createAIMessage(content);
+					formattedMessages.push(lastAIMessage);
+					currentContent = [];
+					continue;
+				}
+				lastAIMessage = createAIMessage(getTextContent(part));
+				formattedMessages.push(lastAIMessage);
+			} else if (part.type === "tool_call") {
+				if (part.tool_call == null) continue;
+				const toolCallId = getToolCallId(part);
+				if (options?.provider === "anthropic" && toolCallId != null && preferredToolCallParts.get(toolCallId) !== part) continue;
+				const { output, args: _args, ..._tool_call } = part.tool_call;
+				if (_tool_call.name == null || _tool_call.name === "" && (output == null || output === "")) continue;
+				if (options?.provider === "anthropic" && typeof _tool_call.id === "string" && _tool_call.id.startsWith("srvtoolu_")) {
+					if (!serverToolResultIds.has(_tool_call.id) && options.preserveUnpairedServerToolUses !== true) continue;
+					if (emittedServerToolUseIds.has(_tool_call.id) || pendingServerToolUses.has(_tool_call.id)) continue;
+					pendingServerToolUses.set(_tool_call.id, {
+						type: "server_tool_use",
+						id: _tool_call.id,
+						name: _tool_call.name,
+						input: parseServerToolInput(_args)
+					});
+					continue;
+				}
+				if (!lastAIMessage) {
+					lastAIMessage = createAIMessage("");
+					formattedMessages.push(lastAIMessage);
+				} else attachPendingReasoningContent(lastAIMessage);
+				const tool_call = _tool_call;
+				let args = _args;
+				try {
+					if (typeof _args === "string") args = JSON.parse(_args);
+				} catch {
+					if (typeof _args === "string") args = { input: _args };
+				}
+				tool_call.args = args;
+				if (options?.provider === "anthropic" && Array.isArray(lastAIMessage.content)) {
+					const content = lastAIMessage.content;
+					content.push({
+						type: "tool_use",
+						id: normalizeAnthropicToolCallId(tool_call.id ?? ""),
+						name: tool_call.name,
+						input: args
+					});
+					lastAIMessage.content = content;
+				} else {
+					if (!lastAIMessage.tool_calls) lastAIMessage.tool_calls = [];
+					lastAIMessage.tool_calls.push(tool_call);
+				}
+				formattedMessages.push(withMessageRole(new ToolMessage({
+					tool_call_id: tool_call.id ?? "",
+					name: tool_call.name,
+					content: output != null ? output : ""
+				}), "tool"));
+			} else if (part.type === "think" || part.type === "thinking" || part.type === "reasoning" || part.type === "reasoning_content" || part.type === "redacted_thinking") {
+				hasReasoning = true;
+				pendingReasoningContent += extractReasoningContent(part);
+				continue;
+			} else if (part.type === "error" || part.type === "agent_update" || part.type === "summary") continue;
+			else {
+				if (part.type === "text" && !getTextContent(part).trim()) continue;
+				currentContent.push(part);
+			}
+		}
+		for (const content of pendingServerToolUses.values()) currentContent.push(content);
+	}
+	if (hasReasoning && currentContent.length > 0) {
+		let content = "";
+		for (const part of currentContent) {
+			if (part.type !== "text") {
+				formattedMessages.push(createAIMessage(toLangChainContent(currentContent)));
+				return formattedMessages;
+			}
+			content += `${getTextContent(part)}\n`;
+		}
+		content = content.trim();
+		if (content) formattedMessages.push(createAIMessage(content));
+	} else if (currentContent.length > 0) formattedMessages.push(createAIMessage(toLangChainContent(currentContent)));
+	return formattedMessages;
 }
 function getSourceMessageId(message) {
-    const candidate = message.messageId ??
-        message.id;
-    if (typeof candidate !== 'string') {
-        return undefined;
-    }
-    const normalized = candidate.trim();
-    return normalized.length > 0 ? normalized : undefined;
+	const candidate = message.messageId ?? message.id;
+	if (typeof candidate !== "string") return;
+	const normalized = candidate.trim();
+	return normalized.length > 0 ? normalized : void 0;
 }
 /**
- * Labels all agent content for parallel patterns (fan-out/fan-in)
- * Groups consecutive content by agent and wraps with clear labels
- */
+* 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;
-    let agentContentBuffer = [];
-    const flushAgentBuffer = () => {
-        if (agentContentBuffer.length === 0) {
-            return;
-        }
-        if (currentAgentId != null && currentAgentId !== '') {
-            const agentName = (agentNames?.[currentAgentId] ?? '') || currentAgentId;
-            const formattedParts = [];
-            formattedParts.push(`--- ${agentName} ---`);
-            for (const part of agentContentBuffer) {
-                if (part.type === ContentTypes.THINK) {
-                    const thinkContent = part.think || '';
-                    if (thinkContent) {
-                        formattedParts.push(`${agentName}: ${JSON.stringify({
-                            type: 'think',
-                            think: thinkContent,
-                        })}`);
-                    }
-                }
-                else if (part.type === ContentTypes.TEXT) {
-                    const textContent = part.text ?? '';
-                    if (textContent) {
-                        formattedParts.push(`${agentName}: ${textContent}`);
-                    }
-                }
-                else if (part.type === ContentTypes.TOOL_CALL) {
-                    formattedParts.push(`${agentName}: ${JSON.stringify({
-                        type: 'tool_call',
-                        tool_call: part.tool_call,
-                    })}`);
-                }
-            }
-            formattedParts.push(`--- End of ${agentName} ---`);
-            // Create a single text content part with all agent content
-            result.push({
-                type: ContentTypes.TEXT,
-                text: formattedParts.join('\n\n'),
-            });
-        }
-        else {
-            // No agent ID, pass through as-is
-            result.push(...agentContentBuffer);
-        }
-        agentContentBuffer = [];
-    };
-    for (let i = 0; i < contentParts.length; i++) {
-        const part = contentParts[i];
-        const agentId = agentIdMap[i];
-        // If agent changed, flush previous buffer
-        if (agentId !== currentAgentId && currentAgentId !== undefined) {
-            flushAgentBuffer();
-        }
-        currentAgentId = agentId;
-        agentContentBuffer.push(part);
-    }
-    // Flush any remaining content
-    flushAgentBuffer();
-    return result;
+	const result = [];
+	let currentAgentId;
+	let agentContentBuffer = [];
+	const flushAgentBuffer = () => {
+		if (agentContentBuffer.length === 0) return;
+		if (currentAgentId != null && currentAgentId !== "") {
+			const agentName = (agentNames?.[currentAgentId] ?? "") || currentAgentId;
+			const formattedParts = [];
+			formattedParts.push(`--- ${agentName} ---`);
+			for (const part of agentContentBuffer) if (part.type === "think") {
+				const thinkContent = part.think || "";
+				if (thinkContent) formattedParts.push(`${agentName}: ${JSON.stringify({
+					type: "think",
+					think: thinkContent
+				})}`);
+			} else if (part.type === "text") {
+				const textContent = part.text ?? "";
+				if (textContent) formattedParts.push(`${agentName}: ${textContent}`);
+			} else if (part.type === "tool_call") formattedParts.push(`${agentName}: ${JSON.stringify({
+				type: "tool_call",
+				tool_call: part.tool_call
+			})}`);
+			formattedParts.push(`--- End of ${agentName} ---`);
+			result.push({
+				type: "text",
+				text: formattedParts.join("\n\n")
+			});
+		} else result.push(...agentContentBuffer);
+		agentContentBuffer = [];
+	};
+	for (let i = 0; i < contentParts.length; i++) {
+		const part = contentParts[i];
+		const agentId = agentIdMap[i];
+		if (agentId !== currentAgentId && currentAgentId !== void 0) flushAgentBuffer();
+		currentAgentId = agentId;
+		agentContentBuffer.push(part);
+	}
+	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
- */
+* 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 labelNonTransferContent is true, use a different strategy for parallel patterns
-    if (options?.labelNonTransferContent === true) {
-        return labelAllAgentContent(contentParts, agentIdMap, agentNames);
-    }
-    const result = [];
-    let currentAgentId;
-    let agentContentBuffer = [];
-    let transferToolCallIndex;
-    let transferToolCallId;
-    const flushAgentBuffer = () => {
-        if (agentContentBuffer.length === 0) {
-            return;
-        }
-        // If this is content from a transferred agent, format it specially
-        if (currentAgentId != null &&
-            currentAgentId !== '' &&
-            transferToolCallIndex !== undefined) {
-            const agentName = (agentNames?.[currentAgentId] ?? '') || currentAgentId;
-            const formattedParts = [];
-            formattedParts.push(`--- Transfer to ${agentName} ---`);
-            for (const part of agentContentBuffer) {
-                if (part.type === ContentTypes.THINK) {
-                    formattedParts.push(`${agentName}: ${JSON.stringify({
-                        type: 'think',
-                        think: part.think,
-                    })}`);
-                }
-                else if ('text' in part && part.type === ContentTypes.TEXT) {
-                    const textContent = part.text ?? '';
-                    if (textContent) {
-                        formattedParts.push(`${agentName}: ${JSON.stringify({
-                            type: 'text',
-                            text: textContent,
-                        })}`);
-                    }
-                }
-                else if (part.type === ContentTypes.TOOL_CALL) {
-                    formattedParts.push(`${agentName}: ${JSON.stringify({
-                        type: 'tool_call',
-                        tool_call: part.tool_call,
-                    })}`);
-                }
-            }
-            formattedParts.push(`--- End of ${agentName} response ---`);
-            // Find the tool call that triggered this transfer and update its output
-            if (transferToolCallIndex < result.length) {
-                const transferToolCall = result[transferToolCallIndex];
-                if (transferToolCall.type === ContentTypes.TOOL_CALL &&
-                    transferToolCall.tool_call?.id === transferToolCallId) {
-                    transferToolCall.tool_call.output = formattedParts.join('\n\n');
-                }
-            }
-        }
-        else {
-            // Not from a transfer, add as-is
-            result.push(...agentContentBuffer);
-        }
-        agentContentBuffer = [];
-        transferToolCallIndex = undefined;
-        transferToolCallId = undefined;
-    };
-    for (let i = 0; i < contentParts.length; i++) {
-        const part = contentParts[i];
-        const agentId = agentIdMap[i];
-        // Check if this is a transfer tool call
-        const isTransferTool = (part.type === ContentTypes.TOOL_CALL &&
-            part.tool_call?.name?.startsWith('lc_transfer_to_')) ??
-            false;
-        // If agent changed, flush previous buffer
-        if (agentId !== currentAgentId && currentAgentId !== undefined) {
-            flushAgentBuffer();
-        }
-        currentAgentId = agentId;
-        if (isTransferTool) {
-            // Flush any existing buffer first
-            flushAgentBuffer();
-            // Add the transfer tool call to result
-            result.push(part);
-            // Mark that the next agent's content should be captured
-            transferToolCallIndex = result.length - 1;
-            transferToolCallId = part.tool_call?.id;
-            currentAgentId = undefined; // Reset to capture the next agent
-        }
-        else {
-            agentContentBuffer.push(part);
-        }
-    }
-    flushAgentBuffer();
-    return result;
+	if (!agentIdMap || Object.keys(agentIdMap).length === 0) return contentParts;
+	if (options?.labelNonTransferContent === true) return labelAllAgentContent(contentParts, agentIdMap, agentNames);
+	const result = [];
+	let currentAgentId;
+	let agentContentBuffer = [];
+	let transferToolCallIndex;
+	let transferToolCallId;
+	const flushAgentBuffer = () => {
+		if (agentContentBuffer.length === 0) return;
+		if (currentAgentId != null && currentAgentId !== "" && transferToolCallIndex !== void 0) {
+			const agentName = (agentNames?.[currentAgentId] ?? "") || currentAgentId;
+			const formattedParts = [];
+			formattedParts.push(`--- Transfer to ${agentName} ---`);
+			for (const part of agentContentBuffer) if (part.type === "think") formattedParts.push(`${agentName}: ${JSON.stringify({
+				type: "think",
+				think: part.think
+			})}`);
+			else if ("text" in part && part.type === "text") {
+				const textContent = part.text ?? "";
+				if (textContent) formattedParts.push(`${agentName}: ${JSON.stringify({
+					type: "text",
+					text: textContent
+				})}`);
+			} else if (part.type === "tool_call") formattedParts.push(`${agentName}: ${JSON.stringify({
+				type: "tool_call",
+				tool_call: part.tool_call
+			})}`);
+			formattedParts.push(`--- End of ${agentName} response ---`);
+			if (transferToolCallIndex < result.length) {
+				const transferToolCall = result[transferToolCallIndex];
+				if (transferToolCall.type === "tool_call" && transferToolCall.tool_call?.id === transferToolCallId) transferToolCall.tool_call.output = formattedParts.join("\n\n");
+			}
+		} else result.push(...agentContentBuffer);
+		agentContentBuffer = [];
+		transferToolCallIndex = void 0;
+		transferToolCallId = void 0;
+	};
+	for (let i = 0; i < contentParts.length; i++) {
+		const part = contentParts[i];
+		const agentId = agentIdMap[i];
+		const isTransferTool = (part.type === "tool_call" && part.tool_call?.name?.startsWith("lc_transfer_to_")) ?? false;
+		if (agentId !== currentAgentId && currentAgentId !== void 0) flushAgentBuffer();
+		currentAgentId = agentId;
+		if (isTransferTool) {
+			flushAgentBuffer();
+			result.push(part);
+			transferToolCallIndex = result.length - 1;
+			transferToolCallId = part.tool_call?.id;
+			currentAgentId = void 0;
+		} else agentContentBuffer.push(part);
+	}
+	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]);
-                if (typeof parsed === 'object' &&
-                    parsed !== null &&
-                    Array.isArray(parsed.tools)) {
-                    return parsed.tools
-                        .map((t) => t.name)
-                        .filter((name) => typeof name === 'string');
-                }
-            }
-            catch {
-                /* ignore */
-            }
-        }
-    }
-    return [];
+	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]);
+			if (typeof parsed === "object" && parsed !== null && Array.isArray(parsed.tools)) return parsed.tools.map((t) => t.name).filter((name) => typeof name === "string");
+		} catch {}
+	}
+	return [];
 }
 function getLatestSummaryBoundary(payload) {
-    let summaryBoundary;
-    for (let i = 0; i < payload.length; i++) {
-        const message = payload[i];
-        if (!Array.isArray(message.content)) {
-            continue;
-        }
-        for (let j = 0; j < message.content.length; j++) {
-            const part = message.content[j];
-            if (part == null || part.type !== ContentTypes.SUMMARY) {
-                continue;
-            }
-            const summaryPart = part;
-            // Try content array first (new format), then direct text (legacy format)
-            let summaryText = (summaryPart.content ?? [])
-                .map((block) => 'text' in block ? block.text : '')
-                .join('')
-                .trim();
-            // Fallback: legacy format where text was a direct field on the block
-            if (summaryText.length === 0 && typeof summaryPart.text === 'string') {
-                summaryText = summaryPart.text.trim();
-            }
-            if (summaryText.length === 0) {
-                continue;
-            }
-            summaryBoundary = {
-                messageIndex: i,
-                contentIndex: j,
-                text: summaryText,
-                tokenCount: typeof summaryPart.tokenCount === 'number' &&
-                    Number.isFinite(summaryPart.tokenCount)
-                    ? summaryPart.tokenCount
-                    : 0,
-            };
-        }
-    }
-    return summaryBoundary;
+	let summaryBoundary;
+	for (let i = 0; i < payload.length; i++) {
+		const message = payload[i];
+		if (!Array.isArray(message.content)) continue;
+		for (let j = 0; j < message.content.length; j++) {
+			const part = message.content[j];
+			if (part == null || part.type !== "summary") continue;
+			const summaryPart = part;
+			let summaryText = (summaryPart.content ?? []).map((block) => "text" in block ? block.text : "").join("").trim();
+			if (summaryText.length === 0 && typeof summaryPart.text === "string") summaryText = summaryPart.text.trim();
+			if (summaryText.length === 0) continue;
+			summaryBoundary = {
+				messageIndex: i,
+				contentIndex: j,
+				text: summaryText,
+				tokenCount: typeof summaryPart.tokenCount === "number" && Number.isFinite(summaryPart.tokenCount) ? summaryPart.tokenCount : 0
+			};
+		}
+	}
+	return summaryBoundary;
 }
 function applySummaryBoundary(message, messageIndex, summaryBoundary) {
-    if (!summaryBoundary) {
-        return message;
-    }
-    if (messageIndex < summaryBoundary.messageIndex) {
-        return null;
-    }
-    if (messageIndex !== summaryBoundary.messageIndex ||
-        !Array.isArray(message.content)) {
-        return message;
-    }
-    return {
-        ...message,
-        content: message.content.slice(summaryBoundary.contentIndex + 1),
-    };
+	if (!summaryBoundary) return message;
+	if (messageIndex < summaryBoundary.messageIndex) return null;
+	if (messageIndex !== summaryBoundary.messageIndex || !Array.isArray(message.content)) return message;
+	return {
+		...message,
+		content: message.content.slice(summaryBoundary.contentIndex + 1)
+	};
 }
 function contentPartCharLength(part) {
-    const record = part;
-    let len = 0;
-    if (typeof record.text === 'string') {
-        len += record.text.length;
-    }
-    if (typeof record.thinking === 'string') {
-        len += record.thinking.length;
-    }
-    const { input } = record;
-    if (typeof input === 'string') {
-        len += input.length;
-    }
-    else if (input != null && typeof input === 'object') {
-        len += JSON.stringify(input).length;
-    }
-    return len;
+	const record = part;
+	let len = 0;
+	if (typeof record.text === "string") len += record.text.length;
+	if (typeof record.thinking === "string") len += record.thinking.length;
+	const { input } = record;
+	if (typeof input === "string") len += input.length;
+	else if (input != null && typeof input === "object") len += JSON.stringify(input).length;
+	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 {
-            parsed = JSON.parse(args);
-        }
-        catch {
-            /* malformed args — skip */
-        }
-    }
-    else {
-        parsed = args;
-    }
-    const name = parsed?.skillName;
-    return typeof name === 'string' && name !== '' ? name : undefined;
+	let parsed;
+	if (typeof args === "string") try {
+		parsed = JSON.parse(args);
+	} catch {}
+	else parsed = 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, 
-/** Pre-resolved skill bodies keyed by skill name. When present, HumanMessages
- *  are reconstructed after skill ToolMessages to restore skill instructions
- *  that were only in LangGraph state during the original run. */
-skills, options) => {
-    const messages = [];
-    // If indexTokenCountMap is provided, create a new map to track the updated indices
-    const updatedIndexTokenCountMap = {};
-    let boundaryTokenAdjustment;
-    // Keep track of the mapping from original payload indices to result indices
-    const indexMapping = {};
-    const summaryBoundary = getLatestSummaryBoundary(payload);
-    // Summary metadata is returned to the caller so it can be forwarded to the
-    // agent run and included in the single system message via AgentContext.
-    // We intentionally do NOT create a SystemMessage here — that would conflict
-    // with the agent's own system message (instructions + summary combined).
-    /**
-     * 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) : undefined;
-    // Process messages with tool conversion if tools set is provided
-    for (let i = 0; i < payload.length; i++) {
-        const rawMessage = payload[i];
-        const sourceMessageId = getSourceMessageId(rawMessage);
-        let message = applySummaryBoundary(rawMessage, i, summaryBoundary);
-        if (!message) {
-            indexMapping[i] = [];
-            continue;
-        }
-        // Q: Store the current length of messages to track where this payload message starts in the result?
-        // const startIndex = messages.length;
-        if (typeof message.content === 'string') {
-            message = {
-                ...message,
-                content: [
-                    { type: ContentTypes.TEXT, [ContentTypes.TEXT]: message.content },
-                ],
-            };
-        }
-        else if (Array.isArray(message.content) && message.content.length === 0) {
-            indexMapping[i] = [];
-            continue;
-        }
-        if (message.role !== 'assistant') {
-            const formattedMessage = formatMessage({
-                message: message,
-                langChain: true,
-            });
-            if (sourceMessageId != null && sourceMessageId !== '') {
-                formattedMessage.id = sourceMessageId;
-            }
-            messages.push(formattedMessage);
-            // Update the index mapping for this message
-            indexMapping[i] = [messages.length - 1];
-            continue;
-        }
-        // For assistant messages, track the starting index before processing
-        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) {
-            const content = message.content;
-            if (content != null && Array.isArray(content)) {
-                const filteredContent = [];
-                const invalidToolCallIds = new Set();
-                const invalidToolStrings = [];
-                for (const part of content) {
-                    if (part.type !== ContentTypes.TOOL_CALL) {
-                        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 === Constants.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);
-                        }
-                    }
-                    if (discoveredTools.has(toolName)) {
-                        filteredContent.push(part);
-                        if (toolName === Constants.SKILL_TOOL &&
-                            skills?.size != null &&
-                            skills.size > 0) {
-                            const skillName = extractSkillName(part.tool_call.args) ?? '';
-                            if (skillName) {
-                                (pendingSkillNames ??= 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 === ContentTypes.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 === ContentTypes.TEXT) {
-                            lastTextPartIndex = j;
-                            break;
-                        }
-                    }
-                    const invalidToolText = invalidToolStrings.join('\n');
-                    if (lastTextPartIndex >= 0) {
-                        const lastTextPart = filteredContent[lastTextPartIndex];
-                        const existingText = lastTextPart[ContentTypes.TEXT] ?? lastTextPart.text ?? '';
-                        filteredContent[lastTextPartIndex] = {
-                            ...lastTextPart,
-                            [ContentTypes.TEXT]: existingText
-                                ? `${existingText}\n${invalidToolText}`
-                                : invalidToolText,
-                        };
-                    }
-                    else {
-                        /** No text part exists, create one */
-                        filteredContent.push({
-                            type: ContentTypes.TEXT,
-                            [ContentTypes.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) {
-                    if (part.type !== ContentTypes.TOOL_CALL ||
-                        part.tool_call?.name !== Constants.SKILL_TOOL) {
-                        continue;
-                    }
-                    const skillName = extractSkillName(part.tool_call.args) ?? '';
-                    if (skillName) {
-                        (pendingSkillNames ??= new Set()).add(skillName);
-                    }
-                }
-            }
-        }
-        const formattedMessages = formatAssistantMessage(processedMessage, {
-            preserveUnpairedServerToolUses: i === payload.length - 1,
-            preserveReasoningContent: options?.provider === Providers.DEEPSEEK,
-            provider: options?.provider,
-        });
-        if (sourceMessageId != null && sourceMessageId !== '') {
-            for (const formattedMessage of formattedMessages) {
-                formattedMessage.id = sourceMessageId;
-            }
-        }
-        messages.push(...formattedMessages);
-        // Capture index range BEFORE skill body injection so injected
-        // HumanMessages are excluded from the assistant's token distribution.
-        const endMessageIndex = messages.length;
-        if (pendingSkillNames?.size != null && pendingSkillNames.size > 0) {
-            const skipSkillBodyNames = options?.skipSkillBodyNames;
-            for (const skillName of pendingSkillNames) {
-                if (skipSkillBodyNames != null && skipSkillBodyNames.has(skillName)) {
-                    continue;
-                }
-                const body = skills?.get(skillName) ?? '';
-                if (body) {
-                    messages.push(withMessageRole(new HumanMessage({
-                        content: body,
-                        additional_kwargs: {
-                            role: 'user',
-                            isMeta: true,
-                            source: 'skill',
-                            skillName,
-                        },
-                    }), 'user'));
-                }
-            }
-        }
-        const resultIndices = [];
-        for (let j = startMessageIndex; j < endMessageIndex; j++) {
-            resultIndices.push(j);
-        }
-        indexMapping[i] = resultIndices;
-    }
-    if (indexTokenCountMap) {
-        for (let originalIndex = 0; originalIndex < payload.length; originalIndex++) {
-            const resultIndices = indexMapping[originalIndex] || [];
-            let tokenCount = indexTokenCountMap[originalIndex];
-            if (tokenCount === undefined) {
-                continue;
-            }
-            if (summaryBoundary &&
-                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;
-                    for (let p = 0; p < content.length; p++) {
-                        const charLen = contentPartCharLength(content[p]);
-                        totalCharLen += charLen;
-                        if (p > contentIndex) {
-                            remainingCharLen += charLen;
-                        }
-                    }
-                    if (totalCharLen > 0) {
-                        const original = tokenCount;
-                        tokenCount = Math.max(1, Math.round(tokenCount * (remainingCharLen / totalCharLen)));
-                        boundaryTokenAdjustment = {
-                            original,
-                            adjusted: tokenCount,
-                            remainingChars: remainingCharLen,
-                            totalChars: totalCharLen,
-                        };
-                    }
-                }
-            }
-            const msgCount = resultIndices.length;
-            if (msgCount === 1) {
-                updatedIndexTokenCountMap[resultIndices[0]] = tokenCount;
-                continue;
-            }
-            if (msgCount < 2) {
-                continue;
-            }
-            let totalLength = 0;
-            const lastIdx = msgCount - 1;
-            const lengths = new Array(msgCount);
-            for (let k = 0; k < msgCount; k++) {
-                const msg = messages[resultIndices[k]];
-                const { content } = msg;
-                let len = 0;
-                if (typeof content === 'string') {
-                    len = content.length;
-                }
-                else if (Array.isArray(content)) {
-                    for (const part of content) {
-                        if (typeof part === 'string') {
-                            len += part.length;
-                        }
-                        else if (part != null && typeof part === 'object') {
-                            const val = part.text ?? part.content;
-                            if (typeof val === 'string') {
-                                len += val.length;
-                            }
-                        }
-                    }
-                }
-                const toolCalls = msg.tool_calls;
-                if (Array.isArray(toolCalls)) {
-                    for (const tc of toolCalls) {
-                        if (typeof tc.name === 'string') {
-                            len += tc.name.length;
-                        }
-                        const { args } = tc;
-                        if (typeof args === 'string') {
-                            len += args.length;
-                        }
-                        else if (args != null) {
-                            len += JSON.stringify(args).length;
-                        }
-                    }
-                }
-                lengths[k] = len;
-                totalLength += len;
-            }
-            if (totalLength === 0) {
-                const countPerMessage = Math.floor(tokenCount / msgCount);
-                for (let k = 0; k < lastIdx; k++) {
-                    updatedIndexTokenCountMap[resultIndices[k]] = countPerMessage;
-                }
-                updatedIndexTokenCountMap[resultIndices[lastIdx]] =
-                    tokenCount - countPerMessage * lastIdx;
-            }
-            else {
-                let distributed = 0;
-                for (let k = 0; k < lastIdx; k++) {
-                    const share = Math.floor((lengths[k] / totalLength) * tokenCount);
-                    updatedIndexTokenCountMap[resultIndices[k]] = share;
-                    distributed += share;
-                }
-                updatedIndexTokenCountMap[resultIndices[lastIdx]] =
-                    tokenCount - distributed;
-            }
-        }
-    }
-    return {
-        messages,
-        indexTokenCountMap: indexTokenCountMap
-            ? updatedIndexTokenCountMap
-            : undefined,
-        summary: summaryBoundary
-            ? { text: summaryBoundary.text, tokenCount: summaryBoundary.tokenCount }
-            : undefined,
-        boundaryTokenAdjustment,
-    };
+* 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 = [];
+	const updatedIndexTokenCountMap = {};
+	let boundaryTokenAdjustment;
+	const indexMapping = {};
+	const summaryBoundary = getLatestSummaryBoundary(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];
+		const sourceMessageId = getSourceMessageId(rawMessage);
+		let message = applySummaryBoundary(rawMessage, i, summaryBoundary);
+		if (!message) {
+			indexMapping[i] = [];
+			continue;
+		}
+		if (typeof message.content === "string") message = {
+			...message,
+			content: [{
+				type: "text",
+				["text"]: message.content
+			}]
+		};
+		else if (Array.isArray(message.content) && message.content.length === 0) {
+			indexMapping[i] = [];
+			continue;
+		}
+		if (message.role !== "assistant") {
+			const formattedMessage = formatMessage({
+				message,
+				langChain: true
+			});
+			if (sourceMessageId != null && sourceMessageId !== "") formattedMessage.id = sourceMessageId;
+			messages.push(formattedMessage);
+			indexMapping[i] = [messages.length - 1];
+			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) {
+			const content = message.content;
+			if (content != null && Array.isArray(content)) {
+				const filteredContent = [];
+				const invalidToolCallIds = /* @__PURE__ */ new Set();
+				const invalidToolStrings = [];
+				for (const part of content) {
+					if (part.type !== "tool_call") {
+						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);
+					}
+					if (discoveredTools.has(toolName)) {
+						filteredContent.push(part);
+						if (toolName === "skill" && skills?.size != null && skills.size > 0) {
+							const skillName = extractSkillName(part.tool_call.args) ?? "";
+							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;
+						break;
+					}
+					const invalidToolText = invalidToolStrings.join("\n");
+					if (lastTextPartIndex >= 0) {
+						const lastTextPart = filteredContent[lastTextPartIndex];
+						const existingText = lastTextPart["text"] ?? lastTextPart.text ?? "";
+						filteredContent[lastTextPartIndex] = {
+							...lastTextPart,
+							["text"]: existingText ? `${existingText}\n${invalidToolText}` : invalidToolText
+						};
+					} else
+ /** No text part exists, create one */
+					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) {
+				if (part.type !== "tool_call" || part.tool_call?.name !== "skill") continue;
+				const skillName = extractSkillName(part.tool_call.args) ?? "";
+				if (skillName) (pendingSkillNames ??= /* @__PURE__ */ new Set()).add(skillName);
+			}
+		}
+		const formattedMessages = formatAssistantMessage(processedMessage, {
+			preserveUnpairedServerToolUses: i === payload.length - 1,
+			preserveReasoningContent: options?.provider === "deepseek",
+			provider: options?.provider
+		});
+		if (sourceMessageId != null && sourceMessageId !== "") for (const formattedMessage of formattedMessages) formattedMessage.id = sourceMessageId;
+		messages.push(...formattedMessages);
+		const endMessageIndex = messages.length;
+		if (pendingSkillNames?.size != null && pendingSkillNames.size > 0) {
+			const skipSkillBodyNames = options?.skipSkillBodyNames;
+			for (const skillName of pendingSkillNames) {
+				if (skipSkillBodyNames != null && skipSkillBodyNames.has(skillName)) continue;
+				const body = skills?.get(skillName) ?? "";
+				if (body) messages.push(withMessageRole(new HumanMessage({
+					content: body,
+					additional_kwargs: {
+						role: "user",
+						isMeta: true,
+						source: "skill",
+						skillName
+					}
+				}), "user"));
+			}
+		}
+		const resultIndices = [];
+		for (let j = startMessageIndex; j < endMessageIndex; j++) resultIndices.push(j);
+		indexMapping[i] = resultIndices;
+	}
+	if (indexTokenCountMap) for (let originalIndex = 0; originalIndex < payload.length; originalIndex++) {
+		const resultIndices = indexMapping[originalIndex] || [];
+		let tokenCount = indexTokenCountMap[originalIndex];
+		if (tokenCount === void 0) continue;
+		if (summaryBoundary && 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;
+				for (let p = 0; p < content.length; p++) {
+					const charLen = contentPartCharLength(content[p]);
+					totalCharLen += charLen;
+					if (p > contentIndex) remainingCharLen += charLen;
+				}
+				if (totalCharLen > 0) {
+					const original = tokenCount;
+					tokenCount = Math.max(1, Math.round(tokenCount * (remainingCharLen / totalCharLen)));
+					boundaryTokenAdjustment = {
+						original,
+						adjusted: tokenCount,
+						remainingChars: remainingCharLen,
+						totalChars: totalCharLen
+					};
+				}
+			}
+		}
+		const msgCount = resultIndices.length;
+		if (msgCount === 1) {
+			updatedIndexTokenCountMap[resultIndices[0]] = tokenCount;
+			continue;
+		}
+		if (msgCount < 2) continue;
+		let totalLength = 0;
+		const lastIdx = msgCount - 1;
+		const lengths = new Array(msgCount);
+		for (let k = 0; k < msgCount; k++) {
+			const msg = messages[resultIndices[k]];
+			const { content } = msg;
+			let len = 0;
+			if (typeof content === "string") len = content.length;
+			else if (Array.isArray(content)) {
+				for (const part of content) if (typeof part === "string") len += part.length;
+				else if (part != null && typeof part === "object") {
+					const val = part.text ?? part.content;
+					if (typeof val === "string") len += val.length;
+				}
+			}
+			const toolCalls = msg.tool_calls;
+			if (Array.isArray(toolCalls)) for (const tc of toolCalls) {
+				if (typeof tc.name === "string") len += tc.name.length;
+				const { args } = tc;
+				if (typeof args === "string") len += args.length;
+				else if (args != null) len += JSON.stringify(args).length;
+			}
+			lengths[k] = len;
+			totalLength += len;
+		}
+		if (totalLength === 0) {
+			const countPerMessage = Math.floor(tokenCount / msgCount);
+			for (let k = 0; k < lastIdx; k++) updatedIndexTokenCountMap[resultIndices[k]] = countPerMessage;
+			updatedIndexTokenCountMap[resultIndices[lastIdx]] = tokenCount - countPerMessage * lastIdx;
+		} else {
+			let distributed = 0;
+			for (let k = 0; k < lastIdx; k++) {
+				const share = Math.floor(lengths[k] / totalLength * tokenCount);
+				updatedIndexTokenCountMap[resultIndices[k]] = share;
+				distributed += share;
+			}
+			updatedIndexTokenCountMap[resultIndices[lastIdx]] = tokenCount - distributed;
+		}
+	}
+	return {
+		messages,
+		indexTokenCountMap: indexTokenCountMap ? updatedIndexTokenCountMap : void 0,
+		summary: summaryBoundary ? {
+			text: summaryBoundary.text,
+			tokenCount: summaryBoundary.tokenCount
+		} : void 0,
+		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
- */
+* 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) {
-    // Create a new map to avoid modifying the original
-    const shiftedMap = {};
-    shiftedMap[0] = instructionsTokenCount;
-    // Shift all existing indices by 1
-    for (const [indexStr, tokenCount] of Object.entries(indexTokenCountMap)) {
-        const index = Number(indexStr);
-        shiftedMap[index + 1] = tokenCount;
-    }
-    return shiftedMap;
+	const shiftedMap = {};
+	shiftedMap[0] = instructionsTokenCount;
+	for (const [indexStr, tokenCount] of Object.entries(indexTokenCountMap)) {
+		const index = Number(indexStr);
+		shiftedMap[index + 1] = tokenCount;
+	}
+	return shiftedMap;
 }
 /** Block types that contain binary image data and must be preserved structurally. */
-const IMAGE_BLOCK_TYPES = new Set(['image_url', 'image']);
+const IMAGE_BLOCK_TYPES = new Set(["image_url", "image"]);
 /** Checks whether a BaseMessage is a tool-role message. */
-const isToolMessage = (m) => m instanceof ToolMessage || ('role' in m && m.role === 'tool');
+const isToolMessage$1 = (m) => m instanceof ToolMessage || "role" in m && m.role === "tool";
 /** Flushes accumulated text chunks into `parts` as a single text block. */
 function flushTextChunks(textChunks, parts) {
-    if (textChunks.length === 0) {
-        return;
-    }
-    parts.push({
-        type: ContentTypes.TEXT,
-        text: textChunks.join('\n'),
-    });
-    textChunks.length = 0;
+	if (textChunks.length === 0) return;
+	parts.push({
+		type: "text",
+		text: textChunks.join("\n")
+	});
+	textChunks.length = 0;
 }
 /**
- * Appends a single message's content to the running `textChunks` / `parts`
- * accumulators.  Image blocks are shallow-copied into `parts` as-is so that
- * binary data (base64 images) never becomes text tokens.  All other block
- * types are serialized to text — unrecognized types are JSON-serialized
- * rather than silently dropped.
- *
- * 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.
- */
+* Appends a single message's content to the running `textChunks` / `parts`
+* accumulators.  Image blocks are shallow-copied into `parts` as-is so that
+* binary data (base64 images) never becomes text tokens.  All other block
+* types are serialized to text — unrecognized types are JSON-serialized
+* rather than silently dropped.
+*
+* 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) {
-    const { content } = msg;
-    if (typeof content === 'string') {
-        if (content) {
-            textChunks.push(`${role}: ${content}`);
-        }
-        appendToolCalls(msg, role, textChunks);
-        return;
-    }
-    if (!Array.isArray(content)) {
-        appendToolCalls(msg, role, textChunks);
-        return;
-    }
-    let hasToolUseBlock = false;
-    for (const block of content) {
-        if (IMAGE_BLOCK_TYPES.has(block.type ?? '')) {
-            flushTextChunks(textChunks, parts);
-            parts.push({ ...block });
-            continue;
-        }
-        if (block.type === 'tool_use') {
-            hasToolUseBlock = true;
-            textChunks.push(`${role}: [tool_use] ${String(block.name ?? '')} ${JSON.stringify(block.input ?? {})}`);
-            continue;
-        }
-        const text = block.text ?? block.input;
-        if (typeof text === 'string' && text) {
-            textChunks.push(`${role}: ${text}`);
-            continue;
-        }
-        // Fallback: serialize unrecognized block types to preserve context
-        if (block.type != null && block.type !== '') {
-            textChunks.push(`${role}: [${block.type}] ${JSON.stringify(block)}`);
-        }
-    }
-    // If content array had no tool_use blocks, fall back to tool_calls metadata
-    // (handles edge case: empty content array with tool_calls populated)
-    if (!hasToolUseBlock) {
-        appendToolCalls(msg, role, textChunks);
-    }
+	const { content } = msg;
+	if (typeof content === "string") {
+		if (content) textChunks.push(`${role}: ${content}`);
+		appendToolCalls(msg, role, textChunks);
+		return;
+	}
+	if (!Array.isArray(content)) {
+		appendToolCalls(msg, role, textChunks);
+		return;
+	}
+	let hasToolUseBlock = false;
+	for (const block of content) {
+		if (IMAGE_BLOCK_TYPES.has(block.type ?? "")) {
+			flushTextChunks(textChunks, parts);
+			parts.push({ ...block });
+			continue;
+		}
+		if (block.type === "tool_use") {
+			hasToolUseBlock = true;
+			textChunks.push(`${role}: [tool_use] ${String(block.name ?? "")} ${JSON.stringify(block.input ?? {})}`);
+			continue;
+		}
+		const text = block.text ?? block.input;
+		if (typeof text === "string" && text) {
+			textChunks.push(`${role}: ${text}`);
+			continue;
+		}
+		if (block.type != null && block.type !== "") textChunks.push(`${role}: [${block.type}] ${JSON.stringify(block)}`);
+	}
+	if (!hasToolUseBlock) appendToolCalls(msg, role, textChunks);
 }
 function appendToolCalls(msg, role, textChunks) {
-    if (role !== 'AI') {
-        return;
-    }
-    const aiMsg = msg;
-    if (!aiMsg.tool_calls || aiMsg.tool_calls.length === 0) {
-        return;
-    }
-    for (const tc of aiMsg.tool_calls) {
-        textChunks.push(`AI: [tool_call] ${tc.name}(${JSON.stringify(tc.args)})`);
-    }
+	if (role !== "AI") return;
+	const aiMsg = msg;
+	if (!aiMsg.tool_calls || aiMsg.tool_calls.length === 0) return;
+	for (const tc of aiMsg.tool_calls) textChunks.push(`AI: [tool_call] ${tc.name}(${JSON.stringify(tc.args)})`);
 }
 /**
- * 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
- */
+* 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;
-    }
-    // Find the last HumanMessage. Only the trailing sequence after it needs
-    // validation — earlier messages are history already accepted by the provider.
-    let lastHumanIndex = -1;
-    for (let k = messages.length - 1; k >= 0; k--) {
-        const m = messages[k];
-        if (m instanceof HumanMessage ||
-            ('role' in m && m.role === 'user')) {
-            lastHumanIndex = k;
-            break;
-        }
-    }
-    if (lastHumanIndex === messages.length - 1) {
-        return messages;
-    }
-    const result = lastHumanIndex >= 0 ? messages.slice(0, lastHumanIndex + 1) : [];
-    let i = lastHumanIndex + 1;
-    while (i < messages.length) {
-        const msg = messages[i];
-        /** Detect AI messages by instanceof OR by role, in case cache-control cloning
-         produced a plain object that lost the LangChain prototype. */
-        const isAI = msg instanceof AIMessage ||
-            msg instanceof AIMessageChunk ||
-            ('role' in msg && msg.role === 'assistant');
-        if (!isAI) {
-            result.push(msg);
-            i++;
-            continue;
-        }
-        const aiMsg = msg;
-        const hasToolCalls = aiMsg.tool_calls && aiMsg.tool_calls.length > 0;
-        const contentIsArray = Array.isArray(aiMsg.content);
-        // Check if the message has tool calls or tool_use content
-        let hasToolUse = hasToolCalls ?? false;
-        let hasThinkingBlock = false;
-        if (contentIsArray && aiMsg.content.length > 0) {
-            for (const c of aiMsg.content) {
-                if (typeof c !== 'object') {
-                    continue;
-                }
-                if (c.type === 'tool_use') {
-                    hasToolUse = true;
-                }
-                else if (c.type === ContentTypes.THINKING ||
-                    c.type === ContentTypes.REASONING_CONTENT ||
-                    c.type === ContentTypes.REASONING ||
-                    c.type === 'redacted_thinking') {
-                    hasThinkingBlock = true;
-                }
-                if (hasToolUse && hasThinkingBlock) {
-                    break;
-                }
-            }
-        }
-        // Bedrock also stores reasoning in additional_kwargs (may not be in content array)
-        if (!hasThinkingBlock &&
-            aiMsg.additional_kwargs.reasoning_content != null) {
-            hasThinkingBlock = true;
-        }
-        // If message has tool use but no thinking block, check whether this is a
-        // continuation of a thinking-enabled agent's chain before converting.
-        // Bedrock reasoning models can produce multiple AI→Tool rounds after an
-        // initial reasoning response: the first AI message has reasoning_content,
-        // but follow-ups have content: "" with only tool_calls. These are the
-        // same agent's turn and must NOT be converted to HumanMessages.
-        if (hasToolUse && !hasThinkingBlock) {
-            // Current-run boundary check: anything at or after `runStartIndex`
-            // is the current run's own work — preserve it. Claude is allowed
-            // to skip a thinking block before a tool_use (cf. PR #116 in the
-            // agents repo), so the agent's own first-iteration AI message can
-            // legitimately have tool_calls without reasoning. Converting it to
-            // a `[Previous agent context]` placeholder pollutes the next
-            // iteration's prompt — the LLM sees the placeholder, treats it as
-            // suspicious injected content, ignores its own real prior tool
-            // result, and re-runs the tool to verify (which then often fails
-            // because subsequent calls land in fresh sandboxes without the
-            // file). Skip the conversion when we know this is in-run.
-            if (runStartIndex !== undefined && i >= runStartIndex) {
-                result.push(msg);
-                i++;
-                continue;
-            }
-            // Walk backwards — if an earlier AI message in the same chain (before
-            // the nearest HumanMessage) has a thinking/reasoning block, this is a
-            // continuation of a thinking-enabled turn, not a non-thinking handoff.
-            if (chainHasThinkingBlock(messages, i)) {
-                result.push(msg);
-                i++;
-                continue;
-            }
-            // Build structured content in a single pass over the AI + following
-            // ToolMessages — preserves image blocks as-is to avoid serializing
-            // binary data as text (which caused 174× token amplification).
-            const parts = [];
-            const textChunks = ['[Previous agent context]'];
-            appendMessageContent(msg, 'AI', textChunks, parts);
-            let j = i + 1;
-            while (j < messages.length && isToolMessage(messages[j])) {
-                appendMessageContent(messages[j], 'Tool', textChunks, parts);
-                j++;
-            }
-            flushTextChunks(textChunks, parts);
-            emitAgentLog(config, 'warn', 'format', 'ensureThinkingBlockInMessages: injecting [Previous agent context] HumanMessage' +
-                ` (${parts.length} msgs at index ${i}, no thinking block in chain)`);
-            result.push(withMessageRole(new HumanMessage({ content: toLangChainContent(parts) }), 'user'));
-            i = j;
-        }
-        else {
-            // Keep the message as is
-            result.push(msg);
-            i++;
-        }
-    }
-    return result;
+	if (messages.length === 0) return messages;
+	let lastHumanIndex = -1;
+	for (let k = messages.length - 1; k >= 0; k--) {
+		const m = messages[k];
+		if (m instanceof HumanMessage || "role" in m && m.role === "user") {
+			lastHumanIndex = k;
+			break;
+		}
+	}
+	if (lastHumanIndex === messages.length - 1) return messages;
+	const result = lastHumanIndex >= 0 ? messages.slice(0, lastHumanIndex + 1) : [];
+	let i = lastHumanIndex + 1;
+	while (i < messages.length) {
+		const msg = messages[i];
+		if (!(msg instanceof AIMessage || msg instanceof AIMessageChunk || "role" in msg && msg.role === "assistant")) {
+			result.push(msg);
+			i++;
+			continue;
+		}
+		const aiMsg = msg;
+		const hasToolCalls = aiMsg.tool_calls && aiMsg.tool_calls.length > 0;
+		const contentIsArray = Array.isArray(aiMsg.content);
+		let hasToolUse = hasToolCalls ?? false;
+		let hasThinkingBlock = false;
+		if (contentIsArray && aiMsg.content.length > 0) for (const c of aiMsg.content) {
+			if (typeof c !== "object") continue;
+			if (c.type === "tool_use") hasToolUse = true;
+			else if (c.type === "thinking" || c.type === "reasoning_content" || c.type === "reasoning" || c.type === "redacted_thinking") hasThinkingBlock = true;
+			if (hasToolUse && hasThinkingBlock) break;
+		}
+		if (!hasThinkingBlock && aiMsg.additional_kwargs.reasoning_content != null) hasThinkingBlock = true;
+		if (hasToolUse && !hasThinkingBlock) {
+			if (runStartIndex !== void 0 && i >= runStartIndex) {
+				result.push(msg);
+				i++;
+				continue;
+			}
+			if (chainHasThinkingBlock(messages, i)) {
+				result.push(msg);
+				i++;
+				continue;
+			}
+			const parts = [];
+			const textChunks = ["[Previous agent context]"];
+			appendMessageContent(msg, "AI", textChunks, parts);
+			let j = i + 1;
+			while (j < messages.length && isToolMessage$1(messages[j])) {
+				appendMessageContent(messages[j], "Tool", textChunks, parts);
+				j++;
+			}
+			flushTextChunks(textChunks, parts);
+			emitAgentLog(config, "warn", "format", `ensureThinkingBlockInMessages: injecting [Previous agent context] HumanMessage (${parts.length} msgs at index ${i}, no thinking block in chain)`);
+			result.push(withMessageRole(new HumanMessage({ content: toLangChainContent(parts) }), "user"));
+			i = j;
+		} else {
+			result.push(msg);
+			i++;
+		}
+	}
+	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.
- */
+* 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];
-        // HumanMessage = turn boundary — stop searching
-        if (prev instanceof HumanMessage ||
-            ('role' in prev && prev.role === 'user')) {
-            return false;
-        }
-        // Check AI messages for thinking/reasoning blocks
-        const isPrevAI = prev instanceof AIMessage ||
-            prev instanceof AIMessageChunk ||
-            ('role' in prev && prev.role === 'assistant');
-        if (isPrevAI) {
-            const prevAiMsg = prev;
-            if (Array.isArray(prevAiMsg.content) && prevAiMsg.content.length > 0) {
-                const content = prevAiMsg.content;
-                if (content.some((c) => typeof c === 'object' &&
-                    (c.type === ContentTypes.THINKING ||
-                        c.type === ContentTypes.REASONING_CONTENT ||
-                        c.type === ContentTypes.REASONING ||
-                        c.type === 'redacted_thinking'))) {
-                    return true;
-                }
-            }
-            // Bedrock also stores reasoning in additional_kwargs
-            if (prevAiMsg.additional_kwargs.reasoning_content != null) {
-                return true;
-            }
-        }
-        // ToolMessages are part of the chain — keep walking back
-    }
-    return false;
+	for (let k = currentIndex - 1; k >= 0; k--) {
+		const prev = messages[k];
+		if (prev instanceof HumanMessage || "role" in prev && prev.role === "user") return false;
+		if (prev instanceof AIMessage || prev instanceof AIMessageChunk || "role" in prev && prev.role === "assistant") {
+			const prevAiMsg = prev;
+			if (Array.isArray(prevAiMsg.content) && prevAiMsg.content.length > 0) {
+				if (prevAiMsg.content.some((c) => typeof c === "object" && (c.type === "thinking" || c.type === "reasoning_content" || c.type === "reasoning" || c.type === "redacted_thinking"))) return true;
+			}
+			if (prevAiMsg.additional_kwargs.reasoning_content != null) return true;
+		}
+	}
+	return false;
 }
-
+//#endregion
 export { ensureThinkingBlockInMessages, formatAgentMessages, formatFromLangChain, formatLangChainMessages, formatMediaMessage, formatMessage, labelContentByAgent, shiftIndexTokenCountMap, withMessageRole };
-//# sourceMappingURL=format.mjs.map
+
+//# sourceMappingURL=format.mjs.map