@librechat/agents 3.7.15 → 3.7.17

package/dist/cjs/messages/prune.cjs

@@ -1,8 +1,10 @@
+const require_truncation = require("../utils/truncation.cjs");
+const require_fading = require("./fading.cjs");
 require("../common/enum.cjs");
 require("../common/index.cjs");
-const require_truncation = require("../utils/truncation.cjs");
 const require_toolContent = require("../utils/toolContent.cjs");
 const require_langchain = require("./langchain.cjs");
+const require_cache = require("./cache.cjs");
 const require_core = require("./core.cjs");
 const require_tokens = require("../utils/tokens.cjs");
 const require_providerRegistry = require("../llm/providerRegistry.cjs");
@@ -29,14 +31,6 @@ function prependItems(target, prefix) {
 }
 const DEFAULT_RESERVE_RATIO = .05;
 const REPLY_PRIMER_TOKENS = 3;
-const PRESSURE_THRESHOLD_MASKING = .8;
-const PRESSURE_BANDS = [
-	[.99, .05],
-	[.9, .2],
-	[.85, .5],
-	[.8, 1]
-];
-const MASKED_RESULT_MAX_CHARS = 300;
 const ORIGINAL_CONTENT_MAX_CHARS = 2e6;
 function enforceOriginalContentCap(map) {
 	let total = 0;
@@ -59,17 +53,30 @@ function getToolCallIds(message) {
 	if (message.getType() !== "ai" && messageRole !== "assistant") return /* @__PURE__ */ new Set();
 	const ids = /* @__PURE__ */ new Set();
 	const aiMessage = message;
-	for (const toolCall of aiMessage.tool_calls ?? []) if (typeof toolCall.id === "string" && toolCall.id.length > 0) ids.add(toolCall.id);
-	if (Array.isArray(aiMessage.content)) for (const part of aiMessage.content) {
+	const toolCalls = aiMessage.tool_calls;
+	if (Array.isArray(toolCalls) && !(0, node_util_types.isProxy)(toolCalls)) for (const toolCall of toolCalls) {
+		if (typeof toolCall !== "object") continue;
+		const id = getStringProperty(toolCall, "id");
+		if (id != null && id.length > 0) ids.add(id);
+	}
+	const rawToolCalls = readPropertyWithoutAccessors(aiMessage.additional_kwargs, "tool_calls");
+	if (!rawToolCalls.accessor && Array.isArray(rawToolCalls.value) && !(0, node_util_types.isProxy)(rawToolCalls.value)) for (const toolCall of rawToolCalls.value) {
+		if (toolCall == null || typeof toolCall !== "object") continue;
+		const id = getStringProperty(toolCall, "id");
+		if (id != null && id.length > 0) ids.add(id);
+	}
+	if (Array.isArray(aiMessage.content) && !(0, node_util_types.isProxy)(aiMessage.content)) for (const part of aiMessage.content) {
 		if (typeof part !== "object") continue;
-		const record = part;
-		if ((record.type === "tool_use" || record.type === "tool_call") && typeof record.id === "string" && record.id.length > 0) ids.add(record.id);
+		const type = getStringProperty(part, "type");
+		const id = getStringProperty(part, "id");
+		if ((type === "tool_use" || type === "tool_call") && id != null && id.length > 0) ids.add(id);
 	}
 	const toolOutputSource = getResponsesToolOutputSource(message);
 	if (toolOutputSource != null) for (const item of toolOutputSource.items) {
 		if (item == null || typeof item !== "object") continue;
-		const record = item;
-		if ((record.type === "function_call" || record.type === "custom_tool_call" || record.type === "computer_call") && typeof record.call_id === "string" && record.call_id !== "") ids.add(record.call_id);
+		const type = getStringProperty(item, "type");
+		const callId = getStringProperty(item, "call_id");
+		if ((type === "function_call" || type === "custom_tool_call" || type === "computer_call") && callId != null && callId !== "") ids.add(callId);
 	}
 	return ids;
 }
@@ -445,72 +452,117 @@ function getMessagesWithinTokenLimit({ messages: _messages, maxContextTokens, in
 function checkValidNumber(value) {
 	return typeof value === "number" && !isNaN(value) && value > 0;
 }
-function maskConsumedToolResults(params) {
-	const { messages, indexTokenCountMap, tokenCounter } = params;
-	let maskedCount = 0;
-	let seenNonToolCallAI = false;
-	const consumedIndices = [];
+function findConsumedBoundary(messages) {
 	for (let i = messages.length - 1; i >= 0; i--) {
-		const msg = messages[i];
-		const type = msg.getType();
-		if (type === "ai") {
-			if (typeof msg.content === "string" ? msg.content.trim().length > 0 : Array.isArray(msg.content) && msg.content.some((b) => typeof b === "object" && b.type === "text" && typeof b.text === "string" && b.text.trim().length > 0)) seenNonToolCallAI = true;
-		} else if (type === "tool" && seenNonToolCallAI) consumedIndices.push(i);
+		const message = messages[i];
+		if (message.getType() === "ai" && require_core.hasNonEmptyTextContent(message.content)) return i;
 	}
-	if (consumedIndices.length === 0) return 0;
-	consumedIndices.reverse();
-	const totalBudgetChars = params.availableRawBudget != null && params.availableRawBudget > 0 ? params.availableRawBudget * 4 : 0;
-	const count = consumedIndices.length;
-	for (let c = 0; c < count; c++) {
-		const i = consumedIndices[c];
+	return 0;
+}
+function applyFadingCaps(params) {
+	const { messages, indexTokenCountMap, tokenCounter, caps, masked } = params;
+	const fromIndex = params.fromIndex ?? 0;
+	const maskedFromIndex = params.maskedFromIndex ?? 0;
+	const consumedBoundary = masked ? findConsumedBoundary(messages) : 0;
+	const start = masked ? Math.min(fromIndex, maskedFromIndex) : fromIndex;
+	let truncated = 0;
+	let maskedCount = 0;
+	for (let i = start; i < messages.length; i++) {
 		const message = messages[i];
-		if (require_toolContent.isComputerCallOutputMessage(message)) continue;
-		const content = message.content;
-		let maxChars;
-		if (totalBudgetChars > 0) {
-			const share = (.2 + .8 * (count > 1 ? c / (count - 1) : 1)) / (count > 1 ? .6 * count : 1) * totalBudgetChars;
-			maxChars = Math.max(MASKED_RESULT_MAX_CHARS, Math.floor(share));
-		} else maxChars = MASKED_RESULT_MAX_CHARS;
-		const compacted = require_toolContent.compactToolContent(content, maxChars);
+		if (message.getType() !== "tool" || require_toolContent.isComputerCallOutputMessage(message)) continue;
+		const consumed = masked && i < consumedBoundary;
+		if (consumed ? i < maskedFromIndex : i < fromIndex) continue;
+		const maxChars = consumed ? caps.consumedChars : caps.resultChars;
+		if (!Number.isFinite(maxChars)) continue;
+		const canonicalContent = params.canonicalMessages?.[i]?.content ?? message.content;
+		const compacted = require_toolContent.compactToolContent(canonicalContent, maxChars);
 		if (!compacted.changed) continue;
-		if (params.originalContentStore && !params.originalContentStore.has(i)) {
-			const original = require_toolContent.serializeToolContentBounded(content, ORIGINAL_CONTENT_MAX_CHARS);
+		if (consumed && params.originalContentStore && !params.originalContentStore.has(i)) {
+			const original = require_toolContent.serializeToolContentBounded(canonicalContent, ORIGINAL_CONTENT_MAX_CHARS);
 			params.originalContentStore.set(i, original);
-			if (params.onContentStored) params.onContentStored(i, original);
+			params.onContentStored?.(i, original);
 		}
 		const cloned = require_toolContent.cloneToolMessageWithContent(message, compacted.content);
 		messages[i] = cloned;
 		indexTokenCountMap[i] = tokenCounter(cloned);
-		maskedCount++;
+		if (consumed) maskedCount++;
+		else truncated++;
 	}
-	return maskedCount;
+	const inputs = Number.isFinite(caps.inputChars) ? applyToolCallInputCaps({
+		messages,
+		canonicalMessages: params.canonicalMessages,
+		maxInputChars: caps.inputChars,
+		indexTokenCountMap,
+		tokenCounter,
+		fromIndex
+	}) : 0;
+	return {
+		truncated,
+		inputs,
+		masked: maskedCount,
+		consumedBoundary
+	};
 }
-function preFlightTruncateToolResults(params) {
-	const { messages, maxContextTokens, indexTokenCountMap, tokenCounter } = params;
-	const baseMaxChars = require_truncation.calculateMaxToolResultChars(maxContextTokens);
-	let truncatedCount = 0;
-	const toolIndices = [];
-	for (let i = 0; i < messages.length; i++) if (messages[i].getType() === "tool" && !require_toolContent.isComputerCallOutputMessage(messages[i])) toolIndices.push(i);
-	for (let t = 0; t < toolIndices.length; t++) {
-		const i = toolIndices[t];
-		const message = messages[i];
-		const content = message.content;
-		const recencyFactor = .2 + .8 * (toolIndices.length > 1 ? t / (toolIndices.length - 1) : 1);
-		const compacted = require_toolContent.compactToolContent(content, Math.max(200, Math.floor(baseMaxChars * recencyFactor)));
-		if (!compacted.changed) continue;
-		const cloned = require_toolContent.cloneToolMessageWithContent(message, compacted.content);
-		messages[i] = cloned;
-		indexTokenCountMap[i] = tokenCounter(cloned);
-		truncatedCount++;
+function maskConsumedToolResults(params) {
+	if (params.maxChars == null && params.availableRawBudget != null && params.availableRawBudget > 0) {
+		const consumedBoundary = findConsumedBoundary(params.messages);
+		const consumedIndices = [];
+		for (let i = 0; i < consumedBoundary; i++) if (params.messages[i].getType() === "tool") consumedIndices.push(i);
+		const count = consumedIndices.length;
+		const totalBudgetChars = params.availableRawBudget * 4;
+		let masked = 0;
+		for (let c = 0; c < count; c++) {
+			const i = consumedIndices[c];
+			const message = params.messages[i];
+			if (require_toolContent.isComputerCallOutputMessage(message)) continue;
+			const weight = .2 + .8 * (count > 1 ? c / (count - 1) : 1);
+			const totalWeight = count > 1 ? .6 * count : 1;
+			const maxChars = Math.max(300, Math.floor(weight / totalWeight * totalBudgetChars));
+			const compacted = require_toolContent.compactToolContent(message.content, maxChars);
+			if (!compacted.changed) continue;
+			if (params.originalContentStore != null && !params.originalContentStore.has(i)) {
+				const original = require_toolContent.serializeToolContentBounded(message.content, ORIGINAL_CONTENT_MAX_CHARS);
+				params.originalContentStore.set(i, original);
+				params.onContentStored?.(i, original);
+			}
+			const cloned = require_toolContent.cloneToolMessageWithContent(message, compacted.content);
+			params.messages[i] = cloned;
+			params.indexTokenCountMap[i] = params.tokenCounter(cloned);
+			masked++;
+		}
+		return masked;
 	}
-	return truncatedCount;
+	return applyFadingCaps({
+		messages: params.messages,
+		indexTokenCountMap: params.indexTokenCountMap,
+		tokenCounter: params.tokenCounter,
+		caps: {
+			resultChars: Number.POSITIVE_INFINITY,
+			consumedChars: Math.max(300, Math.floor(params.maxChars ?? 300)),
+			inputChars: Number.POSITIVE_INFINITY
+		},
+		masked: true,
+		originalContentStore: params.originalContentStore,
+		onContentStored: params.onContentStored
+	}).masked;
+}
+function preFlightTruncateToolResults(params) {
+	return applyFadingCaps({
+		messages: params.messages,
+		indexTokenCountMap: params.indexTokenCountMap,
+		tokenCounter: params.tokenCounter,
+		caps: {
+			resultChars: require_truncation.calculateMaxToolResultChars(params.maxContextTokens),
+			consumedChars: Number.POSITIVE_INFINITY,
+			inputChars: Number.POSITIVE_INFINITY
+		},
+		masked: false
+	}).truncated;
 }
-const HARD_MAX_TOOL_CALL_INPUT_CHARS = 2e5;
-const MIN_JSON_VALUE_CHARS = 4;
 const ACCESSOR_INPUT_PLACEHOLDER = "[Property accessor omitted]";
 function normalizeToolInputLimit(maxChars) {
-	if (!Number.isFinite(maxChars)) return HARD_MAX_TOOL_CALL_INPUT_CHARS;
-	return Math.max(MIN_JSON_VALUE_CHARS, Math.floor(maxChars));
+	if (!Number.isFinite(maxChars)) return require_truncation.HARD_MAX_TOOL_CALL_INPUT_CHARS;
+	return Math.max(4, Math.floor(maxChars));
 }
 function readPropertyWithoutAccessors(value, key) {
 	let current = value;
@@ -600,33 +652,62 @@ function cloneAIMessageWithProjectedStreamContent(message, changes, streamConten
 	};
 	return Object.create(Object.getPrototypeOf(message), descriptors);
 }
+const TOOL_INPUT_TRUNCATION_MARKER = "… [truncated]\n";
 function createBoundedTruncationValue(preview, originalChars, maxChars) {
 	const normalizedMaxChars = normalizeToolInputLimit(maxChars);
+	const canonicalPrefix = preview.startsWith(TOOL_INPUT_TRUNCATION_MARKER) ? preview.slice(14) : preview;
 	if (JSON.stringify({
-		_truncated: "",
+		_truncated: TOOL_INPUT_TRUNCATION_MARKER,
 		_originalChars: originalChars
 	}).length > normalizedMaxChars) return {};
 	let low = 0;
-	let high = Math.min(preview.length, normalizedMaxChars);
+	let high = Math.min(canonicalPrefix.length, normalizedMaxChars);
 	while (low < high) {
 		const next = Math.ceil((low + high) / 2);
 		const candidate = {
-			_truncated: preview.slice(0, next),
+			_truncated: TOOL_INPUT_TRUNCATION_MARKER + canonicalPrefix.slice(0, next),
 			_originalChars: originalChars
 		};
 		if (JSON.stringify(candidate).length <= normalizedMaxChars) low = next;
 		else high = next - 1;
 	}
 	return {
-		_truncated: low < preview.length && low >= 13 ? preview.slice(0, low - 13) + "… [truncated]" : preview.slice(0, low),
+		_truncated: TOOL_INPUT_TRUNCATION_MARKER + canonicalPrefix.slice(0, low),
 		_originalChars: originalChars
 	};
 }
+function readBoundedTruncationValue(input) {
+	if (input == null || typeof input !== "object" || (0, node_util_types.isProxy)(input)) return;
+	try {
+		const prototype = Object.getPrototypeOf(input);
+		const keys = Object.keys(input);
+		if (prototype !== Object.prototype && prototype !== null || keys.length !== 2 || !keys.includes("_truncated") || !keys.includes("_originalChars")) return;
+	} catch {
+		return;
+	}
+	const preview = readPropertyWithoutAccessors(input, "_truncated");
+	const originalChars = readPropertyWithoutAccessors(input, "_originalChars");
+	return preview.own && !preview.accessor && typeof preview.value === "string" && originalChars.own && !originalChars.accessor && typeof originalChars.value === "number" && Number.isFinite(originalChars.value) && originalChars.value >= 0 ? {
+		preview: preview.value,
+		originalChars: originalChars.value
+	} : void 0;
+}
 function projectToolInputWithinLimit(input, maxChars) {
 	const normalizedMaxChars = normalizeToolInputLimit(maxChars);
-	const serialized = require_toolContent.serializeStructuredValueBounded(input, normalizedMaxChars);
+	const priorTruncation = readBoundedTruncationValue(input);
+	if (priorTruncation != null) {
+		if (!require_toolContent.serializeStructuredValueBounded(input, normalizedMaxChars).truncated) return {
+			value: input,
+			changed: false
+		};
+		return {
+			value: createBoundedTruncationValue(priorTruncation.preview, priorTruncation.originalChars, normalizedMaxChars),
+			changed: true
+		};
+	}
+	const serialized = require_toolContent.serializeStructuredValueBounded(input, normalizedMaxChars, normalizedMaxChars);
 	if (serialized.truncated) return {
-		value: createBoundedTruncationValue(serialized.content, serialized.originalChars, normalizedMaxChars),
+		value: createBoundedTruncationValue(serialized.prefix, serialized.originalChars, normalizedMaxChars),
 		changed: true
 	};
 	if (!require_tokens.hasUnsafeStructuredSerialization(input)) return {
@@ -645,11 +726,11 @@ function projectToolInputWithinLimit(input, maxChars) {
 		};
 	}
 }
-function serializeToolCallInput(input, maxChars = HARD_MAX_TOOL_CALL_INPUT_CHARS) {
+function serializeToolCallInput(input, maxChars = require_truncation.HARD_MAX_TOOL_CALL_INPUT_CHARS) {
 	const normalizedMaxChars = normalizeToolInputLimit(maxChars);
-	const serialized = require_toolContent.serializeStructuredValueBounded(projectToolInputWithinLimit(input, normalizedMaxChars).value, normalizedMaxChars);
+	const serialized = require_toolContent.serializeStructuredValueBounded(projectToolInputWithinLimit(input, normalizedMaxChars).value, normalizedMaxChars, normalizedMaxChars);
 	if (!serialized.truncated) return serialized.content === "undefined" ? "null" : serialized.content;
-	const fallback = createBoundedTruncationValue(serialized.content, serialized.originalChars, normalizedMaxChars);
+	const fallback = createBoundedTruncationValue(serialized.prefix, serialized.originalChars, normalizedMaxChars);
 	return JSON.stringify(fallback);
 }
 function projectKnownInputProperty(value, key, maxChars, changes) {
@@ -675,7 +756,7 @@ function projectInlineToolInput(block, maxChars) {
 	if (nestedProperty.found && !nestedProperty.accessor && nestedProperty.value != null && typeof nestedProperty.value === "object") {
 		const nestedChanges = {};
 		projectKnownInputProperty(nestedProperty.value, "args", maxChars, nestedChanges);
-		if (Object.keys(nestedChanges).length > 0) changes.tool_call = cloneWithProjectedProperties(nestedProperty.value, nestedChanges);
+		if (Object.keys(nestedChanges).length > 0) changes.tool_call = (0, node_util_types.isProxy)(nestedProperty.value) ? { args: ACCESSOR_INPUT_PLACEHOLDER } : cloneWithProjectedProperties(nestedProperty.value, nestedChanges);
 		else if (!nestedProperty.own) changes.tool_call = nestedProperty.value;
 	} else if (nestedProperty.accessor) changes.tool_call = { args: ACCESSOR_INPUT_PLACEHOLDER };
 	return Object.keys(changes).length > 0 ? cloneWithProjectedProperties(block, changes) : block;
@@ -686,11 +767,34 @@ function projectSerializedArguments(value, maxChars) {
 		value,
 		changed: false
 	};
+	if (typeof value === "string" && value.includes("\"_truncated\"") && value.includes("\"_originalChars\"")) try {
+		const priorTruncation = readBoundedTruncationValue(JSON.parse(value));
+		if (priorTruncation != null) return {
+			value: JSON.stringify(createBoundedTruncationValue(priorTruncation.preview, priorTruncation.originalChars, normalizedMaxChars)),
+			changed: true
+		};
+	} catch {}
 	return {
 		value: serializeToolCallInput(value, normalizedMaxChars),
 		changed: true
 	};
 }
+const TRUNCATED_STRING_INPUT_PATTERN = /\n… \[truncated: (\d+) chars\]$/u;
+function projectStringInputWithinLimit(value, maxChars) {
+	const normalizedMaxChars = normalizeToolInputLimit(maxChars);
+	if (value.length <= normalizedMaxChars) return {
+		value,
+		changed: false
+	};
+	const match = TRUNCATED_STRING_INPUT_PATTERN.exec(value);
+	const originalChars = match == null ? value.length : Number(match[1]);
+	const prefix = match == null ? value : value.slice(0, match.index);
+	const marker = `\n… [truncated: ${originalChars} chars]`;
+	return {
+		value: marker.length >= normalizedMaxChars ? prefix.slice(0, normalizedMaxChars) : prefix.slice(0, normalizedMaxChars - marker.length) + marker,
+		changed: true
+	};
+}
 function selectProjectedSerializedArguments(property, canonical, maxChars) {
 	if (canonical != null) return {
 		value: canonical,
@@ -794,7 +898,7 @@ function projectResponsesOutput(output, maxChars, canonicalArguments, canonicalI
 				changed: !inputProperty.own || inputProperty.value !== source
 			};
 			else if (type === "custom_tool_call") {
-				const value = typeof source === "string" ? require_truncation.truncateToolResultContent(source, normalizeToolInputLimit(maxChars)) : serializeToolCallInput(source, maxChars);
+				const value = typeof source === "string" ? projectStringInputWithinLimit(source, maxChars).value : serializeToolCallInput(source, maxChars);
 				projectedInput = {
 					value,
 					changed: !inputProperty.own || inputProperty.value !== value
@@ -816,14 +920,10 @@ function projectResponsesOutput(output, maxChars, canonicalArguments, canonicalI
 		changed: state.changed
 	};
 }
-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));
-}
-function projectToolCallInputsInternal(messages, maxInputChars, dropIncompleteStreamContent) {
+function projectToolCallInputsInternal(messages, maxInputChars, dropIncompleteStreamContent, fromIndex = 0) {
 	const normalizedMaxInputChars = normalizeToolInputLimit(maxInputChars);
 	let projectedMessages;
-	for (let i = 0; i < messages.length; i++) {
+	for (let i = fromIndex; i < messages.length; i++) {
 		const message = messages[i];
 		const messageRole = message.role;
 		if (message.getType() !== "ai" && messageRole !== "assistant") continue;
@@ -891,25 +991,47 @@ function projectToolCallInputsInternal(messages, maxInputChars, dropIncompleteSt
 	}
 	return projectedMessages ?? messages;
 }
-function projectToolCallInputs(messages, maxInputChars) {
-	return projectToolCallInputsInternal(messages, maxInputChars, false);
+function projectToolCallInputs(messages, maxInputChars, fromIndex = 0) {
+	return projectToolCallInputsInternal(messages, maxInputChars, false, fromIndex);
 }
 function projectToolMessagesForProvider(messages, maxInputChars) {
 	return projectToolCallInputsInternal(messages, maxInputChars, true);
 }
-function preFlightTruncateToolCallInputs(params) {
-	const { messages, maxContextTokens, indexTokenCountMap, tokenCounter } = params;
-	const projected = projectToolCallInputs(messages, calculateMaxToolCallInputChars(maxContextTokens));
-	if (projected === messages) return 0;
+function applyToolCallInputCaps(params) {
+	const { messages, maxInputChars, indexTokenCountMap, tokenCounter } = params;
+	const fromIndex = params.fromIndex ?? 0;
+	const sourceMessages = params.canonicalMessages ?? messages;
+	const projected = projectToolCallInputs(sourceMessages, maxInputChars, fromIndex);
+	if (projected === sourceMessages) return 0;
 	let truncatedCount = 0;
-	for (let i = 0; i < messages.length; i++) {
+	for (let i = fromIndex; i < messages.length; i++) {
+		if (projected[i] === sourceMessages[i]) continue;
 		if (projected[i] === messages[i]) continue;
-		messages[i] = projected[i];
-		indexTokenCountMap[i] = tokenCounter(projected[i]);
+		const current = messages[i];
+		const canonical = sourceMessages[i];
+		const capped = projected[i];
+		const changes = {};
+		if (capped.content !== canonical.content) changes.content = capped.content;
+		if (capped.tool_calls !== canonical.tool_calls) changes.tool_calls = capped.tool_calls;
+		const additionalKwargsChanges = {};
+		for (const key of ["tool_calls", "function_call"]) if (capped.additional_kwargs[key] !== canonical.additional_kwargs[key]) additionalKwargsChanges[key] = capped.additional_kwargs[key];
+		if (Object.keys(additionalKwargsChanges).length > 0) changes.additional_kwargs = cloneWithProjectedProperties(current.additional_kwargs, additionalKwargsChanges);
+		if (capped.response_metadata.output !== canonical.response_metadata.output) changes.response_metadata = cloneWithProjectedProperties(current.response_metadata, { output: capped.response_metadata.output });
+		const merged = cloneWithProjectedProperties(current, changes);
+		messages[i] = merged;
+		indexTokenCountMap[i] = tokenCounter(merged);
 		truncatedCount++;
 	}
 	return truncatedCount;
 }
+function preFlightTruncateToolCallInputs(params) {
+	return applyToolCallInputCaps({
+		messages: params.messages,
+		maxInputChars: require_truncation.calculateMaxToolCallInputChars(params.maxContextTokens),
+		indexTokenCountMap: params.indexTokenCountMap,
+		tokenCounter: params.tokenCounter
+	});
+}
 function createPruneMessages(factoryParams) {
 	const providerFamily = factoryParams.provider == null ? void 0 : require_providerRegistry.getProviderFamily(factoryParams.provider);
 	const usesBedrockThinking = factoryParams.provider === "bedrock" || providerFamily === "bedrock";
@@ -926,12 +1048,43 @@ function createPruneMessages(factoryParams) {
 	let calibrationRatio = factoryParams.calibrationRatio != null && factoryParams.calibrationRatio > 0 ? factoryParams.calibrationRatio : 1;
 	let bestInstructionOverhead;
 	const reconciledLegacyAiMessages = /* @__PURE__ */ new WeakSet();
+	const canonicalizedToolCallMessages = /* @__PURE__ */ new WeakSet();
 	let bestVarianceAbs = Infinity;
 	let bestInstructionEstimate;
 	const originalToolContent = /* @__PURE__ */ new Map();
 	let originalToolContentSize = 0;
+	const canonicalByProjection = /* @__PURE__ */ new WeakMap();
+	let fadingTier = require_fading.seedFadingTier(factoryParams.maxTokens, factoryParams.fadingTier);
+	let restoredTierPending = require_fading.isFadingTier(factoryParams.fadingTier);
+	let maxToolExchangeWidth = 1;
+	let toolExchangeWidthThrough = 0;
+	let toolExchangeWidthSources = [];
+	let fadedThrough = 0;
+	let maskedThrough = 0;
 	const contextPruningSettings = require_contextPruningSettings.resolveContextPruningSettings(factoryParams.contextPruningConfig);
 	return function pruneMessages(params) {
+		const suppliedCanonicalMessages = params.canonicalMessages;
+		const derivesCanonicalHistory = suppliedCanonicalMessages == null;
+		const canonicalMessages = suppliedCanonicalMessages ?? params.messages.map((message) => {
+			const recovered = canonicalByProjection.get(message);
+			if (recovered != null) return recovered;
+			return Array.isArray(message.content) ? require_cache.cloneMessage(message, [...message.content]) : message;
+		});
+		const priorWidthLength = toolExchangeWidthSources.length;
+		if (derivesCanonicalHistory ? canonicalMessages.length < priorWidthLength || toolExchangeWidthSources.some((source, index) => canonicalMessages[index] !== source) : canonicalMessages.length < priorWidthLength || (params.canonicalPrefixStable === true ? priorWidthLength > 0 && canonicalMessages[priorWidthLength - 1] !== toolExchangeWidthSources[priorWidthLength - 1] : toolExchangeWidthSources.some((source, index) => canonicalMessages[index] !== source))) {
+			maxToolExchangeWidth = 1;
+			toolExchangeWidthThrough = 0;
+			toolExchangeWidthSources = [];
+			fadedThrough = 0;
+			maskedThrough = 0;
+			originalToolContent.clear();
+			originalToolContentSize = 0;
+		}
+		for (let i = toolExchangeWidthThrough; i < canonicalMessages.length; i++) {
+			maxToolExchangeWidth = Math.max(maxToolExchangeWidth, getToolCallIds(canonicalMessages[i]).size);
+			toolExchangeWidthSources[i] = canonicalMessages[i];
+		}
+		toolExchangeWidthThrough = canonicalMessages.length;
 		let newOriginalToolContent;
 		if (params.messages.length === 0) {
 			const emptyInstructionTokens = factoryParams.getInstructionTokens?.() ?? 0;
@@ -945,6 +1098,7 @@ function createPruneMessages(factoryParams) {
 				prePruneContextTokens: 0,
 				remainingContextTokens: Math.max(0, emptyBudget - emptyInstructionTokens - emptyReplyPrimerTokens),
 				calibrationRatio,
+				fadingTier,
 				resolvedInstructionOverhead: bestInstructionOverhead,
 				contextBudget: emptyBudget,
 				effectiveInstructionTokens: emptyInstructionTokens
@@ -987,14 +1141,33 @@ function createPruneMessages(factoryParams) {
 		};
 		for (let i = 0; i < params.messages.length; i++) {
 			let message = params.messages[i];
-			const cachedCount = indexTokenCountMap[i];
+			let cachedCount = indexTokenCountMap[i];
 			const messageType = message.getType();
 			const messageRole = message.role;
-			if ((messageType === "ai" || messageRole === "assistant" ? readPropertyWithoutAccessors(message.additional_kwargs, "function_call") : void 0)?.found === true && !reconciledLegacyAiMessages.has(message)) {
-				const [projected] = projectToolCallInputs([message], calculateMaxToolCallInputChars(factoryParams.maxTokens));
+			const isAssistant = messageType === "ai" || messageRole === "assistant";
+			if (isAssistant && !canonicalizedToolCallMessages.has(message)) {
+				const [canonicalized] = projectToolCallInputs([message], require_truncation.HARD_MAX_TOOL_CALL_INPUT_CHARS);
+				if (canonicalized !== message) {
+					message = canonicalized;
+					params.messages[i] = message;
+					const canonicalizedCount = factoryParams.tokenCounter(message);
+					indexTokenCountMap[i] = canonicalizedCount;
+					totalTokens += canonicalizedCount - (cachedCount ?? 0);
+					cachedCount = canonicalizedCount;
+					if (i >= lastTurnStartIndex) newOutputs.add(i);
+				}
+				canonicalizedToolCallMessages.add(message);
+			}
+			if ((isAssistant ? readPropertyWithoutAccessors(message.additional_kwargs, "function_call") : void 0)?.found === true && !reconciledLegacyAiMessages.has(message)) {
+				const [projected] = projectToolCallInputs([message], require_truncation.calculateMaxToolCallInputChars(factoryParams.maxTokens));
 				if (projected !== message) {
 					message = projected;
 					params.messages[i] = message;
+					const projectedCount = factoryParams.tokenCounter(message);
+					indexTokenCountMap[i] = projectedCount;
+					totalTokens += projectedCount - (cachedCount ?? 0);
+					cachedCount = projectedCount;
+					if (i >= lastTurnStartIndex) newOutputs.add(i);
 				}
 				reconciledLegacyAiMessages.add(message);
 				if (cachedCount !== void 0 || i < lastTurnStartIndex) applyReconciledCount(i, cachedCount, factoryParams.tokenCounter(message));
@@ -1081,15 +1254,6 @@ function createPruneMessages(factoryParams) {
 		const pruningBudget = factoryParams.maxTokens - reserveTokens;
 		const effectiveMaxTokens = Math.max(0, pruningBudget - currentInstructionTokens);
 		let calibratedTotalTokens = Math.round(totalTokens * calibrationRatio);
-		factoryParams.log?.("debug", "Budget", {
-			maxTokens: factoryParams.maxTokens,
-			pruningBudget,
-			effectiveMax: effectiveMaxTokens,
-			instructionTokens: currentInstructionTokens,
-			messageCount: params.messages.length,
-			calibratedTotalTokens,
-			calibrationRatio: Math.round(calibrationRatio * 100) / 100
-		});
 		if (effectiveMaxTokens === 0 && factoryParams.summarizationEnabled === true && params.messages.length > 0) {
 			factoryParams.log?.("warn", "Instructions consume entire budget — yielding all messages for summarization", {
 				instructionTokens: currentInstructionTokens,
@@ -1105,81 +1269,102 @@ function createPruneMessages(factoryParams) {
 				remainingContextTokens: 0,
 				contextPressure: pruningBudget > 0 ? calibratedTotalTokens / pruningBudget : 0,
 				calibrationRatio,
+				fadingTier,
 				resolvedInstructionOverhead: bestInstructionOverhead,
 				contextBudget: pruningBudget,
 				effectiveInstructionTokens: currentInstructionTokens
 			};
 		}
-		totalTokens = sumTokenCounts(indexTokenCountMap, params.messages.length);
-		calibratedTotalTokens = Math.round(totalTokens * calibrationRatio);
-		const contextPressure = pruningBudget > 0 ? calibratedTotalTokens / pruningBudget : 0;
-		let preFlightResultCount = 0;
-		let preFlightInputCount = 0;
-		let observationsMasked = 0;
-		if (contextPressure >= PRESSURE_THRESHOLD_MASKING) {
-			const rawMessageBudget = calibrationRatio > 0 ? Math.floor(effectiveMaxTokens / calibrationRatio) : effectiveMaxTokens;
-			const reserveHeadroom = factoryParams.summarizationEnabled === true ? Math.floor(rawMessageBudget * (factoryParams.reserveRatio ?? .05) * .5) : 0;
-			observationsMasked = maskConsumedToolResults({
+		const storeOriginalToolContent = (index, content) => {
+			originalToolContentSize += content.length;
+			if (newOriginalToolContent == null) newOriginalToolContent = /* @__PURE__ */ new Map();
+			newOriginalToolContent.set(index, content);
+			while (originalToolContentSize > 2e6 && originalToolContent.size > 0) {
+				const oldest = originalToolContent.keys().next();
+				if (oldest.done === true) break;
+				const removed = originalToolContent.get(oldest.value);
+				if (removed != null) originalToolContentSize -= removed.length;
+				originalToolContent.delete(oldest.value);
+			}
+		};
+		let restoredFading = {
+			truncated: 0,
+			inputs: 0,
+			masked: 0,
+			consumedBoundary: 0
+		};
+		if (restoredTierPending) {
+			restoredFading = applyFadingCaps({
 				messages: params.messages,
+				canonicalMessages,
 				indexTokenCountMap,
 				tokenCounter: factoryParams.tokenCounter,
-				availableRawBudget: rawMessageBudget + reserveHeadroom,
+				caps: require_fading.resolveFadingCaps(fadingTier, factoryParams.maxToolResultChars),
+				masked: fadingTier.masked,
 				originalContentStore: factoryParams.summarizationEnabled === true ? originalToolContent : void 0,
-				onContentStored: factoryParams.summarizationEnabled === true ? (index, content) => {
-					originalToolContentSize += content.length;
-					if (newOriginalToolContent == null) newOriginalToolContent = /* @__PURE__ */ new Map();
-					newOriginalToolContent.set(index, content);
-					while (originalToolContentSize > 2e6 && originalToolContent.size > 0) {
-						const oldest = originalToolContent.keys().next();
-						if (oldest.done === true) break;
-						const removed = originalToolContent.get(oldest.value);
-						if (removed != null) originalToolContentSize -= removed.length;
-						originalToolContent.delete(oldest.value);
-					}
-				} : void 0
+				onContentStored: factoryParams.summarizationEnabled === true ? storeOriginalToolContent : void 0
 			});
-			if (observationsMasked > 0) {
-				cumulativeRawSent = 0;
-				cumulativeProviderReported = 0;
-			}
+			fadedThrough = params.messages.length;
+			maskedThrough = restoredFading.consumedBoundary;
+			restoredTierPending = false;
 		}
-		if (contextPressure >= PRESSURE_THRESHOLD_MASKING && factoryParams.summarizationEnabled !== true) {
-			const budgetFactor = PRESSURE_BANDS.find(([threshold]) => contextPressure >= threshold)?.[1] ?? 1;
-			const baseBudget = Math.max(1024, Math.floor(effectiveMaxTokens * budgetFactor));
-			preFlightResultCount = preFlightTruncateToolResults({
-				messages: params.messages,
-				maxContextTokens: baseBudget,
-				indexTokenCountMap,
-				tokenCounter: factoryParams.tokenCounter
-			});
-			preFlightInputCount = preFlightTruncateToolCallInputs({
+		totalTokens = sumTokenCounts(indexTokenCountMap, params.messages.length);
+		calibratedTotalTokens = Math.round(totalTokens * calibrationRatio);
+		const contextPressure = pruningBudget > 0 ? calibratedTotalTokens / pruningBudget : 0;
+		factoryParams.log?.("debug", "Budget", {
+			maxTokens: factoryParams.maxTokens,
+			pruningBudget,
+			effectiveMax: effectiveMaxTokens,
+			instructionTokens: currentInstructionTokens,
+			messageCount: params.messages.length,
+			calibratedTotalTokens,
+			calibrationRatio: Math.round(calibrationRatio * 100) / 100
+		});
+		const fade = (signals) => {
+			const nextTier = require_fading.resolveFadingTier(fadingTier, factoryParams.maxTokens, signals, factoryParams.maxToolResultChars);
+			if (nextTier !== fadingTier) {
+				fadingTier = nextTier;
+				fadedThrough = 0;
+				maskedThrough = 0;
+			}
+			const result = applyFadingCaps({
 				messages: params.messages,
-				maxContextTokens: baseBudget,
+				canonicalMessages,
 				indexTokenCountMap,
-				tokenCounter: factoryParams.tokenCounter
+				tokenCounter: factoryParams.tokenCounter,
+				caps: require_fading.resolveFadingCaps(fadingTier, factoryParams.maxToolResultChars),
+				masked: fadingTier.masked,
+				fromIndex: fadedThrough,
+				maskedFromIndex: maskedThrough,
+				originalContentStore: factoryParams.summarizationEnabled === true ? originalToolContent : void 0,
+				onContentStored: factoryParams.summarizationEnabled === true ? storeOriginalToolContent : void 0
 			});
+			fadedThrough = params.messages.length;
+			maskedThrough = result.consumedBoundary;
+			return result;
+		};
+		const fadingSignals = {
+			contextPressure,
+			effectiveRawTokens: calibrationRatio > 0 ? Math.floor(effectiveMaxTokens / calibrationRatio) : effectiveMaxTokens,
+			summarizationEnabled: factoryParams.summarizationEnabled === true,
+			toolExchangeWidth: maxToolExchangeWidth
+		};
+		const faded = fade(fadingSignals);
+		const observationsMasked = restoredFading.masked + faded.masked;
+		const preFlightResultCount = restoredFading.truncated + faded.truncated;
+		const preFlightInputCount = restoredFading.inputs + faded.inputs;
+		if (observationsMasked > 0) {
+			cumulativeRawSent = 0;
+			cumulativeProviderReported = 0;
 		}
 		if (factoryParams.contextPruningConfig?.enabled === true && factoryParams.summarizationEnabled !== true) require_contextPruning.applyContextPruning({
 			messages: params.messages,
+			canonicalMessages,
 			indexTokenCountMap,
 			tokenCounter: factoryParams.tokenCounter,
 			resolvedSettings: contextPruningSettings
 		});
-		const rawSpaceEffectiveMax = calibrationRatio > 0 ? Math.round(effectiveMaxTokens / calibrationRatio) : effectiveMaxTokens;
-		if (factoryParams.summarizationEnabled === true && rawSpaceEffectiveMax > 0) {
-			preFlightResultCount = preFlightTruncateToolResults({
-				messages: params.messages,
-				maxContextTokens: rawSpaceEffectiveMax,
-				indexTokenCountMap,
-				tokenCounter: factoryParams.tokenCounter
-			});
-			preFlightInputCount = preFlightTruncateToolCallInputs({
-				messages: params.messages,
-				maxContextTokens: rawSpaceEffectiveMax,
-				indexTokenCountMap,
-				tokenCounter: factoryParams.tokenCounter
-			});
-		}
+		if (derivesCanonicalHistory) for (let i = 0; i < params.messages.length; i++) canonicalByProjection.set(params.messages[i], canonicalMessages[i]);
 		const preTruncationTotalTokens = totalTokens;
 		totalTokens = sumTokenCounts(indexTokenCountMap, params.messages.length);
 		calibratedTotalTokens = Math.round(totalTokens * calibrationRatio);
@@ -1204,6 +1389,7 @@ function createPruneMessages(factoryParams) {
 			originalToolContent: originalToolContent.size > 0 ? originalToolContent : void 0,
 			newOriginalToolContent,
 			calibrationRatio,
+			fadingTier,
 			resolvedInstructionOverhead: bestInstructionOverhead,
 			contextBudget: pruningBudget,
 			effectiveInstructionTokens: currentInstructionTokens
@@ -1242,96 +1428,36 @@ function createPruneMessages(factoryParams) {
 		let context = repairedContext;
 		let reclaimedTokens = initialReclaimedTokens;
 		if (droppedMessages.length > 0) appendItems(messagesToRefine, droppedMessages);
-		if (context.length === 0 && params.messages.length > 0 && effectiveMaxTokens > 0 && factoryParams.summarizationEnabled === true) {
-			const fadingBudget = Math.max(1024, effectiveMaxTokens);
-			factoryParams.log?.("debug", "Fallback fading — empty context with summarization", {
-				messageCount: params.messages.length,
-				effectiveMaxTokens,
-				fadingBudget
-			});
-			const fadedMessages = [...params.messages];
-			const preFadingTokenCounts = {};
-			for (let i = 0; i < params.messages.length; i++) preFadingTokenCounts[i] = indexTokenCountMap[i];
-			preFlightTruncateToolResults({
-				messages: fadedMessages,
-				maxContextTokens: fadingBudget,
-				indexTokenCountMap,
-				tokenCounter: factoryParams.tokenCounter
-			});
-			preFlightTruncateToolCallInputs({
-				messages: fadedMessages,
-				maxContextTokens: fadingBudget,
-				indexTokenCountMap,
-				tokenCounter: factoryParams.tokenCounter
-			});
-			const fadingRetry = getMessagesWithinTokenLimit({
-				maxContextTokens: pruningBudget,
-				messages: fadedMessages,
-				indexTokenCountMap,
-				startType: params.startType,
-				thinkingEnabled: factoryParams.thinkingEnabled,
-				tokenCounter: factoryParams.tokenCounter,
-				instructionTokens: currentInstructionTokens,
-				reasoningType: usesBedrockThinking ? "reasoning_content" : "thinking",
-				thinkingStartIndex: factoryParams.thinkingEnabled === true ? runThinkingStartIndex : void 0
-			});
-			const fadingRepaired = repairOrphanedToolMessages({
-				context: fadingRetry.context,
-				allMessages: fadedMessages,
-				tokenCounter: factoryParams.tokenCounter,
-				indexTokenCountMap
-			});
-			if (fadingRepaired.context.length > 0) {
-				context = fadingRepaired.context;
-				reclaimedTokens = fadingRepaired.reclaimedTokens;
-				appendItems(messagesToRefine, fadingRetry.messagesToRefine);
-				if (fadingRepaired.droppedMessages.length > 0) appendItems(messagesToRefine, fadingRepaired.droppedMessages);
-				factoryParams.log?.("debug", "Fallback fading recovered context", {
-					contextLength: context.length,
-					messagesToRefineCount: messagesToRefine.length,
-					remainingTokens: fadingRetry.remainingContextTokens
-				});
-				for (const [key, value] of Object.entries(preFadingTokenCounts)) indexTokenCountMap[key] = value;
-			} else for (const [key, value] of Object.entries(preFadingTokenCounts)) indexTokenCountMap[key] = value;
-		}
 		if (context.length === 0 && params.messages.length > 0 && effectiveMaxTokens > 0) {
 			const perMessageTokenBudget = Math.floor(effectiveMaxTokens / Math.max(1, params.messages.length));
 			const emergencyMaxChars = Math.max(200, perMessageTokenBudget * 4);
+			const emergencyTier = require_fading.resolveFadingTier(fadingTier, factoryParams.maxTokens, {
+				...fadingSignals,
+				minRung: require_fading.fadingRungForExchangeChars(factoryParams.maxTokens, emergencyMaxChars, factoryParams.maxToolResultChars)
+			}, factoryParams.maxToolResultChars);
+			const emergencyCaps = require_fading.resolveFadingCaps(emergencyTier, factoryParams.maxToolResultChars);
 			factoryParams.log?.("warn", "Empty context, entering emergency truncation", {
 				messageCount: params.messages.length,
 				effectiveMax: effectiveMaxTokens,
-				emergencyMaxChars
+				emergencyMaxChars,
+				budgetTokens: emergencyCaps.budgetTokens
 			});
 			const emergencyMessages = [...params.messages];
 			const preEmergencyTokenCounts = {};
 			for (let i = 0; i < params.messages.length; i++) preEmergencyTokenCounts[i] = indexTokenCountMap[i];
 			try {
-				let emergencyTruncatedCount = 0;
-				for (let i = 0; i < emergencyMessages.length; i++) {
-					const message = emergencyMessages[i];
-					if (message.getType() === "tool" && !require_toolContent.isComputerCallOutputMessage(message)) {
-						const content = message.content;
-						if (require_toolContent.getToolContentCharLength(content) > emergencyMaxChars) {
-							const compacted = require_toolContent.compactToolContent(content, emergencyMaxChars);
-							if (!compacted.changed) continue;
-							const cloned = require_toolContent.cloneToolMessageWithContent(message, compacted.content);
-							emergencyMessages[i] = cloned;
-							indexTokenCountMap[i] = factoryParams.tokenCounter(cloned);
-							emergencyTruncatedCount++;
-						}
-					}
-				}
-				const projectedToolInputs = projectToolCallInputs(emergencyMessages, emergencyMaxChars);
-				if (projectedToolInputs !== emergencyMessages) for (let i = 0; i < emergencyMessages.length; i++) {
-					if (projectedToolInputs[i] === emergencyMessages[i]) continue;
-					emergencyMessages[i] = projectedToolInputs[i];
-					indexTokenCountMap[i] = factoryParams.tokenCounter(projectedToolInputs[i]);
-					emergencyTruncatedCount++;
-				}
+				const emergency = applyFadingCaps({
+					messages: emergencyMessages,
+					canonicalMessages,
+					indexTokenCountMap,
+					tokenCounter: factoryParams.tokenCounter,
+					caps: emergencyCaps,
+					masked: emergencyTier.masked
+				});
 				factoryParams.log?.("info", "Emergency truncation complete");
 				factoryParams.log?.("debug", "Emergency truncation details", {
-					truncatedCount: emergencyTruncatedCount,
-					emergencyMaxChars
+					truncatedCount: emergency.truncated + emergency.inputs + emergency.masked,
+					budgetTokens: emergencyCaps.budgetTokens
 				});
 				const retryResult = getMessagesWithinTokenLimit({
 					maxContextTokens: pruningBudget,
@@ -1352,6 +1478,7 @@ function createPruneMessages(factoryParams) {
 				});
 				context = repaired.context;
 				reclaimedTokens = repaired.reclaimedTokens;
+				messagesToRefine.length = 0;
 				appendItems(messagesToRefine, retryResult.messagesToRefine);
 				if (repaired.droppedMessages.length > 0) appendItems(messagesToRefine, repaired.droppedMessages);
 				factoryParams.log?.("debug", "Emergency truncation retry result", {
@@ -1377,6 +1504,7 @@ function createPruneMessages(factoryParams) {
 			originalToolContent: originalToolContent.size > 0 ? originalToolContent : void 0,
 			newOriginalToolContent,
 			calibrationRatio,
+			fadingTier,
 			resolvedInstructionOverhead: bestInstructionOverhead,
 			contextBudget: pruningBudget,
 			effectiveInstructionTokens: currentInstructionTokens
@@ -1389,7 +1517,7 @@ exports.CALIBRATION_RATIO_MIN = CALIBRATION_RATIO_MIN;
 exports.DEFAULT_RESERVE_RATIO = DEFAULT_RESERVE_RATIO;
 exports.ORIGINAL_CONTENT_MAX_CHARS = ORIGINAL_CONTENT_MAX_CHARS;
 exports.REPLY_PRIMER_TOKENS = REPLY_PRIMER_TOKENS;
-exports.calculateMaxToolCallInputChars = calculateMaxToolCallInputChars;
+exports.applyFadingCaps = applyFadingCaps;
 exports.calculateTotalTokens = calculateTotalTokens;
 exports.checkValidNumber = checkValidNumber;
 exports.clampCalibrationRatio = clampCalibrationRatio;