@clinebot/core 0.0.35 → 0.0.37

package/src/session/message-builder.ts

@@ -0,0 +1,941 @@
+/**
+ * API-safe message builder for provider payloads.
+ *
+ * @see PLAN.md §3.1 — moved from `packages/agents/src/context/message-builder.ts`.
+ * @see PLAN.md §3.2.3 — public surface of `MessageBuilder`.
+ *
+ * Verbatim port: walks the conversation to produce provider-ready
+ * messages, handles tool-result truncation and outdated-file-content
+ * rewrite for compaction. Per-instance caches make this host state.
+ */
+
+import type * as LlmsProviders from "@clinebot/llms";
+import { normalizeUserInput } from "@clinebot/shared";
+
+const DEFAULT_MAX_TOOL_RESULT_CHARS = 50_000;
+const DEFAULT_MAX_TOTAL_TEXT_BYTES = 6_000_000;
+const MIN_TOTAL_BUDGET_TOOL_RESULT_BYTES = 8_000;
+const TARGET_TOOL_NAMES = new Set([
+	"read",
+	"read_files",
+	"search",
+	"search_codebase",
+	"bash",
+	"run_commands",
+]);
+const READ_TOOL_NAMES = new Set(["read", "read_files"]);
+const OUTDATED_FILE_CONTENT = "[outdated - see the latest file content]";
+
+interface ReadResultRecord {
+	toolUseId: string;
+	locators: ReadLocator[];
+}
+
+interface ReadLocator {
+	path: string;
+	startLine: number | null;
+	endLine: number | null;
+}
+
+/**
+ * Builds an API-safe message copy without mutating original conversation history.
+ */
+export class MessageBuilder {
+	private indexedMessageCount = 0;
+	private indexedTailRef: LlmsProviders.Message | undefined;
+	private readonly toolNameByIdCache = new Map<string, string>();
+	private readonly readLocatorsByToolUseIdCache = new Map<
+		string,
+		ReadLocator[]
+	>();
+	private readonly latestReadToolUseByLocatorCache = new Map<string, string>();
+	private readonly latestFullContentOwnerByPathCache = new Map<
+		string,
+		string
+	>();
+	private readResultLocatorCache = new WeakMap<object, ReadLocator[]>();
+
+	constructor(
+		private readonly maxToolResultChars = DEFAULT_MAX_TOOL_RESULT_CHARS,
+		private readonly targetToolNames = TARGET_TOOL_NAMES,
+		private readonly maxTotalTextBytes = DEFAULT_MAX_TOTAL_TEXT_BYTES,
+	) {}
+
+	buildForApi(messages: LlmsProviders.Message[]): LlmsProviders.Message[] {
+		this.reindex(messages);
+		const toolNameById = this.toolNameByIdCache;
+		const readLocatorsByToolUseId = this.readLocatorsByToolUseIdCache;
+		const latestReadToolUseByLocator = this.latestReadToolUseByLocatorCache;
+		const latestFullContentOwnerByPath = this.latestFullContentOwnerByPathCache;
+
+		const prepared = messages.map((message) => {
+			if (!Array.isArray(message.content)) {
+				if (message.role === "user" && typeof message.content === "string") {
+					const normalized = normalizeUserInput(message.content);
+					if (normalized !== message.content) {
+						return {
+							...message,
+							content: normalized,
+						};
+					}
+				}
+				return message;
+			}
+
+			const content = message.content.map((block) => {
+				if (
+					message.role === "user" &&
+					block.type === "text" &&
+					typeof block.text === "string"
+				) {
+					const normalized = normalizeUserInput(block.text);
+					if (normalized !== block.text) {
+						return {
+							...block,
+							text: normalized,
+						};
+					}
+				}
+
+				if (block.type === "file") {
+					const truncated = this.truncateMiddle(block.content);
+					if (truncated === block.content) {
+						return block;
+					}
+					return {
+						...block,
+						content: truncated,
+					};
+				}
+
+				if (block.type !== "tool_result") {
+					return block;
+				}
+
+				const toolName = toolNameById.get(block.tool_use_id);
+				let nextContent = block.content;
+
+				if (this.isReadTool(toolName)) {
+					const readRecord = this.getReadResultRecord(
+						block,
+						readLocatorsByToolUseId.get(block.tool_use_id),
+					);
+					if (readRecord) {
+						const outdatedLocators = readRecord.locators.filter((locator) =>
+							this.isOutdatedReadLocator(
+								locator,
+								block.tool_use_id,
+								latestReadToolUseByLocator,
+								latestFullContentOwnerByPath,
+							),
+						);
+						if (outdatedLocators.length > 0) {
+							nextContent = this.replaceOutdatedReadContent(
+								nextContent,
+								outdatedLocators,
+							);
+						}
+					}
+				}
+
+				if (this.shouldTruncateTool(toolName)) {
+					nextContent = this.truncateToolResultContent(nextContent);
+				}
+
+				if (nextContent === block.content) {
+					return block;
+				}
+
+				return {
+					...block,
+					content: nextContent,
+				};
+			});
+
+			return {
+				role: message.role,
+				content,
+			};
+		});
+
+		return this.truncateToTotalTextBudget(prepared);
+	}
+
+	private reindex(messages: LlmsProviders.Message[]): void {
+		if (messages.length < this.indexedMessageCount) {
+			this.resetIndexes();
+		}
+		if (
+			this.indexedMessageCount > 0 &&
+			messages.length >= this.indexedMessageCount &&
+			messages[this.indexedMessageCount - 1] !== this.indexedTailRef
+		) {
+			this.resetIndexes();
+		}
+
+		for (let i = this.indexedMessageCount; i < messages.length; i++) {
+			const message = messages[i];
+			if (!Array.isArray(message.content)) {
+				continue;
+			}
+
+			for (let j = 0; j < message.content.length; j++) {
+				const block = message.content[j];
+				if (block.type === "file") {
+					this.latestFullContentOwnerByPathCache.set(
+						block.path,
+						this.toFileBlockOwnerKey(i, j),
+					);
+					continue;
+				}
+				if (block.type === "tool_use") {
+					const normalizedName = block.name.toLowerCase();
+					this.toolNameByIdCache.set(block.id, normalizedName);
+					if (this.isReadTool(normalizedName)) {
+						const locators = this.extractLocatorsFromReadToolInput(block.input);
+						if (locators.length > 0) {
+							this.readLocatorsByToolUseIdCache.set(block.id, locators);
+						}
+					}
+					continue;
+				}
+				if (block.type === "tool_result") {
+					const toolName = this.toolNameByIdCache.get(block.tool_use_id);
+					if (!this.isReadTool(toolName)) {
+						continue;
+					}
+					const readRecord = this.getReadResultRecord(
+						block,
+						this.readLocatorsByToolUseIdCache.get(block.tool_use_id),
+					);
+					if (!readRecord) {
+						continue;
+					}
+					for (const locator of readRecord.locators) {
+						this.latestReadToolUseByLocatorCache.set(
+							this.toReadLocatorKey(locator),
+							readRecord.toolUseId,
+						);
+						if (this.isFullFileRead(locator)) {
+							this.latestFullContentOwnerByPathCache.set(
+								locator.path,
+								readRecord.toolUseId,
+							);
+						}
+					}
+				}
+			}
+		}
+		this.indexedMessageCount = messages.length;
+		this.indexedTailRef =
+			messages.length > 0 ? messages[messages.length - 1] : undefined;
+	}
+
+	private resetIndexes(): void {
+		this.indexedMessageCount = 0;
+		this.indexedTailRef = undefined;
+		this.toolNameByIdCache.clear();
+		this.readLocatorsByToolUseIdCache.clear();
+		this.latestReadToolUseByLocatorCache.clear();
+		this.latestFullContentOwnerByPathCache.clear();
+		this.readResultLocatorCache = new WeakMap<object, ReadLocator[]>();
+	}
+
+	private getReadResultRecord(
+		block: LlmsProviders.ToolResultContent,
+		fallbackLocators: ReadLocator[] | undefined,
+	): ReadResultRecord | undefined {
+		const blockRef = block as unknown as object;
+		const cachedParsedLocators = this.readResultLocatorCache.get(blockRef);
+		const parsedLocators =
+			cachedParsedLocators ??
+			this.extractReadLocatorsFromToolResultContent(block.content);
+		if (!cachedParsedLocators) {
+			this.readResultLocatorCache.set(blockRef, parsedLocators);
+		}
+		const locators =
+			parsedLocators.length > 0 ? parsedLocators : (fallbackLocators ?? []);
+		if (locators.length === 0) {
+			return undefined;
+		}
+
+		return {
+			toolUseId: block.tool_use_id,
+			locators,
+		};
+	}
+
+	private extractLocatorsFromReadToolInput(input: unknown): ReadLocator[] {
+		if (!input || typeof input !== "object") {
+			return [];
+		}
+
+		const record = input as Record<string, unknown>;
+		const locators: ReadLocator[] = [];
+		const directLocator = this.extractLocatorFromReadRequest(record);
+		if (directLocator) {
+			locators.push(directLocator);
+		}
+
+		const maybeFiles = record.files;
+		if (Array.isArray(maybeFiles)) {
+			for (const value of maybeFiles) {
+				const locator = this.extractLocatorFromReadRequest(value);
+				if (locator) {
+					locators.push(locator);
+				}
+			}
+		}
+
+		const maybeFilePaths = record.file_paths;
+		if (Array.isArray(maybeFilePaths)) {
+			for (const value of maybeFilePaths) {
+				if (typeof value === "string" && value.length > 0) {
+					locators.push({
+						path: value,
+						startLine: null,
+						endLine: null,
+					});
+				}
+			}
+		}
+
+		return this.dedupeReadLocators(locators);
+	}
+
+	private extractReadLocatorsFromToolResultContent(
+		content: LlmsProviders.ToolResultContent["content"],
+	): ReadLocator[] {
+		if (typeof content === "string") {
+			try {
+				const parsed = JSON.parse(content);
+				return this.extractLocatorsFromParsedReadResult(parsed);
+			} catch {
+				return [];
+			}
+		}
+
+		for (const entry of content) {
+			if (entry.type !== "text") {
+				continue;
+			}
+			try {
+				const parsed = JSON.parse(entry.text);
+				return this.extractLocatorsFromParsedReadResult(parsed);
+			} catch {
+				// no-op
+			}
+		}
+
+		return [];
+	}
+
+	private extractLocatorsFromParsedReadResult(value: unknown): ReadLocator[] {
+		if (Array.isArray(value)) {
+			return this.dedupeReadLocators(
+				value
+					.map((item) => this.extractLocatorFromResultEntry(item))
+					.filter((locator): locator is ReadLocator => locator !== undefined),
+			);
+		}
+
+		const locator = this.extractLocatorFromResultEntry(value);
+		return locator ? [locator] : [];
+	}
+
+	private extractLocatorFromReadRequest(
+		value: unknown,
+	): ReadLocator | undefined {
+		if (!value || typeof value !== "object") {
+			return undefined;
+		}
+
+		const record = value as Record<string, unknown>;
+		const path = this.extractPath(record);
+		if (!path) {
+			return undefined;
+		}
+
+		return {
+			path,
+			startLine: this.extractLineNumber(record.start_line),
+			endLine: this.extractLineNumber(record.end_line),
+		};
+	}
+
+	private extractLocatorFromResultEntry(
+		value: unknown,
+	): ReadLocator | undefined {
+		if (!value || typeof value !== "object") {
+			return undefined;
+		}
+
+		const record = value as Record<string, unknown>;
+		const directPath = this.extractPath(record);
+		if (directPath) {
+			return {
+				path: directPath,
+				startLine: this.extractLineNumber(record.start_line),
+				endLine: this.extractLineNumber(record.end_line),
+			};
+		}
+
+		if (typeof record.query === "string" && record.query.length > 0) {
+			return this.parseReadQuery(record.query);
+		}
+
+		return undefined;
+	}
+
+	private extractPath(record: Record<string, unknown>): string | undefined {
+		const candidates = [record.path, record.file_path, record.filePath];
+		for (const candidate of candidates) {
+			if (typeof candidate === "string" && candidate.length > 0) {
+				return candidate;
+			}
+		}
+
+		return undefined;
+	}
+
+	private extractLineNumber(value: unknown): number | null {
+		return typeof value === "number" && Number.isInteger(value) ? value : null;
+	}
+
+	private parseReadQuery(query: string): ReadLocator {
+		const match = /^(.*):(\d+)-(EOF|\d+)$/.exec(query);
+		if (!match) {
+			return { path: query, startLine: null, endLine: null };
+		}
+
+		return {
+			path: match[1],
+			startLine: Number(match[2]),
+			endLine: match[3] === "EOF" ? null : Number(match[3]),
+		};
+	}
+
+	private dedupeReadLocators(locators: ReadLocator[]): ReadLocator[] {
+		const unique = new Map<string, ReadLocator>();
+		for (const locator of locators) {
+			unique.set(this.toReadLocatorKey(locator), locator);
+		}
+		return Array.from(unique.values());
+	}
+
+	private toReadLocatorKey(locator: ReadLocator): string {
+		if (this.isFullFileRead(locator)) {
+			return locator.path;
+		}
+		return `${locator.path}:${locator.startLine ?? 1}-${locator.endLine ?? "EOF"}`;
+	}
+
+	private isFullFileRead(locator: ReadLocator): boolean {
+		return locator.startLine == null && locator.endLine == null;
+	}
+
+	private isOutdatedReadLocator(
+		locator: ReadLocator,
+		toolUseId: string,
+		latestReadToolUseByLocator: Map<string, string>,
+		latestFullContentOwnerByPath: Map<string, string>,
+	): boolean {
+		const latestFullContentOwner = latestFullContentOwnerByPath.get(
+			locator.path,
+		);
+		if (latestFullContentOwner && latestFullContentOwner !== toolUseId) {
+			return true;
+		}
+
+		return (
+			latestReadToolUseByLocator.get(this.toReadLocatorKey(locator)) !==
+			toolUseId
+		);
+	}
+
+	private toFileBlockOwnerKey(
+		messageIndex: number,
+		blockIndex: number,
+	): string {
+		return `file:${messageIndex}:${blockIndex}`;
+	}
+
+	private replaceOutdatedReadContent(
+		content: LlmsProviders.ToolResultContent["content"],
+		outdatedLocators: ReadLocator[],
+	): LlmsProviders.ToolResultContent["content"] {
+		const outdatedLocatorKeySet = new Set(
+			outdatedLocators.map((locator) => this.toReadLocatorKey(locator)),
+		);
+		const outdatedPathSet = new Set(
+			outdatedLocators.map((locator) => locator.path),
+		);
+
+		if (typeof content === "string") {
+			const replaced = this.replaceOutdatedReadContentInString(
+				content,
+				outdatedLocatorKeySet,
+			);
+			return replaced ?? OUTDATED_FILE_CONTENT;
+		}
+
+		let outdatedImageCount = content.reduce((count, entry) => {
+			if (entry.type !== "text") {
+				return count;
+			}
+			return (
+				count +
+				this.countOutdatedImageEntries(entry.text, outdatedLocatorKeySet)
+			);
+		}, 0);
+
+		return content.map((entry) => {
+			if (entry.type === "file") {
+				if (!outdatedPathSet.has(entry.path)) {
+					return entry;
+				}
+				return {
+					...(entry as LlmsProviders.FileContent),
+					content: OUTDATED_FILE_CONTENT,
+				};
+			}
+
+			if (entry.type === "image") {
+				if (outdatedImageCount === 0) {
+					return entry;
+				}
+				outdatedImageCount -= 1;
+				return {
+					type: "text",
+					text: OUTDATED_FILE_CONTENT,
+				} satisfies LlmsProviders.TextContent;
+			}
+
+			if (entry.type !== "text") {
+				return entry;
+			}
+			const replaced = this.replaceOutdatedReadContentInString(
+				entry.text,
+				outdatedLocatorKeySet,
+			);
+			if (replaced === null) {
+				return {
+					...(entry as LlmsProviders.TextContent),
+					text: OUTDATED_FILE_CONTENT,
+				};
+			}
+			if (replaced === entry.text) {
+				return entry;
+			}
+			return {
+				...(entry as LlmsProviders.TextContent),
+				text: replaced,
+			};
+		});
+	}
+
+	private countOutdatedImageEntries(
+		text: string,
+		outdatedLocatorKeySet: Set<string>,
+	): number {
+		try {
+			const parsed = JSON.parse(text);
+			return this.countOutdatedImageEntriesInParsed(
+				parsed,
+				outdatedLocatorKeySet,
+			);
+		} catch {
+			return 0;
+		}
+	}
+
+	private countOutdatedImageEntriesInParsed(
+		value: unknown,
+		outdatedLocatorKeySet: Set<string>,
+	): number {
+		if (Array.isArray(value)) {
+			return value.reduce(
+				(count, entry) =>
+					count +
+					this.countOutdatedImageEntriesInEntry(entry, outdatedLocatorKeySet),
+				0,
+			);
+		}
+
+		return this.countOutdatedImageEntriesInEntry(value, outdatedLocatorKeySet);
+	}
+
+	private countOutdatedImageEntriesInEntry(
+		entry: unknown,
+		outdatedLocatorKeySet: Set<string>,
+	): number {
+		if (!entry || typeof entry !== "object") {
+			return 0;
+		}
+
+		const record = entry as Record<string, unknown>;
+		const locator = this.extractLocatorFromResultEntry(record);
+		if (!locator) {
+			return 0;
+		}
+
+		const locatorKey = this.toReadLocatorKey(locator);
+		if (!outdatedLocatorKeySet.has(locatorKey)) {
+			return 0;
+		}
+
+		return this.isImageReadSummaryEntry(record) ? 1 : 0;
+	}
+
+	private isImageReadSummaryEntry(record: Record<string, unknown>): boolean {
+		return (
+			record.result === "Successfully read image" ||
+			record.content === "Successfully read image"
+		);
+	}
+
+	private replaceOutdatedReadContentInString(
+		text: string,
+		outdatedLocatorKeySet: Set<string>,
+	): string | null {
+		try {
+			const parsed = JSON.parse(text);
+			const replaced = this.replaceOutdatedReadContentInParsed(
+				parsed,
+				outdatedLocatorKeySet,
+			);
+			return JSON.stringify(replaced);
+		} catch {
+			return null;
+		}
+	}
+
+	private replaceOutdatedReadContentInParsed(
+		value: unknown,
+		outdatedLocatorKeySet: Set<string>,
+	): unknown {
+		if (Array.isArray(value)) {
+			return value.map((entry) =>
+				this.replaceOutdatedReadEntry(entry, outdatedLocatorKeySet),
+			);
+		}
+
+		return this.replaceOutdatedReadEntry(value, outdatedLocatorKeySet);
+	}
+
+	private replaceOutdatedReadEntry(
+		entry: unknown,
+		outdatedLocatorKeySet: Set<string>,
+	): unknown {
+		if (!entry || typeof entry !== "object") {
+			return entry;
+		}
+
+		const record = { ...(entry as Record<string, unknown>) };
+		const locator = this.extractLocatorFromResultEntry(record);
+		if (!locator) {
+			return entry;
+		}
+		const locatorKey = this.toReadLocatorKey(locator);
+		if (!outdatedLocatorKeySet.has(locatorKey)) {
+			return entry;
+		}
+
+		if (typeof record.result === "string") {
+			record.result = OUTDATED_FILE_CONTENT;
+		} else if (typeof record.content === "string") {
+			record.content = OUTDATED_FILE_CONTENT;
+		} else {
+			record.result = OUTDATED_FILE_CONTENT;
+		}
+
+		return record;
+	}
+
+	private isReadTool(toolName: string | undefined): boolean {
+		if (!toolName) {
+			return false;
+		}
+		return READ_TOOL_NAMES.has(toolName.toLowerCase());
+	}
+
+	private shouldTruncateTool(toolName: string | undefined): boolean {
+		if (!toolName) {
+			return false;
+		}
+		return this.targetToolNames.has(toolName.toLowerCase());
+	}
+
+	private truncateToolResultContent(
+		content: LlmsProviders.ToolResultContent["content"],
+	): LlmsProviders.ToolResultContent["content"] {
+		if (typeof content === "string") {
+			return this.truncateMiddle(content);
+		}
+
+		return content.map((entry) => {
+			if (entry.type === "file") {
+				const fileContent = this.truncateMiddle(entry.content);
+				if (fileContent === entry.content) {
+					return entry;
+				}
+				return {
+					...(entry as LlmsProviders.FileContent),
+					content: fileContent,
+				};
+			}
+
+			if (entry.type !== "text") {
+				return entry;
+			}
+
+			const text = this.truncateMiddle(entry.text);
+			if (text === entry.text) {
+				return entry;
+			}
+
+			return {
+				...(entry as LlmsProviders.TextContent),
+				text,
+			};
+		});
+	}
+
+	private truncateMiddle(text: string): string {
+		if (text.length <= this.maxToolResultChars) {
+			return text;
+		}
+
+		const marker = `\n\n...[truncated ${Math.max(0, text.length - this.maxToolResultChars)} chars]...\n\n`;
+		const availableChars = Math.max(0, this.maxToolResultChars - marker.length);
+		const keepCharsPerSide = Math.floor(availableChars / 2);
+		const retainedChars = keepCharsPerSide * 2;
+		const removedChars = Math.max(0, text.length - retainedChars);
+		const effectiveMarker = `\n\n...[truncated ${removedChars} chars]...\n\n`;
+		const effectiveAvailableChars = Math.max(
+			0,
+			this.maxToolResultChars - effectiveMarker.length,
+		);
+		const effectiveKeepCharsPerSide = Math.floor(effectiveAvailableChars / 2);
+
+		const start = text.slice(0, effectiveKeepCharsPerSide);
+		const end =
+			effectiveKeepCharsPerSide > 0
+				? text.slice(-effectiveKeepCharsPerSide)
+				: "";
+
+		return `${start}${effectiveMarker}${end}`;
+	}
+
+	private truncateToTotalTextBudget(
+		messages: LlmsProviders.Message[],
+	): LlmsProviders.Message[] {
+		if (this.maxTotalTextBytes <= 0) {
+			return messages;
+		}
+
+		let totalBytes = this.countMessageTextBytes(messages);
+		if (totalBytes <= this.maxTotalTextBytes) {
+			return messages;
+		}
+
+		const next = messages.map((message) => {
+			if (!Array.isArray(message.content)) {
+				return message;
+			}
+			return {
+				...message,
+				content: message.content.map((block) =>
+					this.cloneContentBlockForMutation(block),
+				),
+			};
+		});
+
+		const candidates = this.collectTruncationCandidates(next);
+		for (const candidate of candidates) {
+			if (totalBytes <= this.maxTotalTextBytes) {
+				break;
+			}
+
+			const current = candidate.get();
+			const currentBytes = candidate.byteLength;
+			if (currentBytes <= MIN_TOTAL_BUDGET_TOOL_RESULT_BYTES) {
+				continue;
+			}
+
+			const overflowBytes = totalBytes - this.maxTotalTextBytes;
+			const targetBytes = Math.max(
+				MIN_TOTAL_BUDGET_TOOL_RESULT_BYTES,
+				currentBytes - overflowBytes,
+			);
+			const truncated = this.truncateMiddleToBytes(current, targetBytes);
+			candidate.set(truncated);
+			totalBytes -= currentBytes - this.utf8ByteLength(truncated);
+		}
+
+		return next;
+	}
+
+	private countMessageTextBytes(messages: LlmsProviders.Message[]): number {
+		let total = 0;
+		for (const message of messages) {
+			if (typeof message.content === "string") {
+				total += this.utf8ByteLength(message.content);
+				continue;
+			}
+			for (const block of message.content) {
+				if (block.type === "text") {
+					total += this.utf8ByteLength(block.text);
+				} else if (block.type === "thinking") {
+					total += this.utf8ByteLength(block.thinking);
+				} else if (block.type === "file") {
+					total += this.utf8ByteLength(block.content);
+				} else if (block.type === "tool_result") {
+					total += this.countToolResultTextBytes(block.content);
+				}
+			}
+		}
+		return total;
+	}
+
+	private countToolResultTextBytes(
+		content: LlmsProviders.ToolResultContent["content"],
+	): number {
+		if (typeof content === "string") {
+			return this.utf8ByteLength(content);
+		}
+		return content.reduce((total, entry) => {
+			if (entry.type === "text") {
+				return total + this.utf8ByteLength(entry.text);
+			}
+			if (entry.type === "file") {
+				return total + this.utf8ByteLength(entry.content);
+			}
+			return total;
+		}, 0);
+	}
+
+	private collectTruncationCandidates(
+		messages: LlmsProviders.Message[],
+	): Array<{
+		byteLength: number;
+		get: () => string;
+		set: (value: string) => void;
+	}> {
+		const candidates: Array<{
+			byteLength: number;
+			get: () => string;
+			set: (value: string) => void;
+		}> = [];
+
+		for (const message of messages) {
+			if (!Array.isArray(message.content)) {
+				continue;
+			}
+			for (const block of message.content) {
+				if (block.type !== "tool_result") {
+					continue;
+				}
+				const toolName = this.toolNameByIdCache.get(block.tool_use_id);
+				if (!this.shouldTruncateTool(toolName)) {
+					continue;
+				}
+				if (typeof block.content === "string") {
+					candidates.push({
+						byteLength: this.utf8ByteLength(block.content),
+						get: () => block.content as string,
+						set: (value) => {
+							block.content = value;
+						},
+					});
+					continue;
+				}
+				for (const entry of block.content) {
+					if (entry.type === "text") {
+						candidates.push({
+							byteLength: this.utf8ByteLength(entry.text),
+							get: () => entry.text,
+							set: (value) => {
+								entry.text = value;
+							},
+						});
+					} else if (entry.type === "file") {
+						candidates.push({
+							byteLength: this.utf8ByteLength(entry.content),
+							get: () => entry.content,
+							set: (value) => {
+								entry.content = value;
+							},
+						});
+					}
+				}
+			}
+		}
+
+		return candidates.sort((left, right) => right.byteLength - left.byteLength);
+	}
+
+	private truncateMiddleToLength(text: string, maxChars: number): string {
+		if (text.length <= maxChars) {
+			return text;
+		}
+
+		const marker = `\n\n...[truncated ${Math.max(0, text.length - maxChars)} chars to fit provider request budget]...\n\n`;
+		const availableChars = Math.max(0, maxChars - marker.length);
+		const keepCharsPerSide = Math.floor(availableChars / 2);
+		const retainedChars = keepCharsPerSide * 2;
+		const removedChars = Math.max(0, text.length - retainedChars);
+		const effectiveMarker = `\n\n...[truncated ${removedChars} chars to fit provider request budget]...\n\n`;
+		const effectiveAvailableChars = Math.max(
+			0,
+			maxChars - effectiveMarker.length,
+		);
+		const effectiveKeepCharsPerSide = Math.floor(effectiveAvailableChars / 2);
+
+		const start = text.slice(0, effectiveKeepCharsPerSide);
+		const end =
+			effectiveKeepCharsPerSide > 0
+				? text.slice(-effectiveKeepCharsPerSide)
+				: "";
+
+		return `${start}${effectiveMarker}${end}`;
+	}
+
+	private truncateMiddleToBytes(text: string, maxBytes: number): string {
+		if (this.utf8ByteLength(text) <= maxBytes) {
+			return text;
+		}
+
+		let low = 0;
+		let high = text.length;
+		let best = this.truncateMiddleToLength(text, 0);
+		while (low <= high) {
+			const mid = Math.floor((low + high) / 2);
+			const candidate = this.truncateMiddleToLength(text, mid);
+			if (this.utf8ByteLength(candidate) <= maxBytes) {
+				best = candidate;
+				low = mid + 1;
+			} else {
+				high = mid - 1;
+			}
+		}
+		return best;
+	}
+
+	private utf8ByteLength(text: string): number {
+		return Buffer.byteLength(text, "utf8");
+	}
+
+	private cloneContentBlockForMutation(
+		block: LlmsProviders.ContentBlock,
+	): LlmsProviders.ContentBlock {
+		if (block.type !== "tool_result" || typeof block.content === "string") {
+			return { ...block };
+		}
+
+		return {
+			...block,
+			content: block.content.map((entry) => ({ ...entry })),
+		};
+	}
+}