@librechat/agents 3.4.7 → 3.5.0

package/dist/esm/messages/prune.mjs

@@ -14,31 +14,17 @@ function sumTokenCounts(tokenMap, count) {
 	for (let i = 0; i < count; i++) total += tokenMap[i] ?? 0;
 	return total;
 }
-/** Default fraction of the token budget reserved as headroom (5 %). */
 const DEFAULT_RESERVE_RATIO = .05;
-/** Provider framing reserved for the assistant reply label. */
 const REPLY_PRIMER_TOKENS = 3;
-/** Context pressure at which observation masking and context fading activate. */
 const PRESSURE_THRESHOLD_MASKING = .8;
-/** Pressure band thresholds paired with budget factors for progressive context fading. */
 const PRESSURE_BANDS = [
 	[.99, .05],
 	[.9, .2],
 	[.85, .5],
 	[.8, 1]
 ];
-/** Maximum character length for masked (consumed) tool results. */
 const MASKED_RESULT_MAX_CHARS = 300;
-/** Hard cap for the originalToolContent store (~2 MB estimated from char length). */
 const ORIGINAL_CONTENT_MAX_CHARS = 2e6;
-/**
-* Evicts oldest entries from `map` (in Map-iteration / insertion order) until
-* the cumulative char length of remaining values fits within
-* `ORIGINAL_CONTENT_MAX_CHARS`.  Used by the recency-window carry-over merge
-* path in Graph.ts to bound long-running session memory: the pruner enforces
-* the cap inside its own `originalToolContent` map, but a key-wise union with
-* recency carry-over bypasses that cap unless re-applied here.
-*/
 function enforceOriginalContentCap(map) {
 	let total = 0;
 	for (const v of map.values()) total += v.length;
@@ -50,12 +36,8 @@ function enforceOriginalContentCap(map) {
 		map.delete(oldest.value);
 	}
 }
-/** Minimum cumulative calibration ratio — provider can't count fewer tokens
-*  than our raw estimate (within reason). Prevents divide-by-zero edge cases. */
 const CALIBRATION_RATIO_MIN = .5;
-/** Maximum cumulative calibration ratio — sanity cap for the running ratio. */
 const CALIBRATION_RATIO_MAX = 5;
-/** Keeps provider/local token calibration within the shared safe range. */
 function clampCalibrationRatio(ratio) {
 	return Math.max(CALIBRATION_RATIO_MIN, Math.min(5, ratio));
 }
@@ -172,11 +154,6 @@ function repairOrphanedToolMessages({ context, allMessages, tokenCounter, indexT
 		droppedMessages
 	};
 }
-/**
-* Strips tool_use content blocks and tool_calls entries from an AI message
-* when their corresponding ToolMessages are not in the context.
-* Returns null if the message has no content left after stripping.
-*/
 function stripOrphanToolUseBlocks(message, presentToolResultIds) {
 	const aiMessage = message;
 	const keptToolCalls = (aiMessage.tool_calls ?? []).filter((tc) => typeof tc.id === "string" && presentToolResultIds.has(tc.id));
@@ -207,21 +184,6 @@ function stripOrphanToolUseBlocks(message, presentToolResultIds) {
 		additional_kwargs: additionalKwargs
 	});
 }
-/**
-* Lightweight structural cleanup: strips orphan tool_use blocks from AI messages
-* and drops orphan ToolMessages whose AI counterpart is missing.
-*
-* Unlike `repairOrphanedToolMessages`, this does NOT track tokens — it is
-* intended as a final safety net in Graph.ts right before model invocation
-* to prevent Anthropic/Bedrock structural validation errors.
-*
-* Uses duck-typing instead of `getType()` because messages at this stage
-* may be plain objects (from LangGraph state serialization) rather than
-* proper BaseMessage class instances.
-*
-* Includes a fast-path: if every tool_call has a matching tool_result and
-* vice-versa, the original array is returned immediately with zero allocation.
-*/
 function sanitizeOrphanToolBlocks(messages, onMessageCloned) {
 	const allToolCallIds = /* @__PURE__ */ new Set();
 	const allToolResultIds = /* @__PURE__ */ new Set();
@@ -290,12 +252,6 @@ function sanitizeOrphanToolBlocks(messages, onMessageCloned) {
 	while (result.length > 0 && strippedAiIndices.has(result.length - 1)) result.pop();
 	return result;
 }
-/**
-* Truncates an oversized tool_use `input` field using head+tail, preserving
-* it as a valid JSON object. Head gets ~70%, tail gets ~30% so the model
-* sees both the beginning (what was called) and end (closing structure/values).
-* Falls back to head-only when the budget is too small for a meaningful tail.
-*/
 function isIndexInContext(arrayA, arrayB, targetIndex) {
 	return targetIndex >= arrayA.length - arrayB.length;
 }
@@ -304,7 +260,6 @@ function addThinkingBlock(message, thinkingBlock) {
 		type: "text",
 		text: message.content
 	}];
-	/** Edge case, the message already has the thinking block */
 	if (content[0]?.type === thinkingBlock.type) return message;
 	content.unshift(thinkingBlock);
 	return new AIMessage({
@@ -312,12 +267,6 @@ function addThinkingBlock(message, thinkingBlock) {
 		content: toLangChainContent(content)
 	});
 }
-/**
-* Calculates the total tokens from a single usage object
-*
-* @param usage The usage metadata object containing token information
-* @returns An object containing the total input and output tokens
-*/
 function calculateTotalTokens(usage) {
 	const baseInputTokens = Number(usage.input_tokens) || 0;
 	const cacheCreation = Number(usage.input_token_details?.cache_creation) || 0;
@@ -331,31 +280,9 @@ function calculateTotalTokens(usage) {
 		total_tokens: totalInputTokens + totalOutputTokens
 	};
 }
-/**
-* Locates a reasoning block in assistant content. Reasoning blocks carry
-* provider-specific `type` tags: Anthropic emits `thinking`, while Bedrock and
-* OpenAI-compatible reasoning providers (DeepSeek-R1, DashScope/Qwen-thinking)
-* emit `reasoning_content`. DeepSeek/Qwen route through the `THINKING` default
-* even though their blocks are `reasoning_content` and aren't normalized
-* upstream, so for the `THINKING` case we also accept `reasoning_content` — this
-* is what fixes issue #191.
-*
-* The broadening is intentionally one-directional. A Bedrock run
-* (`REASONING_CONTENT`) must NOT match an Anthropic `thinking` block: the
-* Bedrock input converter rejects `thinking` blocks outright
-* (`src/llm/bedrock/utils/message_inputs.ts`), so reattaching one to a
-* surviving message would make the request fail before it is sent.
-*/
 function findReasoningBlock(content, reasoningType) {
 	return content.find((part) => part.type === reasoningType || reasoningType === "thinking" && part.type === "reasoning_content");
 }
-/**
-* Processes an array of messages and returns a context of messages that fit within a specified token limit.
-* It iterates over the messages from newest to oldest, adding them to the context until the token limit is reached.
-*
-* @param options Configuration options for processing messages
-* @returns Object containing the message context, remaining tokens, messages not included, and summary index
-*/
 function getMessagesWithinTokenLimit({ messages: _messages, maxContextTokens, indexTokenCountMap, startType: _startType, thinkingEnabled, tokenCounter, thinkingStartIndex: _thinkingStartIndex = -1, reasoningType = "thinking", instructionTokens: _instructionTokens = 0 }) {
 	let currentTokenCount = 3;
 	const instructions = _messages[0]?.getType() === "system" ? _messages[0] : void 0;
@@ -364,11 +291,6 @@ function getMessagesWithinTokenLimit({ messages: _messages, maxContextTokens, in
 	let startType = _startType;
 	const originalLength = _messages.length;
 	const messages = [..._messages];
-	/**
-	* IMPORTANT: this context array gets reversed at the end, since the latest messages get pushed first.
-	*
-	* This may be confusing to read, but it is done to ensure the context is in the correct order for the model.
-	* */
 	let context = [];
 	let thinkingStartIndex = _thinkingStartIndex;
 	let thinkingEndIndex = -1;
@@ -392,13 +314,6 @@ function getMessagesWithinTokenLimit({ messages: _messages, maxContextTokens, in
 				thinkingBlock = findReasoningBlock(poppedMessage.content, reasoningType);
 				thinkingStartIndex = thinkingBlock != null ? currentIndex : -1;
 			}
-			/**
-			* Exited the trailing assistant/tool sequence without finding a
-			* thinking block. Anthropic does not require Claude to emit a
-			* thinking block before every tool call, so the absence of one is
-			* a valid sequence — clear thinkingEndIndex so the pruner does not
-			* treat it as malformed.
-			*/
 			if (thinkingEndIndex > -1 && thinkingStartIndex < 0 && !thinkingBlock && messageType !== "ai" && messageType !== "tool") thinkingEndIndex = -1;
 			const tokenCount = indexTokenCountMap[currentIndex] ?? 0;
 			if (prunedMemory.length === 0 && currentTokenCount + tokenCount <= remainingContextTokens) {
@@ -446,25 +361,7 @@ function getMessagesWithinTokenLimit({ messages: _messages, maxContextTokens, in
 		result.context = context.reverse();
 		return result;
 	}
-	/**
-	* A trailing reasoning sequence was detected but its block could not be
-	* located in the surviving context. Rather than throw — which permanently
-	* bricks the conversation, re-firing on every retry of the same thread (see
-	* issue #191) — return the partially-pruned context and let the provider
-	* surface a real, recoverable error if the payload is genuinely malformed.
-	* Strict providers (Anthropic) reject it cleanly; lenient ones (DeepSeek,
-	* Qwen) proceed. The pruner cannot know which applies, so it must not be the
-	* one to make the failure fatal.
-	*/
 	if (thinkingEndIndex > -1 && thinkingStartIndex < 0 || !thinkingBlock) {
-		/**
-		* No block was located, so any `thinkingStartIndex` set above came from a
-		* stale carried-over index pointing at a block-less message. Drop it:
-		* `createPruneMessages` persists the returned index as
-		* `runThinkingStartIndex`, and a stale value would suppress the trailing
-		* scan (`thinkingStartIndex < 0`) on later turns, causing a real reasoning
-		* block to be missed and never reattached.
-		*/
 		delete result.thinkingStartIndex;
 		result.context = context.reverse();
 		return result;
@@ -541,21 +438,6 @@ function getMessagesWithinTokenLimit({ messages: _messages, maxContextTokens, in
 function checkValidNumber(value) {
 	return typeof value === "number" && !isNaN(value) && value > 0;
 }
-/**
-* Observation masking: replaces consumed ToolMessage content with tight
-* head+tail truncations that serve as informative placeholders.
-*
-* A ToolMessage is "consumed" when a subsequent AI message exists that is NOT
-* purely tool calls — meaning the model has already read and acted on the
-* result. Unconsumed results (the latest tool outputs the model hasn't
-* responded to yet) are left intact so the model can still use them.
-*
-* AI messages are never masked — they contain the model's own reasoning and
-* conclusions, which is what prevents the model from repeating work after
-* its tool results are masked.
-*
-* @returns The number of tool messages that were masked.
-*/
 function maskConsumedToolResults(params) {
 	const { messages, indexTokenCountMap, tokenCounter } = params;
 	let maskedCount = 0;
@@ -596,17 +478,6 @@ function maskConsumedToolResults(params) {
 	}
 	return maskedCount;
 }
-/**
-* Pre-flight truncation: truncates oversized ToolMessage content before the
-* main backward-iteration pruning runs. Unlike the ingestion guard (which caps
-* at tool-execution time), pre-flight truncation applies per-turn based on the
-* current context window budget (which may have shrunk due to growing conversation).
-*
-* After truncation, recounts tokens via tokenCounter and updates indexTokenCountMap
-* so subsequent pruning works with accurate counts.
-*
-* @returns The number of tool messages that were truncated.
-*/
 function preFlightTruncateToolResults(params) {
 	const { messages, maxContextTokens, indexTokenCountMap, tokenCounter } = params;
 	const baseMaxChars = calculateMaxToolResultChars(maxContextTokens);
@@ -627,19 +498,6 @@ function preFlightTruncateToolResults(params) {
 	}
 	return truncatedCount;
 }
-/**
-* Pre-flight truncation: truncates oversized `tool_use` input fields in AI messages.
-*
-* Tool call inputs (arguments) can be very large — e.g., code evaluation payloads from
-* MCP tools like chrome-devtools. Since these tool calls have already been executed,
-* the model only needs a summary of what was called, not the full arguments. Truncating
-* them before pruning can prevent entire messages from being dropped.
-*
-* Uses 15% of the context window (in estimated characters, ~4 chars/token) as the
-* per-input cap, capped at 200K chars.
-*
-* @returns The number of AI messages that had tool_use inputs truncated.
-*/
 const HARD_MAX_TOOL_CALL_INPUT_CHARS = 2e5;
 const MIN_JSON_VALUE_CHARS = 4;
 const ACCESSOR_INPUT_PLACEHOLDER = "[Property accessor omitted]";
@@ -716,19 +574,7 @@ function createBoundedTruncationValue(preview, originalChars, maxChars) {
 	if (JSON.stringify({
 		_truncated: "",
 		_originalChars: originalChars
-	}).length > normalizedMaxChars)
- /**
-	* Even the empty envelope overflows the cap, so no preview survives —
-	* but the result must still be a JSON OBJECT, never `null`. This value
-	* replaces a `tool_use.input` / tool-call `args` on messages that are
-	* mutated IN PLACE into graph state (`preFlightTruncateToolCallInputs`),
-	* and Anthropic rejects a replayed non-object input with a 400
-	* (`tool_use.input: Input should be an object`). Observed live: a tight
-	* summarization budget shrank the cap below the envelope, nulled a
-	* retained calculator call's input and args, and the next model call
-	* failed on replay.
-	*/
-	return {};
+	}).length > normalizedMaxChars) return {};
 	let low = 0;
 	let high = Math.min(preview.length, normalizedMaxChars);
 	while (low < high) {
@@ -768,10 +614,6 @@ function projectToolInputWithinLimit(input, maxChars) {
 		};
 	}
 }
-/**
-* Serializes one structured tool-call input as valid, bounded JSON without
-* invoking user-defined accessors or `toJSON`.
-*/
 function serializeToolCallInput(input, maxChars = HARD_MAX_TOOL_CALL_INPUT_CHARS) {
 	const normalizedMaxChars = normalizeToolInputLimit(maxChars);
 	const serialized = serializeStructuredValueBounded(projectToolInputWithinLimit(input, normalizedMaxChars).value, normalizedMaxChars);
@@ -943,16 +785,10 @@ function projectResponsesOutput(output, maxChars, canonicalArguments, canonicalI
 		changed: state.changed
 	};
 }
-/** Per-input cap: 15% of context at ~4 chars/token, never above 200K chars. */
 function calculateMaxToolCallInputChars(maxContextTokens) {
 	if (maxContextTokens == null || maxContextTokens <= 0) return HARD_MAX_TOOL_CALL_INPUT_CHARS;
 	return Math.max(MIN_JSON_VALUE_CHARS, Math.min(Math.floor(maxContextTokens * .15) * 4, HARD_MAX_TOOL_CALL_INPUT_CHARS));
 }
-/**
-* Projects historical tool-call inputs into a provider-safe bounded form.
-* Returns the original array when no message changes and otherwise clones only
-* the array and AI messages whose inline input or `tool_calls` args changed.
-*/
 function projectToolCallInputs(messages, maxInputChars) {
 	const normalizedMaxInputChars = normalizeToolInputLimit(maxInputChars);
 	let projectedMessages;
@@ -1043,35 +879,19 @@ function createPruneMessages(factoryParams) {
 	for (const key in indexTokenCountMap) totalTokens += indexTokenCountMap[key] ?? 0;
 	const reconciledToolMessages = /* @__PURE__ */ new WeakSet();
 	let runThinkingStartIndex = -1;
-	/** Cumulative raw tiktoken tokens we've sent to the provider (messages only,
-	*  excludes instruction overhead and new outputs not yet seen by provider). */
 	let cumulativeRawSent = 0;
-	/** Cumulative provider-reported message tokens (providerInput - instructionOverhead). */
 	let cumulativeProviderReported = 0;
-	/** Stable calibration ratio = cumulativeProviderReported / cumulativeRawSent.
-	*  Converges monotonically as data accumulates. Falls back to seeded value. */
 	let calibrationRatio = factoryParams.calibrationRatio != null && factoryParams.calibrationRatio > 0 ? factoryParams.calibrationRatio : 1;
-	/** Best observed instruction overhead from a near-zero variance turn.
-	*  Self-seeds from provider observations within the run. */
 	let bestInstructionOverhead;
 	const reconciledLegacyAiMessages = /* @__PURE__ */ new WeakSet();
 	let bestVarianceAbs = Infinity;
-	/** Local estimate at the time bestInstructionOverhead was observed.
-	*  Used to invalidate the cached overhead when instructions change
-	*  mid-run (e.g. tool discovery adds tools to the bound set). */
 	let bestInstructionEstimate;
-	/** Original (pre-masking) tool result content keyed by message index.
-	*  Allows the summarizer to see full tool outputs even after masking
-	*  has truncated them in the live message array. Cleared when the
-	*  pruner is recreated after summarization. */
 	const originalToolContent = /* @__PURE__ */ new Map();
 	let originalToolContentSize = 0;
 	const contextPruningSettings = resolveContextPruningSettings(factoryParams.contextPruningConfig);
 	return function pruneMessages(params) {
 		let newOriginalToolContent;
 		if (params.messages.length === 0) {
-			/** Post-compaction calls still invoke the model — report the same
-			*  reserve-adjusted budget fields as the populated paths */
 			const emptyInstructionTokens = factoryParams.getInstructionTokens?.() ?? 0;
 			const emptyReserveRatio = factoryParams.reserveRatio ?? .05;
 			const emptyBudget = factoryParams.maxTokens - (emptyReserveRatio > 0 && emptyReserveRatio < 1 ? Math.round(factoryParams.maxTokens * emptyReserveRatio) : 0);
@@ -1501,12 +1321,9 @@ function createPruneMessages(factoryParams) {
 				for (const [key, value] of Object.entries(preEmergencyTokenCounts)) indexTokenCountMap[key] = value;
 			}
 		}
-		/** Scale raw-space remaining back to calibrated/provider units so it is
-		*  directly comparable with pruningBudget and prePruneContextTokens */
 		const rawRemaining = Math.max(0, initialRemainingContextTokens + reclaimedTokens);
 		const remainingContextTokens = Math.max(0, Math.min(pruningBudget, calibrationRatio > 0 ? Math.round(rawRemaining * calibrationRatio) : rawRemaining));
 		runThinkingStartIndex = thinkingStartIndex ?? -1;
-		/** The index is the first value of `context`, index relative to `params.messages` */
 		lastCutOffIndex = Math.max(params.messages.length - (context.length - (context[0]?.getType() === "system" ? 1 : 0)), 0);
 		return {
 			context,