@librechat/agents 3.3.6 → 3.3.8

package/dist/esm/messages/format.mjs

@@ -564,10 +564,23 @@ function extractToolNamesFromSearchOutput(output) {
 	}
 	return [];
 }
-function getLatestSummaryBoundary(payload) {
-	let summaryBoundary;
+function resolveCoverageIndex(coverage, indexBySourceId, summaryMessageIndex) {
+	/** Persisted JSON, so the declared string type is not a runtime guarantee. */
+	if (typeof coverage?.retainedFromMessageId !== "string") return;
+	const retainedFromMessageId = coverage.retainedFromMessageId.trim();
+	if (retainedFromMessageId === "") return;
+	const retainedIndex = indexBySourceId.get(retainedFromMessageId);
+	return retainedIndex != null && retainedIndex <= summaryMessageIndex ? retainedIndex : void 0;
+}
+function scanSummaryBlocks(payload) {
+	let boundary;
+	/** Filled as the scan advances, so a coverage lookup only ever resolves to a
+	*  message already passed — no second pass over the payload. */
+	const indexBySourceId = /* @__PURE__ */ new Map();
 	for (let i = 0; i < payload.length; i++) {
 		const message = payload[i];
+		const sourceMessageId = getSourceMessageId(message);
+		if (sourceMessageId != null) indexBySourceId.set(sourceMessageId, i);
 		if (!Array.isArray(message.content)) continue;
 		for (let j = 0; j < message.content.length; j++) {
 			const part = message.content[j];
@@ -576,18 +589,31 @@ function getLatestSummaryBoundary(payload) {
 			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 = {
+			const tokenCount = typeof summaryPart.tokenCount === "number" && Number.isFinite(summaryPart.tokenCount) ? summaryPart.tokenCount : 0;
+			const retainedIndex = resolveCoverageIndex(summaryPart.coverage, indexBySourceId, i);
+			boundary = retainedIndex != null ? {
+				mode: "coverage",
+				messageIndex: retainedIndex,
+				text: summaryText,
+				tokenCount
+			} : {
+				mode: "positional",
 				messageIndex: i,
 				contentIndex: j,
 				text: summaryText,
-				tokenCount: typeof summaryPart.tokenCount === "number" && Number.isFinite(summaryPart.tokenCount) ? summaryPart.tokenCount : 0
+				tokenCount
 			};
 		}
 	}
-	return summaryBoundary;
+	return { boundary };
 }
 function applySummaryBoundary(message, messageIndex, summaryBoundary) {
 	if (!summaryBoundary) return message;
+	/** The boundary names the first retained message, so it is exclusive: that
+	*  message and everything after it — the recency tail included — stays
+	*  verbatim, and only genuinely covered history is dropped. Summary parts on
+	*  surviving messages are filtered later by `formatAssistantMessage`. */
+	if (summaryBoundary.mode === "coverage") return messageIndex < summaryBoundary.messageIndex ? null : message;
 	if (messageIndex < summaryBoundary.messageIndex) return null;
 	if (messageIndex !== summaryBoundary.messageIndex || !Array.isArray(message.content)) return message;
 	return {
@@ -595,16 +621,53 @@ function applySummaryBoundary(message, messageIndex, summaryBoundary) {
 		content: message.content.slice(summaryBoundary.contentIndex + 1)
 	};
 }
+/**
+* Whether `formatAssistantMessage` filters this part out of the emitted message.
+* Such a part contributes no prompt tokens, so measuring it as zero characters
+* is accurate — it must not be mistaken for content the heuristic cannot see.
+*/
+function isDroppedByFormatting(part) {
+	if (part == null) return true;
+	if (part.type === "summary" || part.type === "error" || part.type === "agent_update" || part.type === "activity_label") return true;
+	return part.type === "text" && getTextContent(part).trim() === "";
+}
+function measureValueChars(value) {
+	if (typeof value === "string") return value.length;
+	if (value == null || typeof value !== "object") return 0;
+	const measured = serializeStructuredValueBounded(value, 0).originalChars;
+	return measured === Number.MAX_SAFE_INTEGER ? HARD_MAX_TOOL_RESULT_CHARS : Math.min(measured, HARD_MAX_TOOL_RESULT_CHARS);
+}
+/**
+* Whether a retained part's whole prompt cost is the text the char heuristic
+* reads, making it safe to represent in a character ratio.
+*
+* An allowlist, not a denylist. Media, resources, and tool calls carry cost that
+* is unrelated to their serialized length — a short image URL nested in
+* `tool_call.output` stands in for a fixed four-figure media charge — and
+* rejecting those case by case has repeatedly missed a nesting level. Listing
+* the two shapes whose characters `contentPartCharLength` actually reads makes
+* every other shape, present or future, ineligible by default: the ratio is
+* skipped and the entry keeps its original count, which prunes early rather than
+* exceeding the window.
+*/
+function isCharRatioEligible(part) {
+	if (part == null) return false;
+	return part.type === "text" || part.type === "thinking";
+}
 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") {
-		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);
+	len += measureValueChars(record.input);
+	/** Tool calls nest their payload a level down, so measuring only the
+	*  top-level fields scores an entire tool turn as zero characters. */
+	const { tool_call: toolCall } = record;
+	if (toolCall != null && typeof toolCall === "object") {
+		const call = toolCall;
+		len += measureValueChars(call.name);
+		len += measureValueChars(call.args);
+		len += measureValueChars(call.output);
 	}
 	return len;
 }
@@ -654,7 +717,7 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools, skills, options
 	const updatedIndexTokenCountMap = {};
 	let boundaryTokenAdjustment;
 	const indexMapping = {};
-	const summaryBoundary = getLatestSummaryBoundary(payload);
+	const { boundary: summaryBoundary } = scanSummaryBlocks(payload);
 	/**
 	* Create a mutable copy of the tools set that can be expanded dynamically.
 	* When we encounter tool_search results, we add discovered tools to this set,
@@ -853,18 +916,64 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools, skills, options
 		const resultIndices = indexMapping[originalIndex] || [];
 		let tokenCount = indexTokenCountMap[originalIndex];
 		if (tokenCount === void 0) continue;
-		if (summaryBoundary && originalIndex === summaryBoundary.messageIndex && Array.isArray(payload[originalIndex].content)) {
+		/**
+		* Coverage mode deliberately leaves the count alone, even though the entry
+		* holding the block is charged for summary text that `formatAssistantMessage`
+		* filters out and `summary.tokenCount` accounts separately.
+		*
+		* Discounting it needs the summary's cost in the same units as
+		* `indexTokenCountMap`, and that figure is not obtainable here: this
+		* function receives no tokenizer, and a count recorded at write time is in
+		* the writing run's units — `Run.create` derives its counter from the model
+		* in play, and a consumer may supply its own — so a conversation continued
+		* on a different model would subtract across encodings. Attempts to proxy
+		* it (character ratios, provider identity) all under-count some shape,
+		* which risks an over-context request; over-counting merely prunes early.
+		* Fixing it properly means passing the reader a tokenizer, which is a
+		* consumer-facing change and out of scope here.
+		*/
+		if (summaryBoundary?.mode === "positional" && originalIndex === summaryBoundary.messageIndex && Array.isArray(payload[originalIndex].content)) {
 			const content = payload[originalIndex].content;
 			const { contentIndex } = summaryBoundary;
 			if (contentIndex >= 0 && contentIndex < content.length - 1) {
 				let totalCharLen = 0;
 				let remainingCharLen = 0;
+				/**
+				* The ratio applies only when *every* part of the entry is one whose
+				* token cost tracks its character length. A single ineligible part
+				* cancels the discount, whichever side of the boundary it sits on.
+				*
+				* Both sides can break it, in opposite directions. A retained image has
+				* its fixed cost scaled away, collapsing the entry. A removed base64
+				* payload inflates the denominator — serializing to a huge length while
+				* the counter charges a fixed estimate — dragging retained text below
+				* its real cost. Either way the request can exceed the window.
+				*
+				* Telling a text-bearing tool payload from a media-bearing one means
+				* recursing into arbitrary nested output, which has already missed a
+				* level twice here. Cancelling instead keeps the original count: an
+				* over-count that prunes early rather than overflowing. Entries of
+				* plain text and reasoning — the common shape — still proportion.
+				*/
+				let everyRetainedPartMeasurable = true;
 				for (let p = 0; p < content.length; p++) {
-					const charLen = contentPartCharLength(content[p]);
+					const part = content[p];
+					const retained = p > contentIndex;
+					if (isDroppedByFormatting(part)) {
+						/** Removed summary text is real removed content: it is read as
+						*  plain text and belongs in the denominator. */
+						if (!retained && part.type === "summary") totalCharLen += contentPartCharLength(part);
+						continue;
+					}
+					const charLen = contentPartCharLength(part);
+					if (!isCharRatioEligible(part) || retained && charLen === 0) {
+						everyRetainedPartMeasurable = false;
+						break;
+					}
 					totalCharLen += charLen;
-					if (p > contentIndex) remainingCharLen += charLen;
+					if (retained) remainingCharLen += charLen;
 				}
-				if (totalCharLen > 0) {
+				if (totalCharLen > 0 && everyRetainedPartMeasurable) {
 					const original = tokenCount;
 					tokenCount = Math.max(1, Math.round(tokenCount * (remainingCharLen / totalCharLen)));
 					boundaryTokenAdjustment = {