@librechat/agents 3.3.3 → 3.3.5

package/dist/esm/messages/format.mjs

@@ -1,5 +1,7 @@
 import "../common/enum.mjs";
 import "../common/index.mjs";
+import { HARD_MAX_TOOL_RESULT_CHARS } from "../utils/truncation.mjs";
+import { compactToolContent, getToolContentCharLength, isAtomicToolContentBlock, serializeStructuredValueBounded } from "../utils/toolContent.mjs";
 import { toLangChainContent, toLangChainMessageFields } from "./langchain.mjs";
 import { normalizeAnthropicToolCallId } from "../llm/anthropic/utils/message_inputs.mjs";
 import { emitAgentLog } from "../utils/events.mjs";
@@ -175,6 +177,23 @@ function hasToolCallOutput(part) {
 	const output = part.tool_call?.output;
 	return output != null && output !== "";
 }
+function formatToolCallOutput(output) {
+	if (output == null) return "";
+	return compactToolContent(output, HARD_MAX_TOOL_RESULT_CHARS).content;
+}
+/**
+* Content for the synthetic assistant turn that separates a trailing steer
+* from the next user turn. Non-empty by necessity — see the push site.
+*/
+const STEER_ANCHOR_PLACEHOLDER = "_";
+/**
+* True when an assistant message replayed as a steer and nothing followed it,
+* so the emitted run ends on the steer's `HumanMessage`.
+*/
+function endsWithSteerMessage(formatted) {
+	if (formatted.length === 0) return false;
+	return formatted[formatted.length - 1].additional_kwargs.source === "steer";
+}
 /**
 * Helper function to format an assistant message
 * @param message The message to format
@@ -312,7 +331,7 @@ function formatAssistantMessage(message, options) {
 				formattedMessages.push(withMessageRole(new ToolMessage({
 					tool_call_id: tool_call.id ?? "",
 					name: tool_call.name,
-					content: output != null ? output : ""
+					content: formatToolCallOutput(output)
 				}), "tool"));
 			} else if (part.type === "think" || part.type === "thinking" || part.type === "reasoning" || part.type === "reasoning_content" || part.type === "redacted_thinking") {
 				hasReasoning = true;
@@ -583,7 +602,10 @@ function contentPartCharLength(part) {
 	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;
+	else if (input != null && typeof input === "object") {
+		const measured = serializeStructuredValueBounded(input, 0).originalChars;
+		len += measured === Number.MAX_SAFE_INTEGER ? HARD_MAX_TOOL_RESULT_CHARS : Math.min(measured, HARD_MAX_TOOL_RESULT_CHARS);
+	}
 	return len;
 }
 /** Extracts the skillName from a skill tool_call's args (string or object). */
@@ -608,6 +630,27 @@ function extractSkillName(args) {
 */
 const formatAgentMessages = (payload, indexTokenCountMap, tools, skills, options) => {
 	const messages = [];
+	/**
+	* A steer ended the previous payload entry, so the next message emitted —
+	* whichever entry finally produces one — must be separated from it by an
+	* assistant turn. Held rather than emitted so an entry that produces
+	* nothing cannot leave the anchor stranded as the final turn.
+	*/
+	let pendingSteerAnchor = false;
+	/**
+	* Emits the deferred anchor ahead of `next` — the message about to be
+	* pushed. When that message is itself an assistant turn, it already IS the
+	* separation the anchor exists to synthesize, so the intent is simply
+	* discharged: emitting the placeholder anyway would put two assistant turns
+	* back to back, which strict-alternation providers can reject and nothing downstream
+	* repairs (`coalesceAdjacentUserTurns` merges user turns only).
+	*/
+	const flushSteerAnchor = (next) => {
+		if (!pendingSteerAnchor) return;
+		pendingSteerAnchor = false;
+		if (next.role === "assistant") return;
+		messages.push(withMessageRole(new AIMessage({ content: STEER_ANCHOR_PLACEHOLDER }), "assistant"));
+	};
 	const updatedIndexTokenCountMap = {};
 	let boundaryTokenAdjustment;
 	const indexMapping = {};
@@ -643,6 +686,7 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools, skills, options
 				langChain: true
 			});
 			if (sourceMessageId != null && sourceMessageId !== "") formattedMessage.id = sourceMessageId;
+			flushSteerAnchor(formattedMessage);
 			messages.push(formattedMessage);
 			indexMapping[i] = [messages.length - 1];
 			continue;
@@ -746,7 +790,44 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools, skills, options
 			provider: options?.provider
 		});
 		if (sourceMessageId != null && sourceMessageId !== "") for (const formattedMessage of formattedMessages) formattedMessage.id = sourceMessageId;
+		/**
+		* A steer that ends an assistant message leaves the replay on a
+		* `HumanMessage`. The next payload message is itself a user turn, so the
+		* sequence would reach the provider as two adjacent user turns — rejected
+		* by strict-alternation providers. Anchor it with a placeholder assistant
+		* turn.
+		*
+		* The placeholder must be NON-EMPTY. A string-content assistant message
+		* with no tool calls passes through `_convertMessagesToAnthropicPayload`
+		* verbatim — the empty-text repair there only covers array content and
+		* tool-call turns — so an empty anchor would reach Anthropic as
+		* `{role: 'assistant', content: ''}` and trade one invalid sequence for
+		* another. Same single-underscore convention the Anthropic converter
+		* already uses when it has to synthesize a non-empty block.
+		*
+		* Deferred rather than decided by lookahead. `i < payload.length - 1` only
+		* proves a later ENTRY exists, not that it EMITS: entries with empty
+		* content, and entries dropped by `applySummaryBoundary`, are skipped
+		* silently. A trailing steer followed only by those would get the anchor
+		* as the FINAL turn — an assistant prefill with no request after it, which
+		* the model may simply never answer. So the intent is recorded and flushed
+		* only when a message actually follows.
+		*
+		* Pushed AFTER the id stamping above, deliberately. `messagesStateReducer`
+		* treats a repeated id as replace-in-place, so an anchor carrying the
+		* shared `sourceMessageId` would overwrite the steer it exists to protect.
+		* Left unstamped, it reaches the reducer with a null id and is assigned a
+		* fresh one. `endsWithSteerMessage` reads only `additional_kwargs.source`,
+		* so the deferral cannot change which messages get anchored.
+		*/
+		/**
+		* Guarded on emission: an assistant entry whose blocks all filtered away
+		* emits nothing, and flushing for it would strand the anchor as the final
+		* turn — the pending flag stays set for whichever entry emits next.
+		*/
+		if (formattedMessages.length > 0) flushSteerAnchor(formattedMessages[0]);
 		messages.push(...formattedMessages);
+		if (endsWithSteerMessage(formattedMessages)) pendingSteerAnchor = true;
 		const endMessageIndex = messages.length;
 		if (pendingSkillNames?.size != null && pendingSkillNames.size > 0) {
 			const skipSkillBodyNames = options?.skipSkillBodyNames;
@@ -821,7 +902,10 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools, skills, options
 				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;
+				else if (args != null) {
+					const measured = serializeStructuredValueBounded(args, 0).originalChars;
+					len += measured === Number.MAX_SAFE_INTEGER ? HARD_MAX_TOOL_RESULT_CHARS : Math.min(measured, HARD_MAX_TOOL_RESULT_CHARS);
+				}
 			}
 			lengths[k] = len;
 			totalLength += len;
@@ -867,10 +951,99 @@ function shiftIndexTokenCountMap(indexTokenCountMap, instructionsTokenCount) {
 	}
 	return shiftedMap;
 }
-/** Block types that contain binary image data and must be preserved structurally. */
-const IMAGE_BLOCK_TYPES = new Set(["image_url", "image"]);
 /** Checks whether a BaseMessage is a tool-role message. */
 const isToolMessage$1 = (m) => m instanceof ToolMessage || "role" in m && m.role === "tool";
+const PORTABLE_FOLDED_MEDIA_TYPES = new Set(["image", "image_url"]);
+const MAX_FOLDED_BLOCK_CHARS = 8e3;
+const MAX_FOLDED_CONTEXT_CHARS = HARD_MAX_TOOL_RESULT_CHARS;
+const MAX_FOLDED_CONTEXT_WORK = 1e5;
+const FOLDED_CONTEXT_TRUNCATION_NOTICE = "… [additional folded context omitted]";
+const syntheticProviderContextMessages = /* @__PURE__ */ new WeakSet();
+function createFoldContextBudget() {
+	return {
+		remainingChars: MAX_FOLDED_CONTEXT_CHARS,
+		remainingWork: MAX_FOLDED_CONTEXT_WORK,
+		truncated: false
+	};
+}
+function readFoldedDataProperty(value, key) {
+	if (value == null || typeof value !== "object") return;
+	try {
+		const descriptor = Object.getOwnPropertyDescriptor(value, key);
+		return descriptor != null && "value" in descriptor ? descriptor.value : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* Adds one logical line without first concatenating caller-controlled strings.
+* The shared budget covers every synthetic message emitted by one transform,
+* so many individually bounded blocks cannot build an unbounded aggregate.
+*/
+function appendFoldedLine(textChunks, budget, pieces) {
+	if (budget.remainingChars <= 0) {
+		budget.truncated = true;
+		return false;
+	}
+	const separatorChars = textChunks.length > 0 ? 1 : 0;
+	const available = budget.remainingChars - separatorChars;
+	if (available <= 0) {
+		budget.remainingChars = 0;
+		budget.truncated = true;
+		return false;
+	}
+	let totalChars = 0;
+	for (const piece of pieces) totalChars = Math.min(Number.MAX_SAFE_INTEGER, totalChars + piece.length);
+	if (totalChars <= available) {
+		const line = pieces.join("");
+		textChunks.push(line);
+		budget.remainingChars -= separatorChars + line.length;
+		return true;
+	}
+	const notice = FOLDED_CONTEXT_TRUNCATION_NOTICE.slice(0, available);
+	let remainingHeadChars = Math.max(0, available - notice.length);
+	const boundedPieces = [];
+	for (const piece of pieces) {
+		if (remainingHeadChars <= 0) break;
+		const retained = piece.slice(0, remainingHeadChars);
+		boundedPieces.push(retained);
+		remainingHeadChars -= retained.length;
+	}
+	boundedPieces.push(notice);
+	textChunks.push(boundedPieces.join(""));
+	budget.remainingChars = 0;
+	budget.truncated = true;
+	return false;
+}
+function consumeFoldedWork(textChunks, budget) {
+	if (budget.remainingChars <= 0) return false;
+	if (budget.remainingWork-- > 0) return true;
+	appendFoldedLine(textChunks, budget, [FOLDED_CONTEXT_TRUNCATION_NOTICE]);
+	budget.remainingChars = 0;
+	budget.truncated = true;
+	return false;
+}
+function serializeFoldedValue(value) {
+	const compacted = compactToolContent(value, MAX_FOLDED_BLOCK_CHARS).content;
+	return typeof compacted === "string" ? compacted : serializeStructuredValueBounded(compacted, MAX_FOLDED_BLOCK_CHARS).content;
+}
+function markSyntheticProviderContext(message) {
+	syntheticProviderContextMessages.add(message);
+	return message;
+}
+function appendSyntheticProviderContextMessage(result, parts) {
+	if (parts.length === 0) return false;
+	result.push(markSyntheticProviderContext(withMessageRole(new HumanMessage({ content: toLangChainContent(parts) }), "user")));
+	return true;
+}
+/**
+* Identifies provider-context placeholders created by this module without
+* trusting user-controlled content prefixes or leaking marker metadata onto
+* the provider wire.
+*/
+function isSyntheticProviderContextMessage(message) {
+	return syntheticProviderContextMessages.has(message);
+}
 /** Flushes accumulated text chunks into `parts` as a single text block. */
 function flushTextChunks(textChunks, parts) {
 	if (textChunks.length === 0) return;
@@ -882,88 +1055,139 @@ function flushTextChunks(textChunks, parts) {
 }
 /**
 * 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.
+* accumulators. Portable image blocks are shallow-copied into `parts` so
+* binary data never becomes text tokens. Provider-specific media/resource
+* blocks are retained as bounded text so a folded cross-provider history
+* cannot contain an unsupported native block or JSON-expand without limit.
 *
 * When `content` is an array containing tool_use blocks, `tool_calls` is NOT
 * additionally serialized (avoiding double output).  `tool_calls` is used as
 * a fallback when `content` is a plain string or an array with no tool_use.
 */
-function appendMessageContent(msg, role, textChunks, parts) {
+function appendMessageContent(msg, role, textChunks, parts, budget) {
 	const { content } = msg;
 	if (typeof content === "string") {
-		if (content) textChunks.push(`${role}: ${content}`);
-		appendToolCalls(msg, role, textChunks);
+		if (content && consumeFoldedWork(textChunks, budget)) appendFoldedLine(textChunks, budget, [`${role}: `, content]);
+		appendToolCalls(msg, role, textChunks, budget);
 		return;
 	}
 	if (!Array.isArray(content)) {
-		appendToolCalls(msg, role, textChunks);
+		appendToolCalls(msg, role, textChunks, budget);
 		return;
 	}
 	let hasToolUseBlock = false;
 	for (const block of content) {
-		if (IMAGE_BLOCK_TYPES.has(block.type ?? "")) {
-			flushTextChunks(textChunks, parts);
-			parts.push({ ...block });
+		if (!consumeFoldedWork(textChunks, budget)) {
+			hasToolUseBlock = true;
+			break;
+		}
+		const blockTypeValue = readFoldedDataProperty(block, "type");
+		const blockType = typeof blockTypeValue === "string" ? blockTypeValue : void 0;
+		if (blockType !== "tool_use" && blockType !== "tool_call" && blockType !== "tool_result" && isAtomicToolContentBlock(block)) {
+			if (PORTABLE_FOLDED_MEDIA_TYPES.has(blockType ?? "")) {
+				const blockChars = getToolContentCharLength([block]);
+				if (blockChars > budget.remainingChars) {
+					appendFoldedLine(textChunks, budget, [`${role}: [${blockType ?? "media"} omitted: folded context limit]`]);
+					continue;
+				}
+				flushTextChunks(textChunks, parts);
+				parts.push({ ...block });
+				budget.remainingChars -= blockChars;
+			} else appendFoldedLine(textChunks, budget, [`${role}: [${blockType ?? "media"}] `, serializeFoldedValue(block)]);
 			continue;
 		}
-		if (block.type === "tool_use") {
+		if (blockType === "tool_use") {
 			hasToolUseBlock = true;
-			textChunks.push(`${role}: [tool_use] ${String(block.name ?? "")} ${JSON.stringify(block.input ?? {})}`);
+			const name = readFoldedDataProperty(block, "name");
+			const input = readFoldedDataProperty(block, "input");
+			appendFoldedLine(textChunks, budget, [`${role}: [tool_use] ${typeof name === "string" ? name : ""} `, serializeFoldedValue(input ?? {})]);
 			continue;
 		}
-		if (block.type === "tool_call") {
+		if (blockType === "tool_call") {
 			hasToolUseBlock = true;
-			const nested = block.tool_call;
-			const name = String(nested?.name ?? block.name ?? "");
-			const rawArgs = nested?.args ?? block.args ?? {};
-			const argsText = typeof rawArgs === "string" ? rawArgs : JSON.stringify(rawArgs);
-			textChunks.push(`${role}: [tool_use] ${name} ${argsText}`.trimEnd());
-			const output = nested?.output;
-			if (output != null && output !== "") textChunks.push(`Tool: ${String(output)}`);
+			const nested = readFoldedDataProperty(block, "tool_call");
+			const nestedName = readFoldedDataProperty(nested, "name");
+			const topLevelName = readFoldedDataProperty(block, "name");
+			let name = "";
+			if (typeof nestedName === "string") name = nestedName;
+			else if (typeof topLevelName === "string") name = topLevelName;
+			const nestedArgs = readFoldedDataProperty(nested, "args");
+			const topLevelArgs = readFoldedDataProperty(block, "args");
+			const rawArgs = nestedArgs ?? topLevelArgs ?? {};
+			const argsText = typeof rawArgs === "string" ? rawArgs : serializeFoldedValue(rawArgs);
+			appendFoldedLine(textChunks, budget, [`${role}: [tool_use] ${name}${argsText ? " " : ""}`, argsText]);
+			const output = readFoldedDataProperty(nested, "output");
+			if (output != null && output !== "") appendFoldedLine(textChunks, budget, ["Tool: ", typeof output === "string" ? output : serializeFoldedValue(output)]);
 			continue;
 		}
-		if (block.type === "tool_result") {
+		if (blockType === "tool_result") {
 			hasToolUseBlock = true;
-			const inner = block.content;
+			const inner = readFoldedDataProperty(block, "content");
 			if (typeof inner === "string") {
-				if (inner) textChunks.push(`${role}: [tool_result] ${inner}`);
-			} else if (Array.isArray(inner)) for (const innerBlock of inner) if (typeof innerBlock === "string") {
-				if (innerBlock) textChunks.push(`${role}: [tool_result] ${innerBlock}`);
-			} else if (IMAGE_BLOCK_TYPES.has(innerBlock.type ?? "")) {
-				flushTextChunks(textChunks, parts);
-				parts.push({ ...innerBlock });
-			} else {
-				const innerText = innerBlock.text ?? innerBlock.input;
-				textChunks.push(`${role}: [tool_result] ${typeof innerText === "string" && innerText ? innerText : JSON.stringify(innerBlock)}`);
+				if (inner) appendFoldedLine(textChunks, budget, [`${role}: [tool_result] `, inner]);
+			} else if (Array.isArray(inner)) for (const innerBlock of inner) {
+				if (!consumeFoldedWork(textChunks, budget)) break;
+				if (typeof innerBlock === "string") {
+					if (innerBlock) appendFoldedLine(textChunks, budget, [`${role}: [tool_result] `, innerBlock]);
+				} else {
+					const innerTypeValue = readFoldedDataProperty(innerBlock, "type");
+					const innerType = typeof innerTypeValue === "string" ? innerTypeValue : void 0;
+					if (isAtomicToolContentBlock(innerBlock) && PORTABLE_FOLDED_MEDIA_TYPES.has(innerType ?? "")) {
+						const blockChars = getToolContentCharLength([innerBlock]);
+						if (blockChars <= budget.remainingChars) {
+							flushTextChunks(textChunks, parts);
+							parts.push({ ...innerBlock });
+							budget.remainingChars -= blockChars;
+						} else appendFoldedLine(textChunks, budget, [`${role}: [${innerType ?? "media"} omitted: folded context limit]`]);
+					} else {
+						const textValue = readFoldedDataProperty(innerBlock, "text");
+						const inputValue = readFoldedDataProperty(innerBlock, "input");
+						const innerText = textValue ?? inputValue;
+						appendFoldedLine(textChunks, budget, [`${role}: [tool_result] `, typeof innerText === "string" && innerText ? innerText : serializeFoldedValue(innerBlock)]);
+					}
+				}
 			}
-			else if (inner != null) textChunks.push(`${role}: [tool_result] ${JSON.stringify(inner)}`);
+			else if (inner != null) appendFoldedLine(textChunks, budget, [`${role}: [tool_result] `, serializeFoldedValue(inner)]);
 			continue;
 		}
-		const text = block.text ?? block.input;
+		const text = readFoldedDataProperty(block, "text") ?? readFoldedDataProperty(block, "input");
 		if (typeof text === "string" && text) {
-			textChunks.push(`${role}: ${text}`);
+			appendFoldedLine(textChunks, budget, [`${role}: `, text]);
 			continue;
 		}
-		if (block.type != null && block.type !== "") textChunks.push(`${role}: [${block.type}] ${JSON.stringify(block)}`);
+		if (blockType != null && blockType !== "") appendFoldedLine(textChunks, budget, [`${role}: [${blockType}] `, serializeFoldedValue(block)]);
 	}
-	if (!hasToolUseBlock) appendToolCalls(msg, role, textChunks);
+	if (!hasToolUseBlock) appendToolCalls(msg, role, textChunks, budget);
 }
-function appendToolCalls(msg, role, textChunks) {
+function appendToolCalls(msg, role, textChunks, budget) {
 	if (role !== "AI") return;
 	const aiMsg = msg;
 	if (aiMsg.tool_calls && aiMsg.tool_calls.length > 0) {
-		for (const tc of aiMsg.tool_calls) textChunks.push(`AI: [tool_call] ${tc.name}(${JSON.stringify(tc.args)})`);
+		for (const tc of aiMsg.tool_calls) {
+			if (!consumeFoldedWork(textChunks, budget)) break;
+			const name = readFoldedDataProperty(tc, "name");
+			const args = readFoldedDataProperty(tc, "args");
+			appendFoldedLine(textChunks, budget, [
+				`AI: [tool_call] ${typeof name === "string" ? name : ""}(`,
+				serializeFoldedValue(args),
+				")"
+			]);
+		}
 		return;
 	}
 	const rawToolCalls = aiMsg.additional_kwargs.tool_calls;
 	if (!Array.isArray(rawToolCalls)) return;
 	for (const tc of rawToolCalls) {
-		const fn = tc.function;
+		if (!consumeFoldedWork(textChunks, budget)) break;
+		const fn = readFoldedDataProperty(tc, "function");
 		if (fn == null) continue;
-		textChunks.push(`AI: [tool_call] ${String(fn.name ?? "")}(${String(fn.arguments ?? "")})`);
+		const name = readFoldedDataProperty(fn, "name");
+		const args = readFoldedDataProperty(fn, "arguments");
+		appendFoldedLine(textChunks, budget, [
+			`AI: [tool_call] ${typeof name === "string" ? name : ""}(`,
+			typeof args === "string" ? args : "",
+			")"
+		]);
 	}
 }
 /**
@@ -1004,6 +1228,7 @@ function ensureThinkingBlockInMessages(messages, _provider, config, runStartInde
 	}
 	if (lastHumanIndex === messages.length - 1) return messages;
 	const result = lastHumanIndex >= 0 ? messages.slice(0, lastHumanIndex + 1) : [];
+	const foldBudget = createFoldContextBudget();
 	let i = lastHumanIndex + 1;
 	while (i < messages.length) {
 		const msg = messages[i];
@@ -1019,8 +1244,9 @@ function ensureThinkingBlockInMessages(messages, _provider, config, runStartInde
 		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;
+			const type = readFoldedDataProperty(c, "type");
+			if (type === "tool_use") hasToolUse = true;
+			else if (type === "thinking" || type === "reasoning_content" || type === "reasoning" || type === "redacted_thinking") hasThinkingBlock = true;
 			if (hasToolUse && hasThinkingBlock) break;
 		}
 		if (!hasThinkingBlock && aiMsg.additional_kwargs.reasoning_content != null) hasThinkingBlock = true;
@@ -1036,16 +1262,16 @@ function ensureThinkingBlockInMessages(messages, _provider, config, runStartInde
 				continue;
 			}
 			const parts = [];
-			const textChunks = ["[Previous agent context]"];
-			appendMessageContent(msg, "AI", textChunks, parts);
+			const textChunks = [];
+			appendFoldedLine(textChunks, foldBudget, ["[Previous agent context]"]);
+			appendMessageContent(msg, "AI", textChunks, parts, foldBudget);
 			let j = i + 1;
 			while (j < messages.length && isToolMessage$1(messages[j])) {
-				appendMessageContent(messages[j], "Tool", textChunks, parts);
+				appendMessageContent(messages[j], "Tool", textChunks, parts, foldBudget);
 				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"));
+			if (appendSyntheticProviderContextMessage(result, parts)) emitAgentLog(config, "warn", "format", `ensureThinkingBlockInMessages: injecting [Previous agent context] HumanMessage (${parts.length} msgs at index ${i}, no thinking block in chain)`);
 			i = j;
 		} else {
 			result.push(msg);
@@ -1069,8 +1295,9 @@ function messageHasToolContent(msg) {
 	if (aiMsg.tool_calls != null && aiMsg.tool_calls.length > 0) return true;
 	const rawToolCalls = aiMsg.additional_kwargs.tool_calls;
 	if (Array.isArray(rawToolCalls) && rawToolCalls.length > 0) return true;
-	if (Array.isArray(msg.content)) {
-		for (const block of msg.content) if (typeof block === "object" && (block.type === "tool_use" || block.type === "tool_call" || block.type === "tool_result")) return true;
+	if (Array.isArray(msg.content)) for (const block of msg.content) {
+		const type = readFoldedDataProperty(block, "type");
+		if (typeof block === "object" && (type === "tool_use" || type === "tool_call" || type === "tool_result")) return true;
 	}
 	return false;
 }
@@ -1081,7 +1308,7 @@ function messageHasToolContent(msg) {
 *  and labelled as tool output. */
 function isToolResultMessage(msg) {
 	if (isToolMessage$1(msg)) return true;
-	if (Array.isArray(msg.content)) return msg.content.some((block) => typeof block === "object" && block.type === "tool_result");
+	if (Array.isArray(msg.content)) return msg.content.some((block) => typeof block === "object" && readFoldedDataProperty(block, "type") === "tool_result");
 	return false;
 }
 /**
@@ -1108,6 +1335,7 @@ function isToolResultMessage(msg) {
 function foldToolBlocksForToollessAgent(messages, config) {
 	let result = null;
 	let foldedCount = 0;
+	const foldBudget = createFoldContextBudget();
 	let i = 0;
 	while (i < messages.length) {
 		const msg = messages[i];
@@ -1119,17 +1347,18 @@ function foldToolBlocksForToollessAgent(messages, config) {
 		/** First fold — copy the untouched prefix once, then append from here. */
 		if (result === null) result = messages.slice(0, i);
 		const parts = [];
-		const textChunks = ["[Previous tool interaction]"];
-		appendMessageContent(msg, isToolResultMessage(msg) ? "Tool" : "AI", textChunks, parts);
+		const textChunks = [];
+		appendFoldedLine(textChunks, foldBudget, ["[Previous tool interaction]"]);
+		appendMessageContent(msg, isToolResultMessage(msg) ? "Tool" : "AI", textChunks, parts, foldBudget);
 		foldedCount++;
 		let j = i + 1;
 		while (j < messages.length && isToolResultMessage(messages[j])) {
-			appendMessageContent(messages[j], "Tool", textChunks, parts);
+			appendMessageContent(messages[j], "Tool", textChunks, parts, foldBudget);
 			foldedCount++;
 			j++;
 		}
 		flushTextChunks(textChunks, parts);
-		result.push(withMessageRole(new HumanMessage({ content: toLangChainContent(parts) }), "user"));
+		appendSyntheticProviderContextMessage(result, parts);
 		i = j;
 	}
 	if (result === null) return messages;
@@ -1162,6 +1391,6 @@ function chainHasThinkingBlock(messages, currentIndex) {
 	return false;
 }
 //#endregion
-export { ensureThinkingBlockInMessages, foldToolBlocksForToollessAgent, formatAgentMessages, formatFromLangChain, formatLangChainMessages, formatMediaMessage, formatMessage, labelContentByAgent, shiftIndexTokenCountMap, withMessageRole };
+export { ensureThinkingBlockInMessages, foldToolBlocksForToollessAgent, formatAgentMessages, formatFromLangChain, formatLangChainMessages, formatMediaMessage, formatMessage, isSyntheticProviderContextMessage, labelContentByAgent, shiftIndexTokenCountMap, withMessageRole };
 
 //# sourceMappingURL=format.mjs.map