@librechat/agents 3.7.7 → 3.7.9

package/dist/cjs/messages/format.cjs

@@ -1,3 +1,4 @@
+const require_constants = require("../common/constants.cjs");
 require("../common/enum.cjs");
 require("../common/index.cjs");
 const require_truncation = require("../utils/truncation.cjs");
@@ -5,6 +6,7 @@ const require_toolContent = require("../utils/toolContent.cjs");
 const require_provenance = require("./provenance.cjs");
 const require_langchain = require("./langchain.cjs");
 const require_toolResultTypes = require("./toolResultTypes.cjs");
+const require_semanticIndex = require("../summarization/semanticIndex.cjs");
 const require_message_inputs = require("../llm/anthropic/utils/message_inputs.cjs");
 const require_content = require("./content.cjs");
 const require_events = require("../utils/events.cjs");
@@ -140,6 +142,356 @@ function getToolUseId(part) {
 	if (!("tool_use_id" in part) || typeof part.tool_use_id !== "string") return;
 	return part.tool_use_id;
 }
+const DERIVED_SEMANTIC_HEAD_LIMIT = require_constants.COMPACTION_SEMANTIC_INDEX_LIMITS.maxInputEntries / 4;
+const DERIVED_SEMANTIC_TAIL_LIMIT = require_constants.COMPACTION_SEMANTIC_INDEX_LIMITS.maxInputEntries / 2;
+const DERIVED_SEMANTIC_TYPE_EDGE_LIMIT = require_constants.COMPACTION_SEMANTIC_INDEX_LIMITS.maxInputEntries / 32;
+const DERIVED_SEMANTIC_TYPE_HASH = Object.freeze({
+	tool_intent: 1,
+	tool_outcome: 2,
+	activity_phase: 3,
+	reasoning_label: 4
+});
+function createDerivedCompactionSemanticIndexCollector(baseSnapshot) {
+	const collector = {
+		entries: [],
+		entryCount: 0,
+		baseEntryCount: 0,
+		omittedBaseEntryCount: 0
+	};
+	let baseEntries;
+	let serializedProvidedEntryCount;
+	try {
+		baseEntries = baseSnapshot?.entries;
+		serializedProvidedEntryCount = baseSnapshot?.providedEntryCount;
+	} catch {
+		return collector;
+	}
+	const snapshot = require_semanticIndex.snapshotCompactionSemanticIndex(baseEntries);
+	if (snapshot == null) return collector;
+	const snapshotProvidedEntryCount = require_semanticIndex.getCompactionSemanticIndexProvidedEntryCount(snapshot);
+	collector.omittedBaseEntryCount = Math.max(0, (typeof serializedProvidedEntryCount === "number" && Number.isSafeInteger(serializedProvidedEntryCount) && serializedProvidedEntryCount >= snapshotProvidedEntryCount && serializedProvidedEntryCount != null ? serializedProvidedEntryCount : snapshotProvidedEntryCount) - snapshot.length);
+	for (let index = 0; index < snapshot.length; index++) appendDerivedCompactionSemanticEntry(collector, snapshot[index], true);
+	collector.baseEntryCount = collector.entryCount;
+	return collector;
+}
+function createCompactionSemanticCoverageState() {
+	return {
+		head: [],
+		tail: {
+			entries: [],
+			cursor: 0
+		},
+		latestByIdentityHash: /* @__PURE__ */ new Map(),
+		typeCoverage: /* @__PURE__ */ new Map()
+	};
+}
+function getDerivedCompactionSemanticLocalId(entry) {
+	if (entry.type === "reasoning_label") return entry.reasoningStepId.trim();
+	if (entry.type !== "activity_phase") return entry.toolCallId.trim();
+	return "";
+}
+function hashDerivedCompactionSemanticIdentityString(initialHash, value) {
+	let hash = initialHash;
+	for (let index = 0; index < value.length; index++) {
+		hash ^= value.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return hash;
+}
+function hashDerivedCompactionSemanticIdentity(entry) {
+	let hash = 2166136261 ^ DERIVED_SEMANTIC_TYPE_HASH[entry.type];
+	hash = Math.imul(hash, 16777619);
+	hash = hashDerivedCompactionSemanticIdentityString(hash, entry.sourceMessageId.trim());
+	hash ^= entry.sourceContentIndex;
+	hash = Math.imul(hash, 16777619);
+	hash = hashDerivedCompactionSemanticIdentityString(hash, getDerivedCompactionSemanticLocalId(entry));
+	return hash >>> 0;
+}
+function entriesShareDerivedCompactionSemanticIdentity(left, right) {
+	return left.type === right.type && left.sourceMessageId.trim() === right.sourceMessageId.trim() && left.sourceContentIndex === right.sourceContentIndex && getDerivedCompactionSemanticLocalId(left) === getDerivedCompactionSemanticLocalId(right);
+}
+function entriesHaveConflictingSemanticState(left, right) {
+	return left.status !== right.status || left.redacted === true !== (right.redacted === true) || left.text.replace(/\s+/g, " ").trim() !== right.text.replace(/\s+/g, " ").trim();
+}
+function findCompactionSemanticRevisionFloor(collector, entry, identityHash) {
+	return collector.baseRevisionFloors?.get(identityHash)?.find((floor) => entriesShareDerivedCompactionSemanticIdentity(floor.entry, entry));
+}
+function seedCompactionSemanticRevisionFloor(collector, entry, order) {
+	collector.baseRevisionFloors ??= /* @__PURE__ */ new Map();
+	const identityHash = hashDerivedCompactionSemanticIdentity(entry);
+	const existing = findCompactionSemanticRevisionFloor(collector, entry, identityHash);
+	if (existing != null) {
+		if (entry.revision > existing.entry.revision) {
+			existing.entry = entry;
+			existing.order = order;
+		}
+		return;
+	}
+	const floor = {
+		entry,
+		order
+	};
+	const bucket = collector.baseRevisionFloors.get(identityHash);
+	if (bucket == null) {
+		collector.baseRevisionFloors.set(identityHash, [floor]);
+		return;
+	}
+	bucket.push(floor);
+}
+function updateCompactionSemanticRevisionFloor(collector, orderedEntry) {
+	const floor = findCompactionSemanticRevisionFloor(collector, orderedEntry.entry, orderedEntry.identityHash);
+	if (floor == null || orderedEntry.entry.revision <= floor.entry.revision) return;
+	floor.entry = orderedEntry.entry;
+	floor.order = orderedEntry.order;
+}
+function shouldRejectCompactionSemanticEntryBelowBaseFloor(collector, orderedEntry) {
+	const floor = findCompactionSemanticRevisionFloor(collector, orderedEntry.entry, orderedEntry.identityHash);
+	if (floor == null || orderedEntry.order === floor.order) return false;
+	if ((collector.coverage?.latestByIdentityHash.get(orderedEntry.identityHash))?.find(({ entry }) => entriesShareDerivedCompactionSemanticIdentity(entry, orderedEntry.entry)) != null) return false;
+	return orderedEntry.entry.revision <= floor.entry.revision;
+}
+function retainCompactionSemanticEntry(entry) {
+	entry.retentionCount++;
+}
+function releaseCompactionSemanticEntry(coverage, entry) {
+	entry.retentionCount--;
+	if (entry.retentionCount === 0 && coverage.latestByIdentityHash.has(entry.identityHash)) {
+		const bucket = coverage.latestByIdentityHash.get(entry.identityHash);
+		if (bucket == null) return;
+		const entryIndex = bucket.indexOf(entry);
+		if (entryIndex >= 0) bucket.splice(entryIndex, 1);
+		if (bucket.length === 0) coverage.latestByIdentityHash.delete(entry.identityHash);
+	}
+}
+function appendCompactionSemanticEntryRing(coverage, ring, entry, limit) {
+	if (ring.entries.length < limit) {
+		ring.entries.push(entry);
+		retainCompactionSemanticEntry(entry);
+		return;
+	}
+	releaseCompactionSemanticEntry(coverage, ring.entries[ring.cursor]);
+	ring.entries[ring.cursor] = entry;
+	retainCompactionSemanticEntry(entry);
+	ring.cursor = (ring.cursor + 1) % limit;
+}
+function renewCompactionSemanticEntryRing(coverage, ring, entry, limit) {
+	const existingIndex = ring.entries.indexOf(entry);
+	if (existingIndex < 0) {
+		appendCompactionSemanticEntryRing(coverage, ring, entry, limit);
+		return;
+	}
+	if (ring.entries.length < limit) {
+		ring.entries.splice(existingIndex, 1);
+		ring.entries.push(entry);
+		return;
+	}
+	const newestIndex = (ring.cursor + ring.entries.length - 1) % ring.entries.length;
+	let currentIndex = existingIndex;
+	for (let offset = 0; currentIndex !== newestIndex && offset < ring.entries.length; offset++) {
+		const nextIndex = (currentIndex + 1) % ring.entries.length;
+		ring.entries[currentIndex] = ring.entries[nextIndex];
+		currentIndex = nextIndex;
+	}
+	ring.entries[newestIndex] = entry;
+}
+function renewCoverageBalancedCompactionSemanticEntry(coverage, entry) {
+	renewCompactionSemanticEntryRing(coverage, coverage.tail, entry, DERIVED_SEMANTIC_TAIL_LIMIT);
+	const typeCoverage = coverage.typeCoverage.get(entry.entry.type);
+	if (typeCoverage == null) return;
+	renewCompactionSemanticEntryRing(coverage, typeCoverage.tail, entry, DERIVED_SEMANTIC_TYPE_EDGE_LIMIT);
+}
+function appendDerivedCompactionSemanticEntry(collector, entry, baseEntry = false) {
+	let boundedEntry = entry;
+	if (entry.status === "pending") boundedEntry = {
+		...entry,
+		text: ""
+	};
+	else if (entry.text.length > require_constants.COMPACTION_SEMANTIC_INDEX_LIMITS.maxInputTextChars) boundedEntry = {
+		...entry,
+		text: "",
+		redacted: true
+	};
+	const order = collector.entryCount;
+	collector.entryCount++;
+	if (collector.coverage == null && collector.entries.length < require_constants.COMPACTION_SEMANTIC_INDEX_LIMITS.maxInputEntries) {
+		collector.entries.push(boundedEntry);
+		if (!baseEntry && collector.baseRevisionFloors != null) updateCompactionSemanticRevisionFloor(collector, {
+			entry: boundedEntry,
+			identityHash: hashDerivedCompactionSemanticIdentity(boundedEntry),
+			order,
+			retentionCount: 0
+		});
+		return;
+	}
+	const orderedEntry = {
+		entry: boundedEntry,
+		identityHash: hashDerivedCompactionSemanticIdentity(boundedEntry),
+		order,
+		retentionCount: 0
+	};
+	if (collector.coverage == null) {
+		for (let order = 0; order < collector.baseEntryCount; order++) seedCompactionSemanticRevisionFloor(collector, collector.entries[order], order);
+		collector.coverage = createCompactionSemanticCoverageState();
+		for (let order = 0; order < collector.entries.length; order++) {
+			const bufferedEntry = {
+				entry: collector.entries[order],
+				identityHash: hashDerivedCompactionSemanticIdentity(collector.entries[order]),
+				order,
+				retentionCount: 0
+			};
+			if (shouldRejectCompactionSemanticEntryBelowBaseFloor(collector, bufferedEntry)) continue;
+			appendCoverageBalancedCompactionSemanticEntry(collector.coverage, bufferedEntry);
+			if (order >= collector.baseEntryCount) updateCompactionSemanticRevisionFloor(collector, bufferedEntry);
+		}
+		collector.entries = [];
+	}
+	if (!baseEntry && shouldRejectCompactionSemanticEntryBelowBaseFloor(collector, orderedEntry)) return;
+	appendCoverageBalancedCompactionSemanticEntry(collector.coverage, orderedEntry);
+	if (!baseEntry) updateCompactionSemanticRevisionFloor(collector, orderedEntry);
+}
+function appendCoverageBalancedCompactionSemanticEntry(coverage, orderedEntry) {
+	const identityHash = orderedEntry.identityHash;
+	const identityBucket = coverage.latestByIdentityHash.get(identityHash);
+	const current = identityBucket?.find(({ entry }) => entriesShareDerivedCompactionSemanticIdentity(entry, orderedEntry.entry));
+	if (current != null) {
+		if (orderedEntry.entry.revision < current.entry.revision) return;
+		if (orderedEntry.entry.revision === current.entry.revision) {
+			if (entriesHaveConflictingSemanticState(current.entry, orderedEntry.entry)) {
+				current.entry = {
+					...current.entry,
+					text: "",
+					redacted: true
+				};
+				current.order = orderedEntry.order;
+				renewCoverageBalancedCompactionSemanticEntry(coverage, current);
+			}
+			return;
+		}
+		current.entry = orderedEntry.entry;
+		current.order = orderedEntry.order;
+		renewCoverageBalancedCompactionSemanticEntry(coverage, current);
+		return;
+	}
+	if (identityBucket == null) coverage.latestByIdentityHash.set(identityHash, [orderedEntry]);
+	else identityBucket.push(orderedEntry);
+	if (coverage.head.length < DERIVED_SEMANTIC_HEAD_LIMIT) {
+		coverage.head.push(orderedEntry);
+		retainCompactionSemanticEntry(orderedEntry);
+	}
+	appendCompactionSemanticEntryRing(coverage, coverage.tail, orderedEntry, DERIVED_SEMANTIC_TAIL_LIMIT);
+	let typeCoverage = coverage.typeCoverage.get(orderedEntry.entry.type);
+	if (typeCoverage == null) {
+		typeCoverage = {
+			head: [],
+			tail: {
+				entries: [],
+				cursor: 0
+			}
+		};
+		coverage.typeCoverage.set(orderedEntry.entry.type, typeCoverage);
+	}
+	if (typeCoverage.head.length < DERIVED_SEMANTIC_TYPE_EDGE_LIMIT) {
+		typeCoverage.head.push(orderedEntry);
+		retainCompactionSemanticEntry(orderedEntry);
+	}
+	appendCompactionSemanticEntryRing(coverage, typeCoverage.tail, orderedEntry, DERIVED_SEMANTIC_TYPE_EDGE_LIMIT);
+}
+function finalizeDerivedCompactionSemanticIndexSnapshot(collector) {
+	if (collector == null || collector.entryCount === 0 && collector.omittedBaseEntryCount === 0) return;
+	const providedEntryCount = Math.min(Number.MAX_SAFE_INTEGER, collector.entryCount + collector.omittedBaseEntryCount);
+	if (collector.coverage == null) {
+		require_semanticIndex.setCompactionSemanticIndexProvidedEntryCount(collector.entries, providedEntryCount);
+		return {
+			entries: collector.entries,
+			providedEntryCount
+		};
+	}
+	const retained = /* @__PURE__ */ new Map();
+	const retain = (entries) => {
+		for (const { entry, order } of entries) retained.set(order, entry);
+	};
+	retain(collector.coverage.head);
+	retain(collector.coverage.tail.entries);
+	for (const typeCoverage of collector.coverage.typeCoverage.values()) {
+		retain(typeCoverage.head);
+		retain(typeCoverage.tail.entries);
+	}
+	const result = [...retained.entries()].sort(([left], [right]) => left - right).map(([, entry]) => entry);
+	require_semanticIndex.setCompactionSemanticIndexProvidedEntryCount(result, providedEntryCount);
+	return {
+		entries: result,
+		providedEntryCount
+	};
+}
+function collectCompactionSemanticEntriesFromPart(collector, part, sourceMessageId, sourceContentIndex, retainedSourceContentStart, retainedSourceContentEnd, intentToolNames, parsedToolInput) {
+	if (sourceMessageId.length > require_constants.COMPACTION_SEMANTIC_INDEX_LIMITS.maxIdentityChars) return;
+	if (part.type === "tool_call") {
+		if (sourceContentIndex < 0 || sourceContentIndex > require_constants.COMPACTION_SEMANTIC_INDEX_LIMITS.maxSourceContentIndex) return;
+		const toolCall = part.tool_call;
+		const toolCallId = toolCall?.id;
+		if (typeof toolCallId !== "string" || toolCallId === "" || toolCallId.length > require_constants.COMPACTION_SEMANTIC_INDEX_LIMITS.maxIdentityChars) return;
+		if (typeof toolCall.name === "string" && intentToolNames?.has(toolCall.name) === true) {
+			const intent = parsedToolInput != null && typeof parsedToolInput === "object" && !Array.isArray(parsedToolInput) ? parsedToolInput.intent : void 0;
+			if (typeof intent === "string" && intent !== "") appendDerivedCompactionSemanticEntry(collector, {
+				type: "tool_intent",
+				sourceMessageId,
+				sourceContentIndex,
+				revision: 0,
+				status: "committed",
+				text: intent,
+				toolCallId
+			});
+		}
+		if (typeof toolCall.outcome === "string" && toolCall.outcome !== "") appendDerivedCompactionSemanticEntry(collector, {
+			type: "tool_outcome",
+			sourceMessageId,
+			sourceContentIndex,
+			revision: 0,
+			status: "committed",
+			text: toolCall.outcome,
+			toolCallId
+		});
+		return;
+	}
+	if (part.type === "think") {
+		if (sourceContentIndex < 0 || sourceContentIndex > require_constants.COMPACTION_SEMANTIC_INDEX_LIMITS.maxSourceContentIndex) return;
+		const reasoningStepId = part.reasoning_label_step_id;
+		const revision = part.reasoning_label_revision;
+		const status = part.reasoning_label_status;
+		const text = part.reasoning_label;
+		if (typeof reasoningStepId !== "string" || reasoningStepId === "" || reasoningStepId.length > require_constants.COMPACTION_SEMANTIC_INDEX_LIMITS.maxIdentityChars || typeof revision !== "number" || !Number.isSafeInteger(revision) || revision < 0) return;
+		const malformedState = status !== "complete" && status !== "streaming" || typeof text !== "string";
+		appendDerivedCompactionSemanticEntry(collector, {
+			type: "reasoning_label",
+			sourceMessageId,
+			sourceContentIndex,
+			revision,
+			status: status === "streaming" || malformedState ? "pending" : "committed",
+			text: typeof text === "string" ? text : "",
+			reasoningStepId,
+			...malformedState ? { redacted: true } : {}
+		});
+		return;
+	}
+	if (part.type !== "activity_label" || part.activity_label_type !== "phase") return;
+	const activitySourceContentIndex = part.activity_start_index;
+	if (typeof activitySourceContentIndex !== "number" || !Number.isSafeInteger(activitySourceContentIndex) || activitySourceContentIndex < retainedSourceContentStart || activitySourceContentIndex >= retainedSourceContentEnd || activitySourceContentIndex > require_constants.COMPACTION_SEMANTIC_INDEX_LIMITS.maxSourceContentIndex) return;
+	const revision = part.activity_label_revision;
+	if (revision !== void 0 && (typeof revision !== "number" || !Number.isSafeInteger(revision) || revision < 0)) return;
+	const malformedPending = part.pending !== void 0 && typeof part.pending !== "boolean";
+	const malformedText = typeof part.activity_label !== "string";
+	const malformedState = malformedPending || malformedText;
+	const text = typeof part.activity_label === "string" ? part.activity_label : "";
+	appendDerivedCompactionSemanticEntry(collector, {
+		type: "activity_phase",
+		sourceMessageId,
+		sourceContentIndex: activitySourceContentIndex,
+		revision: revision ?? 0,
+		status: part.pending === true || malformedPending ? "pending" : "committed",
+		text,
+		...malformedState ? { redacted: true } : {}
+	});
+}
 function collectTrustedToolResultSourceContentPartIndices(content, sourceContentPartOffset) {
 	if (content == null) return;
 	let calls;
@@ -295,6 +647,10 @@ function formatAssistantMessage(message, options) {
 	const emittedServerToolUseIds = /* @__PURE__ */ new Set();
 	const pendingServerToolUses = /* @__PURE__ */ new Map();
 	const shouldPreserveReasoningContent = options?.preserveReasoningContent === true;
+	const compactionSemanticIndex = options?.compactionSemanticIndex;
+	const semanticSourceMessageId = compactionSemanticIndex != null && options?.sourceMessageId != null && options.sourceMessageId.length <= require_constants.COMPACTION_SEMANTIC_INDEX_LIMITS.maxIdentityChars ? options.sourceMessageId : void 0;
+	const retainedSourceContentStart = options?.sourceContentPartOffset ?? 0;
+	const retainedSourceContentEnd = options?.retainedSourceContentEnd ?? retainedSourceContentStart;
 	const serverToolResultIds = /* @__PURE__ */ new Set();
 	const preferredToolCallParts = /* @__PURE__ */ new Map();
 	const takePendingReasoningContent = () => {
@@ -353,6 +709,7 @@ function formatAssistantMessage(message, options) {
 		for (let partIndex = 0; partIndex < contentParts.length; partIndex++) {
 			const part = contentParts[partIndex];
 			if (part == null) continue;
+			if (part.type === "activity_label") continue;
 			const isTrustedResult = isTrustedServerToolResult(part, getSourcePartIndices(partIndex), options?.toolSourceContentPartIndices);
 			if (isTrustedResult) {
 				trustedServerToolResultPartIndices ??= /* @__PURE__ */ new Set();
@@ -374,6 +731,10 @@ function formatAssistantMessage(message, options) {
 			const part = contentParts[partIndex];
 			if (part == null) continue;
 			const sourcePartIndices = getSourcePartIndices(partIndex);
+			if (part.type === "activity_label") {
+				if (compactionSemanticIndex != null && semanticSourceMessageId != null && typeof sourcePartIndices === "number") collectCompactionSemanticEntriesFromPart(compactionSemanticIndex, part, semanticSourceMessageId, sourcePartIndices, retainedSourceContentStart, retainedSourceContentEnd, options?.intentToolNames);
+				continue;
+			}
 			const toolUseId = getToolUseId(part);
 			if (toolUseId != null) {
 				const isServerToolResult = trustedServerToolResultPartIndices?.has(partIndex) === true;
@@ -418,12 +779,14 @@ function formatAssistantMessage(message, options) {
 				if (options?.provider === "anthropic" && typeof _tool_call.id === "string" && _tool_call.id.startsWith("srvtoolu_")) {
 					if (!serverToolResultIds.has(_tool_call.id) && options.preserveUnpairedServerToolUses !== true) continue;
 					if (emittedServerToolUseIds.has(_tool_call.id) || pendingServerToolUses.has(_tool_call.id)) continue;
+					const serverToolInput = parseServerToolInput(_args);
+					if (compactionSemanticIndex != null && semanticSourceMessageId != null && typeof sourcePartIndices === "number") collectCompactionSemanticEntriesFromPart(compactionSemanticIndex, part, semanticSourceMessageId, sourcePartIndices, retainedSourceContentStart, retainedSourceContentEnd, options.intentToolNames, serverToolInput);
 					pendingServerToolUses.set(_tool_call.id, {
 						content: {
 							type: "server_tool_use",
 							id: _tool_call.id,
 							name: _tool_call.name,
-							input: parseServerToolInput(_args)
+							input: serverToolInput
 						},
 						sourceContentPartIndices: sourcePartIndices
 					});
@@ -442,6 +805,7 @@ function formatAssistantMessage(message, options) {
 					if (typeof _args === "string") args = { input: _args };
 				}
 				tool_call.args = args;
+				if (compactionSemanticIndex != null && semanticSourceMessageId != null && typeof sourcePartIndices === "number") collectCompactionSemanticEntriesFromPart(compactionSemanticIndex, part, semanticSourceMessageId, sourcePartIndices, retainedSourceContentStart, retainedSourceContentEnd, options?.intentToolNames, args);
 				if (options?.provider === "anthropic" && Array.isArray(lastAIMessage.content)) {
 					const content = lastAIMessage.content;
 					content.push({
@@ -461,6 +825,7 @@ function formatAssistantMessage(message, options) {
 					content: formatToolCallOutput(output)
 				}), "tool"), "tool", sourcePartIndices);
 			} else if (part.type === "think" || part.type === "thinking" || part.type === "reasoning" || part.type === "reasoning_content" || part.type === "redacted_thinking") {
+				if (part.type === "think" && compactionSemanticIndex != null && semanticSourceMessageId != null && typeof sourcePartIndices === "number") collectCompactionSemanticEntriesFromPart(compactionSemanticIndex, part, semanticSourceMessageId, sourcePartIndices, retainedSourceContentStart, retainedSourceContentEnd, options?.intentToolNames);
 				hasReasoning = true;
 				pendingReasoningContent += extractReasoningContent(part);
 				appendSourceContentPartIndices(pendingReasoningSourcePartIndices, sourcePartIndices);
@@ -487,7 +852,7 @@ function formatAssistantMessage(message, options) {
 				hasReasoning = false;
 				pendingReasoningContent = "";
 				pendingReasoningSourcePartIndices = [];
-			} else if (part.type === "error" || part.type === "agent_update" || part.type === "summary" || part.type === "activity_label") continue;
+			} else if (part.type === "error" || part.type === "agent_update" || part.type === "summary") continue;
 			else {
 				if (part.type === "text" && !getTextContent(part).trim()) continue;
 				currentContent.push(part);
@@ -764,6 +1129,7 @@ function extractSkillName(args) {
 const formatAgentMessages = (payload, indexTokenCountMap, tools, skills, options) => {
 	const messages = [];
 	const legacyContentEnabled = options?.legacyContent === true;
+	const compactionSemanticIndexCollector = options?.compactionSemanticIndex != null ? createDerivedCompactionSemanticIndexCollector(options.compactionSemanticIndex.baseSnapshot) : void 0;
 	const emitFormattedMessage = (message) => {
 		if (legacyContentEnabled && require_content.isLegacyConvertible(message)) {
 			const flattened = require_content.flattenLegacyContent(message.content);
@@ -914,9 +1280,12 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools, skills, options
 			}
 		}
 		const formattedMessages = formatAssistantMessage(processedMessage, {
+			compactionSemanticIndex: compactionSemanticIndexCollector,
+			intentToolNames: options?.compactionSemanticIndex?.intentToolNames,
 			preserveUnpairedServerToolUses: i === payload.length - 1,
 			preserveReasoningContent: options?.preserveReasoningContent ?? options?.provider === "deepseek",
 			provider: options?.provider,
+			retainedSourceContentEnd: sourceContentPartOffset + (Array.isArray(message.content) ? message.content.length : 0),
 			sourceMessageId,
 			sourceContentPartOffset,
 			sourceContentPartIndices: processedSourceContentPartIndices,
@@ -1036,6 +1405,7 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools, skills, options
 			updatedIndexTokenCountMap[resultIndices[lastIdx]] = tokenCount - distributed;
 		}
 	}
+	const compactionSemanticIndexSnapshot = finalizeDerivedCompactionSemanticIndexSnapshot(compactionSemanticIndexCollector);
 	return {
 		messages,
 		indexTokenCountMap: indexTokenCountMap ? updatedIndexTokenCountMap : void 0,
@@ -1043,7 +1413,9 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools, skills, options
 			text: summaryBoundary.text,
 			tokenCount: summaryBoundary.tokenCount
 		} : void 0,
-		boundaryTokenAdjustment
+		boundaryTokenAdjustment,
+		compactionSemanticIndex: compactionSemanticIndexSnapshot?.entries,
+		compactionSemanticIndexSnapshot
 	};
 };
 function shiftIndexTokenCountMap(indexTokenCountMap, instructionsTokenCount) {