@librechat/agents 3.2.67 → 3.3.0

package/dist/cjs/messages/format.cjs

@@ -152,7 +152,7 @@ function getTextContent(part) {
 }
 function hasMeaningfulAssistantContent(part) {
 	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 === "tool_call" || part.type === "error" || part.type === "agent_update" || part.type === "summary" || part.type === "activity_label") 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 !== "";
 }
@@ -357,7 +357,7 @@ function formatAssistantMessage(message, options) {
 				*  flushed above or intentionally dropped when not preserving). */
 				hasReasoning = false;
 				pendingReasoningContent = "";
-			} else if (part.type === "error" || part.type === "agent_update" || part.type === "summary") continue;
+			} else if (part.type === "error" || part.type === "agent_update" || part.type === "summary" || part.type === "activity_label") continue;
 			else {
 				if (part.type === "text" && !getTextContent(part).trim()) continue;
 				currentContent.push(part);
@@ -422,6 +422,12 @@ function labelAllAgentContent(contentParts, agentIdMap, agentNames) {
 	};
 	for (let i = 0; i < contentParts.length; i++) {
 		const part = contentParts[i];
+		/** UI-only progress headers are not agent content and must not disturb
+		*  agent state: a label with no `agentIdMap` entry would otherwise read
+		*  as an agent change and flush the buffer mid-agent, splitting one
+		*  agent's contiguous content into two labeled blocks. Skipped before
+		*  any state transition below (mirrors the transfer path). */
+		if (part.type === "activity_label") continue;
 		const agentId = agentIdMap[i];
 		if (agentId !== currentAgentId && currentAgentId !== void 0) flushAgentBuffer();
 		currentAgentId = agentId;
@@ -487,6 +493,12 @@ const labelContentByAgent = (contentParts, agentIdMap, agentNames, options) => {
 	};
 	for (let i = 0; i < contentParts.length; i++) {
 		const part = contentParts[i];
+		/** UI-only progress headers are not agent content and must not disturb
+		*  agent state: a label with no `agentIdMap` entry would otherwise look
+		*  like an agent change, flushing the buffer and resetting an open
+		*  transfer capture so the transferred agent's following chunks lose
+		*  their frame. Skipped before any state transition below. */
+		if (part.type === "activity_label") continue;
 		const agentId = agentIdMap[i];
 		const isTransferTool = (part.type === "tool_call" && part.tool_call?.name?.startsWith("lc_transfer_to_")) ?? false;
 		if (agentId !== currentAgentId && currentAgentId !== void 0) flushAgentBuffer();
@@ -902,6 +914,34 @@ function appendMessageContent(msg, role, textChunks, parts) {
 			textChunks.push(`${role}: [tool_use] ${String(block.name ?? "")} ${JSON.stringify(block.input ?? {})}`);
 			continue;
 		}
+		if (block.type === "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)}`);
+			continue;
+		}
+		if (block.type === "tool_result") {
+			hasToolUseBlock = true;
+			const inner = 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)}`);
+			}
+			else if (inner != null) textChunks.push(`${role}: [tool_result] ${JSON.stringify(inner)}`);
+			continue;
+		}
 		const text = block.text ?? block.input;
 		if (typeof text === "string" && text) {
 			textChunks.push(`${role}: ${text}`);
@@ -914,8 +954,17 @@ function appendMessageContent(msg, role, textChunks, parts) {
 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 (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)})`);
+		return;
+	}
+	const rawToolCalls = aiMsg.additional_kwargs.tool_calls;
+	if (!Array.isArray(rawToolCalls)) return;
+	for (const tc of rawToolCalls) {
+		const fn = tc.function;
+		if (fn == null) continue;
+		textChunks.push(`AI: [tool_call] ${String(fn.name ?? "")}(${String(fn.arguments ?? "")})`);
+	}
 }
 /**
 * Ensures compatibility when switching from a non-thinking agent to a thinking-enabled agent.
@@ -1005,6 +1054,88 @@ function ensureThinkingBlockInMessages(messages, _provider, config, runStartInde
 	}
 	return result;
 }
+/** Whether a message carries tool content a tool-less agent cannot legally
+*  send. Covers every representation a provider converter will serialize back
+*  into a request: a ToolMessage, parsed `AIMessage.tool_calls`, raw
+*  `additional_kwargs.tool_calls` (OpenAI keeps calls here when the parsed
+*  array is empty), and `tool_use` / `tool_call` / `tool_result` content
+*  blocks (`@langchain/aws` and the Anthropic converter map these to Converse
+*  `toolUse` / `toolResult`). Missing the parent AI message is not just a
+*  passthrough: folding its ToolMessage alone would leave an orphan
+*  `assistant(tool_calls) -> user(...)` sequence. */
+function messageHasToolContent(msg) {
+	if (isToolMessage(msg)) return true;
+	const aiMsg = 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;
+	}
+	return false;
+}
+/** Whether a message carries a tool RESULT: a ToolMessage, or a message whose
+*  content includes a `tool_result` block (the shape when a call/result pair is
+*  split as `AIMessage(tool_call)` + `HumanMessage(tool_result)`). Such a result
+*  belongs with the preceding tool call, so it is absorbed into the same fold
+*  and labelled as tool output. */
+function isToolResultMessage(msg) {
+	if (isToolMessage(msg)) return true;
+	if (Array.isArray(msg.content)) return msg.content.some((block) => typeof block === "object" && block.type === "tool_result");
+	return false;
+}
+/**
+* Folds tool_use / tool_result content into plain text for an agent that binds
+* no tools.
+*
+* In a multi-agent graph, a tool-less destination still inherits the prior
+* agent's conversation history, which can contain toolUse/toolResult blocks.
+* Because it binds no tools, the model is invoked with no tool schema — and
+* Bedrock's Converse API rejects any request that carries toolUse/toolResult
+* blocks without a top-level toolConfig ("The toolConfig field must be defined
+* when using toolUse and toolResult content blocks"). Adding a dummy toolConfig
+* is not an option: AWS requires at least one tool, and it would expose a
+* capability the destination was intentionally denied.
+*
+* Each tool-call turn plus its trailing tool results (ToolMessages or
+* `tool_result` content blocks) is collapsed into a single `[Previous tool
+* interaction]` HumanMessage that preserves the tool name, arguments and result
+* as text (image blocks are kept as-is). Runs in a single pass: non-tool
+* messages pass through, `result` is allocated lazily on the first fold, and the
+* original array is returned unchanged when it holds no tool content (the common
+* fresh-tool-less-agent case).
+*/
+function foldToolBlocksForToollessAgent(messages, config) {
+	let result = null;
+	let foldedCount = 0;
+	let i = 0;
+	while (i < messages.length) {
+		const msg = messages[i];
+		if (!messageHasToolContent(msg)) {
+			result?.push(msg);
+			i++;
+			continue;
+		}
+		/** First fold — copy the untouched prefix once, then append from here. */
+		if (result === null) result = messages.slice(0, i);
+		const parts = [];
+		const textChunks = ["[Previous tool interaction]"];
+		appendMessageContent(msg, isToolResultMessage(msg) ? "Tool" : "AI", textChunks, parts);
+		foldedCount++;
+		let j = i + 1;
+		while (j < messages.length && isToolResultMessage(messages[j])) {
+			appendMessageContent(messages[j], "Tool", textChunks, parts);
+			foldedCount++;
+			j++;
+		}
+		flushTextChunks(textChunks, parts);
+		result.push(withMessageRole(new _langchain_core_messages.HumanMessage({ content: require_langchain.toLangChainContent(parts) }), "user"));
+		i = j;
+	}
+	if (result === null) return messages;
+	require_events.emitAgentLog(config, "warn", "format", `foldToolBlocksForToollessAgent: folded ${foldedCount} tool message(s) into text for a tool-less agent`);
+	return result;
+}
 /**
 * Walks backwards from `currentIndex` through the message array to check
 * whether an earlier AI message in the same "chain" (no HumanMessage boundary)
@@ -1032,6 +1163,7 @@ function chainHasThinkingBlock(messages, currentIndex) {
 }
 //#endregion
 exports.ensureThinkingBlockInMessages = ensureThinkingBlockInMessages;
+exports.foldToolBlocksForToollessAgent = foldToolBlocksForToollessAgent;
 exports.formatAgentMessages = formatAgentMessages;
 exports.formatFromLangChain = formatFromLangChain;
 exports.formatLangChainMessages = formatLangChainMessages;