@librechat/agents 3.3.2 → 3.3.4

package/dist/esm/messages/prune.mjs

@@ -1,10 +1,13 @@
 import "../common/enum.mjs";
 import "../common/index.mjs";
+import { calculateMaxToolResultChars, truncateToolResultContent } from "../utils/truncation.mjs";
+import { cloneToolMessageWithContent, compactToolContent, getToolContentCharLength, isComputerCallOutputMessage, serializeStructuredValueBounded, serializeToolContentBounded } from "../utils/toolContent.mjs";
+import { hasUnsafeStructuredSerialization } from "../utils/tokens.mjs";
 import { toLangChainContent } from "./langchain.mjs";
-import { calculateMaxToolResultChars, truncateToolInput, truncateToolResultContent } from "../utils/truncation.mjs";
 import { resolveContextPruningSettings } from "./contextPruningSettings.mjs";
 import { applyContextPruning } from "./contextPruning.mjs";
 import { AIMessage, ToolMessage } from "@langchain/core/messages";
+import { isProxy } from "node:util/types";
 //#region src/messages/prune.ts
 function sumTokenCounts(tokenMap, count) {
 	let total = 0;
@@ -13,6 +16,8 @@ function sumTokenCounts(tokenMap, count) {
 }
 /** 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. */
@@ -55,7 +60,8 @@ function clampCalibrationRatio(ratio) {
 	return Math.max(CALIBRATION_RATIO_MIN, Math.min(5, ratio));
 }
 function getToolCallIds(message) {
-	if (message.getType() !== "ai") return /* @__PURE__ */ new Set();
+	const messageRole = message.role;
+	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);
@@ -64,8 +70,26 @@ function getToolCallIds(message) {
 		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 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);
+	}
 	return ids;
 }
+function getResponsesToolOutputSource(message) {
+	const responseOutput = readPropertyWithoutAccessors(message.response_metadata, "output");
+	if (!responseOutput.accessor && Array.isArray(responseOutput.value) && !isProxy(responseOutput.value) && responseOutput.value.length > 0) return {
+		source: "response_metadata",
+		items: responseOutput.value
+	};
+	const fallbackOutput = readPropertyWithoutAccessors(message.additional_kwargs, "tool_outputs");
+	if (!fallbackOutput.accessor && Array.isArray(fallbackOutput.value) && !isProxy(fallbackOutput.value)) return {
+		source: "tool_outputs",
+		items: fallbackOutput.value
+	};
+}
 function getToolResultId(message) {
 	if (message.getType() !== "tool") return null;
 	const toolMessage = message;
@@ -109,7 +133,8 @@ function repairOrphanedToolMessages({ context, allMessages, tokenCounter, indexT
 			repairedContext.push(message);
 			continue;
 		}
-		if (message.getType() === "ai" && message instanceof AIMessage) {
+		const messageRole = message.role;
+		if (message.getType() === "ai" || messageRole === "assistant") {
 			const toolCallIds = getToolCallIds(message);
 			if (toolCallIds.size > 0) {
 				let hasOrphanToolCalls = false;
@@ -153,22 +178,33 @@ function repairOrphanedToolMessages({ context, allMessages, tokenCounter, indexT
 * Returns null if the message has no content left after stripping.
 */
 function stripOrphanToolUseBlocks(message, presentToolResultIds) {
-	const keptToolCalls = (message.tool_calls ?? []).filter((tc) => typeof tc.id === "string" && presentToolResultIds.has(tc.id));
+	const aiMessage = message;
+	const keptToolCalls = (aiMessage.tool_calls ?? []).filter((tc) => typeof tc.id === "string" && presentToolResultIds.has(tc.id));
 	let keptContent;
-	if (Array.isArray(message.content)) {
-		const filtered = message.content.filter((block) => {
-			if (typeof block !== "object") return true;
-			const record = block;
-			if ((record.type === "tool_use" || record.type === "tool_call") && typeof record.id === "string") return presentToolResultIds.has(record.id);
-			return true;
-		});
-		if (filtered.length === 0) return null;
-		keptContent = filtered;
-	} else keptContent = message.content;
-	return new AIMessage({
-		...message,
+	if (Array.isArray(aiMessage.content)) keptContent = aiMessage.content.filter((block) => {
+		if (typeof block !== "object") return true;
+		const record = block;
+		if ((record.type === "tool_use" || record.type === "tool_call") && typeof record.id === "string") return presentToolResultIds.has(record.id);
+		return true;
+	});
+	else keptContent = aiMessage.content;
+	const toolOutputSource = getResponsesToolOutputSource(message);
+	const keptToolOutputs = toolOutputSource?.items.filter((item) => {
+		if (item == null || typeof item !== "object") return true;
+		const record = item;
+		if (record.type !== "function_call" && record.type !== "custom_tool_call" && record.type !== "computer_call") return true;
+		return typeof record.call_id === "string" && presentToolResultIds.has(record.call_id);
+	}) ?? [];
+	if (keptToolCalls.length === 0 && Array.isArray(keptContent) && keptContent.length === 0 && keptToolOutputs.length === 0) return null;
+	let responseMetadata = message.response_metadata;
+	let additionalKwargs = message.additional_kwargs;
+	if (toolOutputSource?.source === "response_metadata") responseMetadata = cloneWithProjectedProperties(responseMetadata, { output: keptToolOutputs });
+	else if (toolOutputSource?.source === "tool_outputs") additionalKwargs = cloneWithProjectedProperties(additionalKwargs, { tool_outputs: keptToolOutputs });
+	return cloneWithProjectedProperties(message, {
 		content: toLangChainContent(keptContent),
-		tool_calls: keptToolCalls.length > 0 ? keptToolCalls : void 0
+		tool_calls: keptToolCalls.length > 0 ? keptToolCalls : void 0,
+		response_metadata: responseMetadata,
+		additional_kwargs: additionalKwargs
 	});
 }
 /**
@@ -186,11 +222,12 @@ function stripOrphanToolUseBlocks(message, presentToolResultIds) {
 * 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) {
+function sanitizeOrphanToolBlocks(messages, onMessageCloned) {
 	const allToolCallIds = /* @__PURE__ */ new Set();
 	const allToolResultIds = /* @__PURE__ */ new Set();
 	for (const msg of messages) {
 		const msgAny = msg;
+		if (typeof msg.getType === "function") for (const id of getToolCallIds(msg)) allToolCallIds.add(id);
 		const toolCalls = msgAny.tool_calls;
 		if (Array.isArray(toolCalls)) {
 			for (const tc of toolCalls) if (typeof tc.id === "string" && tc.id.length > 0 && !tc.id.startsWith("srvtoolu_")) allToolCallIds.add(tc.id);
@@ -227,6 +264,7 @@ function sanitizeOrphanToolBlocks(messages) {
 					const stripped = stripOrphanToolUseBlocks(msg, allToolResultIds);
 					if (stripped != null) {
 						strippedAiIndices.add(result.length);
+						onMessageCloned?.(msg, stripped);
 						result.push(stripped);
 					}
 					continue;
@@ -242,6 +280,7 @@ function sanitizeOrphanToolBlocks(messages) {
 				const patched = Object.create(Object.getPrototypeOf(msg), Object.getOwnPropertyDescriptors(msg));
 				patched.tool_calls = keptToolCalls.length > 0 ? keptToolCalls : [];
 				patched.content = keptContent;
+				onMessageCloned?.(msg, patched);
 				result.push(patched);
 				continue;
 			}
@@ -536,26 +575,21 @@ function maskConsumedToolResults(params) {
 	for (let c = 0; c < count; c++) {
 		const i = consumedIndices[c];
 		const message = messages[i];
+		if (isComputerCallOutputMessage(message)) continue;
 		const content = message.content;
-		if (typeof content !== "string") continue;
 		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;
-		if (content.length <= maxChars) continue;
+		const compacted = compactToolContent(content, maxChars);
+		if (!compacted.changed) continue;
 		if (params.originalContentStore && !params.originalContentStore.has(i)) {
-			params.originalContentStore.set(i, content);
-			if (params.onContentStored) params.onContentStored(i, content);
+			const original = serializeToolContentBounded(content, ORIGINAL_CONTENT_MAX_CHARS);
+			params.originalContentStore.set(i, original);
+			if (params.onContentStored) params.onContentStored(i, original);
 		}
-		const cloned = new ToolMessage({
-			content: truncateToolResultContent(content, maxChars),
-			tool_call_id: message.tool_call_id,
-			name: message.name,
-			id: message.id,
-			additional_kwargs: message.additional_kwargs,
-			response_metadata: message.response_metadata
-		});
+		const cloned = cloneToolMessageWithContent(message, compacted.content);
 		messages[i] = cloned;
 		indexTokenCountMap[i] = tokenCounter(cloned);
 		maskedCount++;
@@ -578,23 +612,15 @@ function preFlightTruncateToolResults(params) {
 	const baseMaxChars = calculateMaxToolResultChars(maxContextTokens);
 	let truncatedCount = 0;
 	const toolIndices = [];
-	for (let i = 0; i < messages.length; i++) if (messages[i].getType() === "tool") toolIndices.push(i);
+	for (let i = 0; i < messages.length; i++) if (messages[i].getType() === "tool" && !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;
-		if (typeof content !== "string") continue;
 		const recencyFactor = .2 + .8 * (toolIndices.length > 1 ? t / (toolIndices.length - 1) : 1);
-		const maxChars = Math.max(200, Math.floor(baseMaxChars * recencyFactor));
-		if (content.length <= maxChars) continue;
-		const cloned = new ToolMessage({
-			content: truncateToolResultContent(content, maxChars),
-			tool_call_id: message.tool_call_id,
-			name: message.name,
-			id: message.id,
-			additional_kwargs: message.additional_kwargs,
-			response_metadata: message.response_metadata
-		});
+		const compacted = compactToolContent(content, Math.max(200, Math.floor(baseMaxChars * recencyFactor)));
+		if (!compacted.changed) continue;
+		const cloned = cloneToolMessageWithContent(message, compacted.content);
 		messages[i] = cloned;
 		indexTokenCountMap[i] = tokenCounter(cloned);
 		truncatedCount++;
@@ -614,46 +640,385 @@ function preFlightTruncateToolResults(params) {
 *
 * @returns The number of AI messages that had tool_use inputs truncated.
 */
-function preFlightTruncateToolCallInputs(params) {
-	const { messages, maxContextTokens, indexTokenCountMap, tokenCounter } = params;
-	const maxInputChars = Math.min(Math.floor(maxContextTokens * .15) * 4, 2e5);
-	let truncatedCount = 0;
-	for (let i = 0; i < messages.length; i++) {
-		const message = messages[i];
-		if (message.getType() !== "ai") continue;
-		if (!Array.isArray(message.content)) continue;
-		const originalContent = message.content;
-		const state = { changed: false };
-		const newContent = originalContent.map((block) => {
-			if (typeof block !== "object") return block;
-			const record = block;
-			if (record.type !== "tool_use" && record.type !== "tool_call") return block;
-			const input = record.input;
-			if (input == null) return block;
-			const serialized = typeof input === "string" ? input : JSON.stringify(input);
-			if (serialized.length <= maxInputChars) return block;
-			state.changed = true;
+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));
+}
+function readPropertyWithoutAccessors(value, key) {
+	let current = value;
+	for (let depth = 0; current != null && depth < 100; depth++) {
+		if (isProxy(current)) return {
+			found: true,
+			own: current === value,
+			accessor: true
+		};
+		let descriptor;
+		try {
+			descriptor = Object.getOwnPropertyDescriptor(current, key);
+		} catch {
 			return {
-				...record,
-				input: truncateToolInput(serialized, maxInputChars)
+				found: true,
+				own: current === value,
+				accessor: true
+			};
+		}
+		if (descriptor != null) {
+			if (!("value" in descriptor)) return {
+				found: true,
+				own: current === value,
+				accessor: true
 			};
-		});
-		if (!state.changed) continue;
-		const aiMsg = message;
-		const newToolCalls = (aiMsg.tool_calls ?? []).map((tc) => {
-			const serializedArgs = JSON.stringify(tc.args);
-			if (serializedArgs.length <= maxInputChars) return tc;
 			return {
-				...tc,
-				args: truncateToolInput(serializedArgs, maxInputChars)
+				found: true,
+				own: current === value,
+				accessor: false,
+				value: descriptor.value
+			};
+		}
+		try {
+			current = Object.getPrototypeOf(current);
+		} catch {
+			return {
+				found: true,
+				own: false,
+				accessor: true
+			};
+		}
+	}
+	return current == null ? {
+		found: false,
+		own: false,
+		accessor: false
+	} : {
+		found: true,
+		own: false,
+		accessor: true
+	};
+}
+function cloneWithProjectedProperties(value, changes) {
+	const descriptors = Object.getOwnPropertyDescriptors(value);
+	for (const [key, projectedValue] of Object.entries(changes)) {
+		const descriptor = descriptors[key];
+		descriptors[key] = {
+			configurable: descriptor?.configurable ?? true,
+			enumerable: descriptor?.enumerable ?? true,
+			value: projectedValue,
+			writable: descriptor?.writable ?? true
+		};
+	}
+	return Object.create(Object.getPrototypeOf(value), descriptors);
+}
+function createBoundedTruncationValue(preview, originalChars, maxChars) {
+	const normalizedMaxChars = normalizeToolInputLimit(maxChars);
+	if (JSON.stringify({
+		_truncated: "",
+		_originalChars: originalChars
+	}).length > normalizedMaxChars) return null;
+	let low = 0;
+	let high = Math.min(preview.length, normalizedMaxChars);
+	while (low < high) {
+		const next = Math.ceil((low + high) / 2);
+		const candidate = {
+			_truncated: preview.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),
+		_originalChars: originalChars
+	};
+}
+function projectToolInputWithinLimit(input, maxChars) {
+	const normalizedMaxChars = normalizeToolInputLimit(maxChars);
+	const serialized = serializeStructuredValueBounded(input, normalizedMaxChars);
+	if (serialized.truncated) return {
+		value: createBoundedTruncationValue(serialized.content, serialized.originalChars, normalizedMaxChars),
+		changed: true
+	};
+	if (!hasUnsafeStructuredSerialization(input)) return {
+		value: input,
+		changed: false
+	};
+	try {
+		return {
+			value: JSON.parse(serialized.content),
+			changed: true
+		};
+	} catch {
+		return {
+			value: createBoundedTruncationValue(serialized.content, serialized.originalChars, normalizedMaxChars),
+			changed: true
+		};
+	}
+}
+/**
+* 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);
+	if (!serialized.truncated) return serialized.content === "undefined" ? "null" : serialized.content;
+	const fallback = createBoundedTruncationValue(serialized.content, serialized.originalChars, normalizedMaxChars);
+	return JSON.stringify(fallback);
+}
+function projectKnownInputProperty(value, key, maxChars, changes) {
+	const property = readPropertyWithoutAccessors(value, key);
+	if (!property.found) return;
+	const projected = property.accessor ? {
+		value: ACCESSOR_INPUT_PLACEHOLDER,
+		changed: true
+	} : projectToolInputWithinLimit(property.value, maxChars);
+	if (projected.changed || !property.own) changes[key] = projected.value;
+}
+function getStringProperty(value, key) {
+	const property = readPropertyWithoutAccessors(value, key);
+	return !property.accessor && typeof property.value === "string" ? property.value : void 0;
+}
+function projectInlineToolInput(block, maxChars) {
+	const type = getStringProperty(block, "type");
+	if (type !== "tool_use" && type !== "tool_call") return block;
+	const changes = {};
+	projectKnownInputProperty(block, "input", maxChars, changes);
+	projectKnownInputProperty(block, "args", maxChars, changes);
+	const nestedProperty = readPropertyWithoutAccessors(block, "tool_call");
+	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);
+		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;
+}
+function projectSerializedArguments(value, maxChars) {
+	const normalizedMaxChars = normalizeToolInputLimit(maxChars);
+	if (typeof value === "string" && value.length <= normalizedMaxChars) return {
+		value,
+		changed: false
+	};
+	return {
+		value: serializeToolCallInput(value, normalizedMaxChars),
+		changed: true
+	};
+}
+function selectProjectedSerializedArguments(property, canonical, maxChars) {
+	if (canonical != null) return {
+		value: canonical,
+		changed: property.value !== canonical
+	};
+	if (property.accessor) return {
+		value: serializeToolCallInput(ACCESSOR_INPUT_PLACEHOLDER, maxChars),
+		changed: true
+	};
+	return projectSerializedArguments(property.value, maxChars);
+}
+function projectRawOpenAIToolCalls(rawToolCalls, maxChars, canonicalArguments) {
+	if (!Array.isArray(rawToolCalls)) return {
+		value: rawToolCalls,
+		changed: false
+	};
+	const state = { changed: false };
+	const projected = rawToolCalls.map((rawToolCall) => {
+		if (rawToolCall == null || typeof rawToolCall !== "object") return rawToolCall;
+		const functionProperty = readPropertyWithoutAccessors(rawToolCall, "function");
+		if (!functionProperty.found || functionProperty.accessor || functionProperty.value == null || typeof functionProperty.value !== "object") return rawToolCall;
+		const argsProperty = readPropertyWithoutAccessors(functionProperty.value, "arguments");
+		if (!argsProperty.found) return rawToolCall;
+		const callId = getStringProperty(rawToolCall, "id");
+		const projectedArgs = selectProjectedSerializedArguments(argsProperty, callId != null ? canonicalArguments.get(callId) : void 0, maxChars);
+		if (!projectedArgs.changed && functionProperty.own && argsProperty.own) return rawToolCall;
+		state.changed = true;
+		return cloneWithProjectedProperties(rawToolCall, { function: cloneWithProjectedProperties(functionProperty.value, { arguments: projectedArgs.value }) });
+	});
+	return {
+		value: state.changed ? projected : rawToolCalls,
+		changed: state.changed
+	};
+}
+function projectLegacyFunctionCall(property, maxChars) {
+	if (!property.found) return {
+		value: property.value,
+		changed: false
+	};
+	if (property.own && !property.accessor && property.value === void 0) return {
+		value: void 0,
+		changed: false
+	};
+	if (property.accessor || !property.own || property.value == null || typeof property.value !== "object") return {
+		value: void 0,
+		changed: true
+	};
+	const nameProperty = readPropertyWithoutAccessors(property.value, "name");
+	const argsProperty = readPropertyWithoutAccessors(property.value, "arguments");
+	if (nameProperty.accessor || !nameProperty.own || typeof nameProperty.value !== "string" || nameProperty.value === "" || nameProperty.value.length > normalizeToolInputLimit(maxChars) || !argsProperty.found || argsProperty.accessor || !argsProperty.own) return {
+		value: void 0,
+		changed: true
+	};
+	try {
+		const prototype = Object.getPrototypeOf(property.value);
+		const enumerableKeys = Object.keys(property.value);
+		if ((prototype === Object.prototype || prototype === null) && enumerableKeys.length === 2 && enumerableKeys.includes("name") && enumerableKeys.includes("arguments") && typeof argsProperty.value === "string" && argsProperty.value.length <= normalizeToolInputLimit(maxChars) && !hasUnsafeStructuredSerialization(property.value)) return {
+			value: property.value,
+			changed: false
+		};
+	} catch {
+		return {
+			value: void 0,
+			changed: true
+		};
+	}
+	const projectedArgs = selectProjectedSerializedArguments(argsProperty, void 0, maxChars);
+	return {
+		value: {
+			name: nameProperty.value,
+			arguments: projectedArgs.value
+		},
+		changed: true
+	};
+}
+function projectResponsesOutput(output, maxChars, canonicalArguments, canonicalInputs) {
+	if (!Array.isArray(output)) return {
+		value: output,
+		changed: false
+	};
+	const state = { changed: false };
+	const projected = output.map((item) => {
+		if (item == null || typeof item !== "object") return item;
+		const type = getStringProperty(item, "type");
+		if (type !== "function_call" && type !== "custom_tool_call" && type !== "computer_call") return item;
+		let inputKey = "action";
+		if (type === "function_call") inputKey = "arguments";
+		else if (type === "custom_tool_call") inputKey = "input";
+		const inputProperty = readPropertyWithoutAccessors(item, inputKey);
+		if (!inputProperty.found) return item;
+		const callId = getStringProperty(item, "call_id") ?? getStringProperty(item, "id");
+		let projectedInput;
+		if (type === "function_call") projectedInput = selectProjectedSerializedArguments(inputProperty, callId != null ? canonicalArguments.get(callId) : void 0, maxChars);
+		else {
+			const canonicalArgs = callId != null ? canonicalInputs.get(callId) : void 0;
+			const canonicalProperty = canonicalArgs != null && typeof canonicalArgs === "object" ? readPropertyWithoutAccessors(canonicalArgs, inputKey) : void 0;
+			let source = inputProperty.accessor ? ACCESSOR_INPUT_PLACEHOLDER : inputProperty.value;
+			if (canonicalProperty != null && canonicalProperty.found) source = canonicalProperty.accessor ? ACCESSOR_INPUT_PLACEHOLDER : canonicalProperty.value;
+			if (type === "custom_tool_call" && typeof source === "string" && source.length <= normalizeToolInputLimit(maxChars)) projectedInput = {
+				value: source,
+				changed: !inputProperty.own || inputProperty.value !== source
 			};
+			else if (type === "custom_tool_call") {
+				const value = typeof source === "string" ? truncateToolResultContent(source, normalizeToolInputLimit(maxChars)) : serializeToolCallInput(source, maxChars);
+				projectedInput = {
+					value,
+					changed: !inputProperty.own || inputProperty.value !== value
+				};
+			} else {
+				const projected = projectToolInputWithinLimit(source, maxChars);
+				projectedInput = {
+					value: projected.value,
+					changed: projected.changed || !inputProperty.own || inputProperty.value !== projected.value
+				};
+			}
+		}
+		if (!projectedInput.changed && inputProperty.own) return item;
+		state.changed = true;
+		return cloneWithProjectedProperties(item, { [inputKey]: projectedInput.value });
+	});
+	return {
+		value: state.changed ? projected : output,
+		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;
+	for (let i = 0; i < messages.length; i++) {
+		const message = messages[i];
+		const messageRole = message.role;
+		if (message.getType() !== "ai" && messageRole !== "assistant") continue;
+		const aiMessage = message;
+		let projectedContent = aiMessage.content;
+		let contentChanged = false;
+		if (Array.isArray(aiMessage.content)) {
+			const originalContent = aiMessage.content;
+			const mappedContent = originalContent.map((block) => projectInlineToolInput(block, normalizedMaxInputChars));
+			contentChanged = mappedContent.some((block, blockIndex) => block !== originalContent[blockIndex]);
+			projectedContent = toLangChainContent(mappedContent);
+		}
+		const originalToolCalls = aiMessage.tool_calls ?? [];
+		const projectedToolCalls = originalToolCalls.map((toolCall) => {
+			const argsProperty = readPropertyWithoutAccessors(toolCall, "args");
+			const projected = argsProperty.accessor ? {
+				value: ACCESSOR_INPUT_PLACEHOLDER,
+				changed: true
+			} : projectToolInputWithinLimit(argsProperty.value, normalizedMaxInputChars);
+			if (argsProperty.own && !projected.changed) return toolCall;
+			return cloneWithProjectedProperties(toolCall, { args: projected.value });
 		});
-		messages[i] = new AIMessage({
-			...aiMsg,
-			content: toLangChainContent(newContent),
-			tool_calls: newToolCalls.length > 0 ? newToolCalls : void 0
+		const toolCallsChanged = projectedToolCalls.some((toolCall, toolCallIndex) => toolCall !== originalToolCalls[toolCallIndex]);
+		const rawAdditionalToolCallsProperty = readPropertyWithoutAccessors(aiMessage.additional_kwargs, "tool_calls");
+		const rawAdditionalToolCalls = rawAdditionalToolCallsProperty.accessor ? void 0 : rawAdditionalToolCallsProperty.value;
+		const rawResponsesOutputProperty = readPropertyWithoutAccessors(aiMessage.response_metadata, "output");
+		const rawResponsesOutput = rawResponsesOutputProperty.accessor ? void 0 : rawResponsesOutputProperty.value;
+		const canonicalArguments = /* @__PURE__ */ new Map();
+		const canonicalInputs = /* @__PURE__ */ new Map();
+		if (Array.isArray(rawAdditionalToolCalls) || Array.isArray(rawResponsesOutput)) for (const toolCall of projectedToolCalls) {
+			const id = getStringProperty(toolCall, "id");
+			if (id == null) continue;
+			const args = readPropertyWithoutAccessors(toolCall, "args");
+			const canonicalInput = args.accessor ? ACCESSOR_INPUT_PLACEHOLDER : args.value;
+			canonicalInputs.set(id, canonicalInput);
+			canonicalArguments.set(id, serializeToolCallInput(canonicalInput, normalizedMaxInputChars));
+		}
+		const additionalKwargsChanges = rawAdditionalToolCallsProperty.accessor ? { tool_calls: void 0 } : {};
+		const rawToolCalls = projectRawOpenAIToolCalls(rawAdditionalToolCalls, normalizedMaxInputChars, canonicalArguments);
+		if (rawToolCalls.changed) additionalKwargsChanges.tool_calls = rawToolCalls.value;
+		const legacyFunctionCall = projectLegacyFunctionCall(readPropertyWithoutAccessors(aiMessage.additional_kwargs, "function_call"), normalizedMaxInputChars);
+		if (legacyFunctionCall.changed) additionalKwargsChanges.function_call = legacyFunctionCall.value;
+		const additionalKwargsChanged = Object.keys(additionalKwargsChanges).length > 0;
+		let projectedAdditionalKwargs = aiMessage.additional_kwargs;
+		if (additionalKwargsChanged) projectedAdditionalKwargs = isProxy(aiMessage.additional_kwargs) ? { ...additionalKwargsChanges } : cloneWithProjectedProperties(aiMessage.additional_kwargs, additionalKwargsChanges);
+		let projectedResponseMetadata = aiMessage.response_metadata;
+		let responseMetadataChanged = rawResponsesOutputProperty.accessor;
+		const responsesOutput = projectResponsesOutput(rawResponsesOutput, normalizedMaxInputChars, canonicalArguments, canonicalInputs);
+		if (responsesOutput.changed || rawResponsesOutputProperty.accessor) {
+			const output = rawResponsesOutputProperty.accessor ? void 0 : responsesOutput.value;
+			projectedResponseMetadata = isProxy(aiMessage.response_metadata) ? { output } : cloneWithProjectedProperties(aiMessage.response_metadata, { output });
+			responseMetadataChanged = true;
+		}
+		if (!contentChanged && !toolCallsChanged && !additionalKwargsChanged && !responseMetadataChanged) continue;
+		const projectedMessage = cloneWithProjectedProperties(aiMessage, {
+			content: projectedContent,
+			tool_calls: projectedToolCalls.length > 0 ? projectedToolCalls : [],
+			additional_kwargs: projectedAdditionalKwargs,
+			response_metadata: projectedResponseMetadata
 		});
-		indexTokenCountMap[i] = tokenCounter(messages[i]);
+		projectedMessages ??= [...messages];
+		projectedMessages[i] = projectedMessage;
+	}
+	return projectedMessages ?? messages;
+}
+function preFlightTruncateToolCallInputs(params) {
+	const { messages, maxContextTokens, indexTokenCountMap, tokenCounter } = params;
+	const projected = projectToolCallInputs(messages, calculateMaxToolCallInputChars(maxContextTokens));
+	if (projected === messages) return 0;
+	let truncatedCount = 0;
+	for (let i = 0; i < messages.length; i++) {
+		if (projected[i] === messages[i]) continue;
+		messages[i] = projected[i];
+		indexTokenCountMap[i] = tokenCounter(projected[i]);
 		truncatedCount++;
 	}
 	return truncatedCount;
@@ -664,6 +1029,7 @@ function createPruneMessages(factoryParams) {
 	let lastCutOffIndex = 0;
 	let totalTokens = 0;
 	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). */
@@ -676,6 +1042,7 @@ function createPruneMessages(factoryParams) {
 	/** 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
@@ -696,12 +1063,13 @@ function createPruneMessages(factoryParams) {
 			const emptyInstructionTokens = factoryParams.getInstructionTokens?.() ?? 0;
 			const emptyReserveRatio = factoryParams.reserveRatio ?? .05;
 			const emptyBudget = factoryParams.maxTokens - (emptyReserveRatio > 0 && emptyReserveRatio < 1 ? Math.round(factoryParams.maxTokens * emptyReserveRatio) : 0);
+			const emptyReplyPrimerTokens = Math.round(3 * calibrationRatio);
 			return {
 				context: [],
 				indexTokenCountMap,
 				messagesToRefine: [],
 				prePruneContextTokens: 0,
-				remainingContextTokens: Math.max(0, emptyBudget - emptyInstructionTokens),
+				remainingContextTokens: Math.max(0, emptyBudget - emptyInstructionTokens - emptyReplyPrimerTokens),
 				calibrationRatio,
 				resolvedInstructionOverhead: bestInstructionOverhead,
 				contextBudget: emptyBudget,
@@ -731,6 +1099,45 @@ function createPruneMessages(factoryParams) {
 		let currentUsage;
 		if (params.usageMetadata && (checkValidNumber(params.usageMetadata.input_tokens) || checkValidNumber(params.usageMetadata.input_token_details) && (checkValidNumber(params.usageMetadata.input_token_details.cache_creation) || checkValidNumber(params.usageMetadata.input_token_details.cache_read))) && checkValidNumber(params.usageMetadata.output_tokens)) currentUsage = calculateTotalTokens(params.usageMetadata);
 		const newOutputs = /* @__PURE__ */ new Set();
+		const applyReconciledCount = (index, cachedCount, reconciledCount) => {
+			if (cachedCount === void 0) {
+				indexTokenCountMap[index] = reconciledCount;
+				totalTokens += reconciledCount;
+				if (index >= lastTurnStartIndex) newOutputs.add(index);
+				return;
+			}
+			if (reconciledCount <= cachedCount) return;
+			indexTokenCountMap[index] = reconciledCount;
+			totalTokens += reconciledCount - cachedCount;
+			if (index >= lastTurnStartIndex) newOutputs.add(index);
+		};
+		for (let i = 0; i < params.messages.length; i++) {
+			let message = params.messages[i];
+			const 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));
+				if (projected !== message) {
+					message = projected;
+					params.messages[i] = message;
+				}
+				reconciledLegacyAiMessages.add(message);
+				if (cachedCount !== void 0 || i < lastTurnStartIndex) applyReconciledCount(i, cachedCount, factoryParams.tokenCounter(message));
+				continue;
+			}
+			if (messageType !== "tool" || reconciledToolMessages.has(message)) continue;
+			if (!isComputerCallOutputMessage(message)) {
+				const normalized = compactToolContent(message.content, factoryParams.maxToolResultChars ?? 4e5);
+				if (normalized.changed) {
+					message = cloneToolMessageWithContent(message, normalized.content);
+					params.messages[i] = message;
+				}
+			}
+			const reconciledCount = factoryParams.tokenCounter(message);
+			reconciledToolMessages.add(message);
+			applyReconciledCount(i, cachedCount, reconciledCount);
+		}
 		let outputTokensAssigned = false;
 		for (let i = lastTurnStartIndex; i < params.messages.length; i++) {
 			const message = params.messages[i];
@@ -912,12 +1319,13 @@ function createPruneMessages(factoryParams) {
 			tokensSaved: preTruncationTotalTokens - totalTokens
 		});
 		lastTurnStartIndex = params.messages.length;
-		if (lastCutOffIndex === 0 && calibratedTotalTokens + currentInstructionTokens <= pruningBudget) return {
+		const calibratedReplyPrimerTokens = Math.round(3 * calibrationRatio);
+		if (lastCutOffIndex === 0 && calibratedTotalTokens + calibratedReplyPrimerTokens + currentInstructionTokens <= pruningBudget) return {
 			context: params.messages,
 			indexTokenCountMap,
 			messagesToRefine: [],
 			prePruneContextTokens: calibratedTotalTokens,
-			remainingContextTokens: pruningBudget - calibratedTotalTokens - currentInstructionTokens,
+			remainingContextTokens: pruningBudget - calibratedTotalTokens - calibratedReplyPrimerTokens - currentInstructionTokens,
 			contextPressure,
 			originalToolContent: originalToolContent.size > 0 ? originalToolContent : void 0,
 			newOriginalToolContent,
@@ -1027,60 +1435,24 @@ function createPruneMessages(factoryParams) {
 				let emergencyTruncatedCount = 0;
 				for (let i = 0; i < emergencyMessages.length; i++) {
 					const message = emergencyMessages[i];
-					if (message.getType() === "tool") {
+					if (message.getType() === "tool" && !isComputerCallOutputMessage(message)) {
 						const content = message.content;
-						if (typeof content === "string" && content.length > emergencyMaxChars) {
-							const cloned = new ToolMessage({
-								content: truncateToolResultContent(content, emergencyMaxChars),
-								tool_call_id: message.tool_call_id,
-								name: message.name,
-								id: message.id,
-								additional_kwargs: message.additional_kwargs,
-								response_metadata: message.response_metadata
-							});
+						if (getToolContentCharLength(content) > emergencyMaxChars) {
+							const compacted = compactToolContent(content, emergencyMaxChars);
+							if (!compacted.changed) continue;
+							const cloned = cloneToolMessageWithContent(message, compacted.content);
 							emergencyMessages[i] = cloned;
 							indexTokenCountMap[i] = factoryParams.tokenCounter(cloned);
 							emergencyTruncatedCount++;
 						}
 					}
-					if (message.getType() === "ai" && Array.isArray(message.content)) {
-						const aiMsg = message;
-						const contentBlocks = aiMsg.content;
-						if (contentBlocks.some((block) => {
-							if (typeof block !== "object") return false;
-							const record = block;
-							if ((record.type === "tool_use" || record.type === "tool_call") && record.input != null) return (typeof record.input === "string" ? record.input : JSON.stringify(record.input)).length > emergencyMaxChars;
-							return false;
-						})) {
-							const newContent = contentBlocks.map((block) => {
-								if (typeof block !== "object") return block;
-								const record = block;
-								if ((record.type === "tool_use" || record.type === "tool_call") && record.input != null) {
-									const serialized = typeof record.input === "string" ? record.input : JSON.stringify(record.input);
-									if (serialized.length > emergencyMaxChars) return {
-										...record,
-										input: truncateToolInput(serialized, emergencyMaxChars)
-									};
-								}
-								return block;
-							});
-							const newToolCalls = (aiMsg.tool_calls ?? []).map((tc) => {
-								const serializedArgs = JSON.stringify(tc.args);
-								if (serializedArgs.length > emergencyMaxChars) return {
-									...tc,
-									args: truncateToolInput(serializedArgs, emergencyMaxChars)
-								};
-								return tc;
-							});
-							emergencyMessages[i] = new AIMessage({
-								...aiMsg,
-								content: toLangChainContent(newContent),
-								tool_calls: newToolCalls.length > 0 ? newToolCalls : void 0
-							});
-							indexTokenCountMap[i] = factoryParams.tokenCounter(emergencyMessages[i]);
-							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++;
 				}
 				factoryParams.log?.("info", "Emergency truncation complete");
 				factoryParams.log?.("debug", "Emergency truncation details", {
@@ -1141,6 +1513,6 @@ function createPruneMessages(factoryParams) {
 	};
 }
 //#endregion
-export { CALIBRATION_RATIO_MAX, CALIBRATION_RATIO_MIN, DEFAULT_RESERVE_RATIO, ORIGINAL_CONTENT_MAX_CHARS, calculateTotalTokens, checkValidNumber, clampCalibrationRatio, createPruneMessages, enforceOriginalContentCap, getMessagesWithinTokenLimit, maskConsumedToolResults, preFlightTruncateToolCallInputs, preFlightTruncateToolResults, repairOrphanedToolMessages, sanitizeOrphanToolBlocks };
+export { CALIBRATION_RATIO_MAX, CALIBRATION_RATIO_MIN, DEFAULT_RESERVE_RATIO, ORIGINAL_CONTENT_MAX_CHARS, REPLY_PRIMER_TOKENS, calculateMaxToolCallInputChars, calculateTotalTokens, checkValidNumber, clampCalibrationRatio, createPruneMessages, enforceOriginalContentCap, getMessagesWithinTokenLimit, maskConsumedToolResults, preFlightTruncateToolCallInputs, preFlightTruncateToolResults, projectToolCallInputs, repairOrphanedToolMessages, sanitizeOrphanToolBlocks, serializeToolCallInput };
 
 //# sourceMappingURL=prune.mjs.map