@linxiraos/pi-agent-core 1.1.27 → 1.2.0

package/src/compaction/pruning.ts

@@ -7,6 +7,7 @@ import type { Tokenizer } from "../tokenizer";
 import type { AgentMessage, AgentToolCall } from "../types";
 import type { SessionEntry, SessionMessageEntry } from "./entries";
 import { invalidateMessageCache } from "./message-cache";
+import { type ConvertToLlm, defaultConvertToLlm, getMessageFromEntry } from "./messages";
 import {
 	collectToolCallsById,
 	getToolResultMessage,
@@ -16,7 +17,25 @@ import {
 } from "./tool-protection";
 import { isAlternateFormReadSelector, splitReadSelector } from "./utils";
 
-export interface PruneConfig {
+/** Bound warm-cache pruning by the provider's prompt-cache lookback window. */
+export interface CacheLookbackConfig {
+	/**
+	 * Prompt-cache lookback of the model the next request goes to, in block
+	 * positions (catalog `prompt-cache-lookback`; Anthropic: 20). When set,
+	 * warm-cache pruning also leaves a result whose rewrite would put the next
+	 * request's cache lookup out of reach, whatever its token suffix (see
+	 * `cacheLookbackFloor`). Undefined = no lookback bound.
+	 */
+	cacheLookbackPositions?: number;
+	/**
+	 * Projects context messages to what the provider receives, so lookback
+	 * positions count app roles (file mentions, command output, custom
+	 * messages) as sent. Default {@link defaultConvertToLlm}.
+	 */
+	convertToLlm?: ConvertToLlm;
+}
+
+export interface PruneConfig extends CacheLookbackConfig {
 	/** Keep the most recent tool output tokens intact. */
 	protectTokens: number;
 	/** Only prune if total savings meets this threshold. */
@@ -48,7 +67,8 @@ export interface PruneConfig {
 	 * already-sent cache prefix: mutating it forces the provider to re-write the
 	 * whole suffix (cacheWrite premium). Such results — including superseded and
 	 * useless ones, which otherwise bypass {@link protectTokens} — are left for
-	 * compaction/shake (which rebuild the cache anyway) to reclaim. Undefined =
+	 * compaction/shake (which rebuild the cache anyway) to reclaim, as are
+	 * results beyond {@link CacheLookbackConfig.cacheLookbackPositions}. Undefined =
 	 * no cache guard (legacy: superseded/useless prune at any depth).
 	 */
 	cacheWarmSuffixTokens?: number;
@@ -117,7 +137,7 @@ export type SupersedeKeyFn = (toolName: string, args: Record<string, unknown>) =
  */
 export type SupersedeCompleteFn = (message: ToolResultMessage) => boolean;
 
-export interface SupersedePruneConfig {
+export interface SupersedePruneConfig extends CacheLookbackConfig {
 	/** Supersede key function; a newer successful result with the same key supersedes older ones (see {@link SupersedeKeyFn}). */
 	supersedeKey?: SupersedeKeyFn;
 	/**
@@ -135,7 +155,11 @@ export interface SupersedePruneConfig {
 	supersedeComplete?: SupersedeCompleteFn;
 	/** Also prune results flagged useless by their tool. Default false. */
 	pruneUseless?: boolean;
-	/** Prune a candidate now when all messages after it total at most this many estimated tokens. Default 8 000. */
+	/**
+	 * Prune a candidate now when all messages after it total at most this many
+	 * estimated tokens and it sits within
+	 * {@link CacheLookbackConfig.cacheLookbackPositions}. Default 8 000.
+	 */
 	suffixTokenLimit?: number;
 	/**
 	 * Prune all candidates when the last message is at least this old: the
@@ -160,6 +184,99 @@ export interface SupersedePruneConfig {
 const DEFAULT_SUFFIX_TOKEN_LIMIT = 8_000;
 const DEFAULT_IDLE_FLUSH_MS = 30 * 60_000;
 
+/**
+ * Positions kept free for the next request's own input (prompt, date/cwd
+ * reminder, attachments) and for request projections the count below does not
+ * model (orphan-result notes, replayed compaction file metadata, tool-change
+ * controls): with Anthropic's 20, stored history gets at most 13.
+ */
+const RESERVED_LOOKBACK_POSITIONS = 6;
+
+type LookbackBlock = "tool_use" | "tool_result" | undefined;
+
+/**
+ * Index of the oldest tool result that can be rewritten while the next request
+ * still reaches a cache entry, given the model's prompt-cache `lookback` in
+ * block positions (a breakpoint counts itself; a run of consecutive `tool_use`
+ * blocks, or of consecutive `tool_result` blocks, is one position). A
+ * conservative estimate, not an exact count: a skipped prune costs its tokens,
+ * a missed lookup the whole cache.
+ *
+ * Each request writes its tail cache entry at its last block, so rewriting a
+ * result invalidates every entry from its issuing assistant turn on, and once a
+ * request has 15 user turns its other breakpoint sits on an older decimation
+ * checkpoint. The next request's tail breakpoint then reaches the newest
+ * surviving entry, which ends the message before the issuing turn, only when
+ * the issuing turn, its tool-result batch, everything after and the next input
+ * fit in the lookback window; otherwise the lookup falls back to that
+ * checkpoint and the whole conversation since is re-written, not the small
+ * suffix the token limits budget for. Each entry is projected through
+ * `convertToLlm` and counted the way the Anthropic request converter emits it.
+ */
+function cacheLookbackFloor(
+	entries: readonly SessionEntry[],
+	start: number,
+	lookback: number | undefined,
+	convertToLlm: ConvertToLlm,
+): number {
+	if (lookback === undefined) return start;
+	let positions = RESERVED_LOOKBACK_POSITIONS;
+	let later: LookbackBlock;
+	let runHoistsImages = false;
+	let newerIsAssistant = false;
+	const add = (block: LookbackBlock): void => {
+		if (block === undefined || block !== later) positions++;
+		later = block;
+	};
+	let floor = entries.length;
+	for (let i = entries.length - 1; i >= start; i--) {
+		const message = getMessageFromEntry(entries[i]);
+		const sent = message === undefined ? [] : convertToLlm([message]);
+		for (let m = sent.length - 1; m >= 0; m--) {
+			const llm = sent[m];
+			if (llm.role === "toolResult") {
+				if (later !== "tool_result") runHoistsImages = false;
+				add("tool_result");
+				// Anthropic rejects images in error results, so the converter moves
+				// them after the result run behind one explanatory text block.
+				let images = 0;
+				if (llm.isError) {
+					for (const block of llm.content) if (block.type === "image") images++;
+				}
+				if (images > 0) {
+					positions += runHoistsImages ? images : images + 1;
+					runHoistsImages = true;
+				}
+				newerIsAssistant = false;
+			} else if (llm.role === "assistant") {
+				// The converter pads consecutive assistant turns with a user turn and
+				// drops assistant images, blank text, and turns left empty.
+				let pad = newerIsAssistant;
+				for (let b = llm.content.length - 1; b >= 0; b--) {
+					const block = llm.content[b];
+					if (block.type === "image" || (block.type === "text" && block.text.trim().length === 0)) continue;
+					if (pad) {
+						add(undefined);
+						pad = false;
+					}
+					add(block.type === "toolCall" ? "tool_use" : undefined);
+					newerIsAssistant = true;
+				}
+			} else {
+				// The converter drops blank user/developer turns.
+				const blocks =
+					typeof llm.content === "string" ? (llm.content.trim().length > 0 ? 1 : 0) : llm.content.length;
+				if (blocks === 0) continue;
+				for (let b = blocks; b > 0; b--) add(undefined);
+				newerIsAssistant = false;
+			}
+		}
+		if (positions >= lookback) return floor;
+		if (message?.role === "assistant") floor = i;
+	}
+	return start;
+}
+
 function createPrunedNotice(tokens: number): string {
 	return `[Output truncated - ${tokens} tokens]`;
 }
@@ -179,24 +296,6 @@ function estimatePrunedSavings(tokens: number, notice: string): number {
 	return Math.max(0, tokens - noticeTokens);
 }
 
-/**
- * For each entry index, the estimated token total of all *message* entries
- * strictly after it — how much prompt-cache content the provider must re-write
- * (cacheWrite premium) if that entry is mutated in place. Used to keep prune
- * mutations inside the cheap-to-recache tail.
- */
-function computeMessageSuffixTokens(entries: readonly SessionEntry[], tokenizer: Tokenizer): number[] {
-	// [suppressed] length preallocation
-	const suffix = new Array<number>(entries.length);
-	let accumulated = 0;
-	for (let i = entries.length - 1; i >= 0; i--) {
-		suffix[i] = accumulated;
-		const entry = entries[i];
-		if (entry.type === "message") accumulated += tokenizer.countMessage(entry.message as AgentMessage);
-	}
-	return suffix;
-}
-
 /**
  * Resolve the array index of the compaction boundary (`keepBoundaryId`). Entries
  * before this index are summarized away by the latest compaction and never sent,
@@ -205,8 +304,36 @@ function computeMessageSuffixTokens(entries: readonly SessionEntry[], tokenizer:
  */
 function resolveBoundaryIndex(entries: readonly SessionEntry[], keepBoundaryId: string | undefined): number {
 	if (keepBoundaryId === undefined) return 0;
-	const index = entries.findIndex(entry => entry.id === keepBoundaryId);
-	return index < 0 ? 0 : index;
+	for (let i = entries.length - 1; i >= 0; i--) {
+		if (entries[i].id === keepBoundaryId) return i;
+	}
+	return 0;
+}
+
+/**
+ * Tool-call lookup for results in the sent region `entries[start, end)`.
+ * Calls there are indexed eagerly; the summarized-away prefix is indexed only
+ * on the first miss, so lookups match a whole-branch scan while the common
+ * case never walks history the boundary already excludes.
+ */
+class SentToolCalls {
+	readonly #entries: readonly SessionEntry[];
+	readonly #start: number;
+	readonly #sent: Map<string, AgentToolCall>;
+	#prefix: Map<string, AgentToolCall> | undefined;
+
+	constructor(entries: readonly SessionEntry[], start: number) {
+		this.#entries = entries;
+		this.#start = start;
+		this.#sent = collectToolCallsById(entries, start);
+	}
+
+	get(id: string): AgentToolCall | undefined {
+		const call = this.#sent.get(id);
+		if (call !== undefined || this.#start === 0) return call;
+		this.#prefix ??= collectToolCallsById(this.#entries, 0, this.#start);
+		return this.#prefix.get(id);
+	}
 }
 
 interface SupersedeCandidate {
@@ -240,19 +367,22 @@ interface NewerResults {
  */
 function collectSupersededResults(
 	entries: readonly SessionEntry[],
+	start: number,
 	tokenizer: Tokenizer,
-	toolCallsById: ReadonlyMap<string, AgentToolCall>,
+	toolCalls: SentToolCalls,
 	supersedeKey: SupersedeKeyFn,
 	supersedeComplete: SupersedeCompleteFn | undefined,
 	protectedTools: readonly ProtectedToolMatcher[],
 ): SupersedeCandidate[] {
+	// Walk newest → oldest: supersession only depends on NEWER results, so
+	// stopping at `start` yields exactly the full scan's candidates at/after it.
 	const candidates: SupersedeCandidate[] = [];
 	const newerByKey = new Map<string, NewerResults>();
-	for (let i = entries.length - 1; i >= 0; i--) {
+	for (let i = entries.length - 1; i >= start; i--) {
 		const entry = entries[i];
 		const message = getToolResultMessage(entry);
 		if (!message || message.prunedAt !== undefined) continue;
-		const toolCall = toolCallsById.get(message.toolCallId);
+		const toolCall = toolCalls.get(message.toolCallId);
 		if (!toolCall) continue;
 		if (isProtectedToolResult(message, toolCall, protectedTools)) continue;
 		const key = supersedeKey(toolCall.name, toolCall.arguments as Record<string, unknown>);
@@ -289,18 +419,19 @@ function collectSupersededResults(
  */
 function collectUselessResults(
 	entries: readonly SessionEntry[],
+	start: number,
 	tokenizer: Tokenizer,
-	toolCallsById: ReadonlyMap<string, AgentToolCall>,
+	toolCalls: SentToolCalls,
 	protectedTools: readonly ProtectedToolMatcher[],
 	exclude: ReadonlySet<ToolResultMessage>,
 ): SupersedeCandidate[] {
 	const candidates: SupersedeCandidate[] = [];
-	for (let i = 0; i < entries.length; i++) {
+	for (let i = start; i < entries.length; i++) {
 		const entry = entries[i];
 		const message = getToolResultMessage(entry);
 		if (message?.useless !== true || message.prunedAt !== undefined || message.isError === true) continue;
 		if (exclude.has(message)) continue;
-		if (isProtectedToolResult(message, toolCallsById.get(message.toolCallId), protectedTools)) continue;
+		if (isProtectedToolResult(message, toolCalls.get(message.toolCallId), protectedTools)) continue;
 		const tokens = tokenizer.countMessage(message as AgentMessage);
 		if (estimatePrunedSavings(tokens, USELESS_NOTICE) <= 0) continue;
 		candidates.push({ entry: entry as SessionMessageEntry, message, index: i, tokens, notice: USELESS_NOTICE });
@@ -315,19 +446,22 @@ function collectUselessResults(
  * candidate is pruned now only when the suffix after it is small (tail case —
  * the read→edit→read loop) or when the context has been idle long enough that
  * the provider cache is cold anyway (then all still-sent candidates flush).
- * Never mutates entries before `keepBoundaryId` (summarized away — not sent).
+ * Never mutates entries before `keepBoundaryId` (summarized away — not sent),
+ * and never walks them unless a sent result's call lives there.
  */
 export function pruneSupersededToolResults(
-	entries: SessionEntry[],
+	entries: readonly SessionEntry[],
 	tokenizer: Tokenizer,
 	config: SupersedePruneConfig,
 ): PruneResult {
-	const toolCallsById = collectToolCallsById(entries);
+	const boundaryIndex = resolveBoundaryIndex(entries, config.keepBoundaryId);
+	const toolCalls = new SentToolCalls(entries, boundaryIndex);
 	const candidates = config.supersedeKey
 		? collectSupersededResults(
 				entries,
+				boundaryIndex,
 				tokenizer,
-				toolCallsById,
+				toolCalls,
 				config.supersedeKey,
 				config.supersedeComplete,
 				config.protectedTools,
@@ -335,7 +469,16 @@ export function pruneSupersededToolResults(
 		: [];
 	if (config.pruneUseless) {
 		const exclude = new Set(candidates.map(candidate => candidate.message));
-		candidates.push(...collectUselessResults(entries, tokenizer, toolCallsById, config.protectedTools, exclude));
+		for (const candidate of collectUselessResults(
+			entries,
+			boundaryIndex,
+			tokenizer,
+			toolCalls,
+			config.protectedTools,
+			exclude,
+		)) {
+			candidates.push(candidate);
+		}
 		candidates.sort((a, b) => a.index - b.index);
 	}
 	if (candidates.length === 0) return NOTHING_PRUNED;
@@ -352,38 +495,47 @@ export function pruneSupersededToolResults(
 	const idle =
 		lastMessageTimestamp !== undefined && now - lastMessageTimestamp >= (config.idleFlushMs ?? DEFAULT_IDLE_FLUSH_MS);
 
-	const boundaryIndex = resolveBoundaryIndex(entries, config.keepBoundaryId);
-
 	let toPrune: SupersedeCandidate[];
 	if (idle) {
 		// Provider cache is cold (idle exceeds the retention TTL), so re-writing
-		// the sent region costs nothing. Entries before the compaction boundary
-		// are summarized away and never sent — skip them to avoid pointless churn.
-		toPrune = candidates.filter(candidate => candidate.index >= boundaryIndex);
+		// the sent region costs nothing. Candidates already start at the
+		// compaction boundary (summarized-away entries are never sent).
+		toPrune = candidates;
 	} else {
+		// Mutating a candidate re-writes its suffix (tokens of every message
+		// strictly after it) in the warm cache, so prune only when that suffix is
+		// small and the next request's cache lookup stays in reach. The suffix
+		// only grows walking back, so stop at the first index past either limit
+		// instead of measuring the whole branch.
 		const suffixTokenLimit = config.suffixTokenLimit ?? DEFAULT_SUFFIX_TOKEN_LIMIT;
-		// suffixTokens[i] = estimated tokens of all messages strictly after entry i.
-		// Mutating a candidate re-writes its suffix in the warm cache, so prune only
-		// when that suffix is small (cheap-to-recache tail) and the candidate sits
-		// at/after the compaction boundary.
-		const suffixTokens = computeMessageSuffixTokens(entries, tokenizer);
-		toPrune = candidates.filter(
-			candidate => candidate.index >= boundaryIndex && suffixTokens[candidate.index] <= suffixTokenLimit,
+		const lookbackFloor = cacheLookbackFloor(
+			entries,
+			boundaryIndex,
+			config.cacheLookbackPositions,
+			config.convertToLlm ?? defaultConvertToLlm,
 		);
+		toPrune = [];
+		let suffixTokens = 0;
+		let next = candidates.length - 1;
+		for (let i = entries.length - 1; next >= 0 && suffixTokens <= suffixTokenLimit && i >= lookbackFloor; i--) {
+			while (next >= 0 && candidates[next].index === i) toPrune.push(candidates[next--]);
+			const entry = entries[i];
+			if (entry.type === "message") suffixTokens += tokenizer.countMessage(entry.message as AgentMessage);
+		}
+		toPrune.reverse();
 	}
 	if (toPrune.length === 0) return NOTHING_PRUNED;
 
-	const prunedAt = Date.now();
 	let tokensSaved = 0;
-	const steps = toPrune.map(candidate => {
-		tokensSaved += estimatePrunedSavings(candidate.tokens, candidate.notice);
-		return blankToolResult(candidate.message, candidate.notice, prunedAt);
-	});
+	for (const candidate of toPrune) tokensSaved += estimatePrunedSavings(candidate.tokens, candidate.notice);
+
+	const prunedAt = Date.now();
+	const steps = toPrune.map(candidate => blankToolResult(candidate.message, candidate.notice, prunedAt));
 	return { prunedCount: toPrune.length, tokensSaved, undo: undoAll(steps) };
 }
 
 export function pruneToolOutputs(
-	entries: SessionEntry[],
+	entries: readonly SessionEntry[],
 	tokenizer: Tokenizer,
 	config: PruneConfig = DEFAULT_PRUNE_CONFIG,
 ): PruneResult {
@@ -391,13 +543,17 @@ export function pruneToolOutputs(
 	let tokensSaved = 0;
 
 	const candidates: Array<{ entry: SessionMessageEntry; tokens: number; superseded: boolean; useless: boolean }> = [];
-	const toolCallsById = collectToolCallsById(entries);
+	// Entries before the compaction boundary are summarized away (never sent)
+	// and are never prune candidates, so no pass below walks them.
+	const boundaryIndex = resolveBoundaryIndex(entries, config.keepBoundaryId);
+	const toolCalls = new SentToolCalls(entries, boundaryIndex);
 	const supersededMessages = config.supersedeKey
 		? new Set(
 				collectSupersededResults(
 					entries,
+					boundaryIndex,
 					tokenizer,
-					toolCallsById,
+					toolCalls,
 					config.supersedeKey,
 					config.supersedeComplete,
 					config.protectedTools,
@@ -409,42 +565,52 @@ export function pruneToolOutputs(
 			? new Set(
 					collectUselessResults(
 						entries,
+						boundaryIndex,
 						tokenizer,
-						toolCallsById,
+						toolCalls,
 						config.protectedTools,
 						supersededMessages ?? new Set(),
 					).map(candidate => candidate.message),
 				)
 			: undefined;
 
-	const boundaryIndex = resolveBoundaryIndex(entries, config.keepBoundaryId);
 	const cacheWarmSuffixTokens = config.cacheWarmSuffixTokens;
-	// All-message suffix per index, only when the cache guard is armed.
-	const messageSuffix =
-		cacheWarmSuffixTokens === undefined ? undefined : computeMessageSuffixTokens(entries, tokenizer);
-
-	for (let i = entries.length - 1; i >= 0; i--) {
+	const lookbackFloor =
+		cacheWarmSuffixTokens === undefined
+			? boundaryIndex
+			: cacheLookbackFloor(
+					entries,
+					boundaryIndex,
+					config.cacheLookbackPositions,
+					config.convertToLlm ?? defaultConvertToLlm,
+				);
+	// Tokens of every message strictly after entry `i` (cache guard only).
+	let messageSuffix = 0;
+
+	for (let i = entries.length - 1; i >= boundaryIndex; i--) {
 		const entry = entries[i];
+		const suffixAfter = messageSuffix;
 		const message = getToolResultMessage(entry);
-		if (!message) continue;
-
-		const tokens = tokenizer.countMessage(message as AgentMessage);
-		const isProtected = isProtectedToolResult(message, toolCallsById.get(message.toolCallId), config.protectedTools);
-
-		if (message.prunedAt !== undefined) {
-			accumulatedTokens += tokens;
+		if (!message) {
+			if (cacheWarmSuffixTokens !== undefined && entry.type === "message") {
+				messageSuffix += tokenizer.countMessage(entry.message as AgentMessage);
+			}
 			continue;
 		}
 
+		const tokens = tokenizer.countMessage(message as AgentMessage);
+		messageSuffix += tokens;
+
 		// Prompt-cache guard: a result whose all-message suffix exceeds the
 		// warm-cache window sits in the already-sent cached prefix — mutating it
-		// re-writes the whole suffix (cacheWrite premium). Entries before the
-		// compaction boundary are summarized away (never sent). Both are skipped
-		// before any prune decision, so superseded/useless cannot reach a deep,
-		// still-cached copy; compaction/shake reclaim those when they rebuild.
-		const inWarmPrefix =
-			messageSuffix !== undefined && cacheWarmSuffixTokens !== undefined && messageSuffix[i] > cacheWarmSuffixTokens;
-		if (inWarmPrefix || i < boundaryIndex) {
+		// re-writes the whole suffix (cacheWrite premium), or the whole
+		// conversation once the next request's cache lookup is out of reach.
+		// Both only worsen walking back, so every older result is in the warm
+		// prefix too. Deeper, still-cached superseded/useless copies are left for
+		// compaction/shake.
+		if (cacheWarmSuffixTokens !== undefined && (suffixAfter > cacheWarmSuffixTokens || i < lookbackFloor)) break;
+
+		if (message.prunedAt !== undefined) {
 			accumulatedTokens += tokens;
 			continue;
 		}
@@ -456,7 +622,13 @@ export function pruneToolOutputs(
 		const superseded = supersededMessages?.has(message) ?? false;
 		const useless = uselessMessages?.has(message) ?? false;
 		const tooSmall = tokens < MIN_PRUNE_TOKENS;
-		if (!superseded && !useless && (accumulatedTokens < config.protectTokens || isProtected || tooSmall)) {
+		if (
+			!superseded &&
+			!useless &&
+			(accumulatedTokens < config.protectTokens ||
+				tooSmall ||
+				isProtectedToolResult(message, toolCalls.get(message.toolCallId), config.protectedTools))
+		) {
 			accumulatedTokens += tokens;
 			continue;
 		}

package/src/compaction/tool-protection.ts

@@ -11,9 +11,15 @@ export type ProtectedToolMatcher = string | ((context: ProtectedToolContext) =>
 
 const SKILL_INTERNAL_URL_PREFIX = "skill://";
 
-export function collectToolCallsById(entries: readonly SessionEntry[]): Map<string, AgentToolCall> {
+/** Map tool-call ids to their calls across `entries[start, end)` (later calls win). */
+export function collectToolCallsById(
+	entries: readonly SessionEntry[],
+	start = 0,
+	end = entries.length,
+): Map<string, AgentToolCall> {
 	const toolCalls = new Map<string, AgentToolCall>();
-	for (const entry of entries) {
+	for (let i = start; i < end; i++) {
+		const entry = entries[i];
 		if (entry.type !== "message") continue;
 		const message = entry.message;
 		if (message.role !== "assistant") continue;

package/src/index.ts

@@ -28,6 +28,8 @@ export * from "./thinking";
 export * from "./tool-context";
 // Tokenizer choice
 export * from "./tokenizer";
+// Lenient-aware tool argument validation
+export * from "./tool-arguments";
 // Types
 export * from "./types";
 // Yield utilities for Bun event-loop busy-wait prevention

package/src/speculative-execution.ts

@@ -1,5 +1,6 @@
 import * as path from "node:path";
-import { type AssistantMessage, validateToolArguments } from "@linxiraos/pi-ai";
+import type { AssistantMessage } from "@linxiraos/pi-ai";
+import { validateAgentToolArguments } from "./tool-arguments";
 import type {
 	AgentContext,
 	AgentLoopConfig,
@@ -712,15 +713,10 @@ export class SpeculativeOperationCoordinator {
 		}
 		let validatedArgs: Record<string, unknown>;
 		try {
-			validatedArgs = validateToolArguments(tool, toolCall);
+			validatedArgs = validateAgentToolArguments(tool, toolCall);
 		} catch {
-			// Lenience covers schema mismatches; a parse failure has no args to hand over.
-			if (!tool.lenientArgValidation || "__parseError" in toolCall.arguments) {
-				this.ineligible(toolCall, "tool arguments are not valid", source, parentToolCallId);
-				return undefined;
-			}
-			validatedArgs = { ...toolCall.arguments };
-			delete validatedArgs.__rawJson;
+			this.ineligible(toolCall, "tool arguments are not valid", source, parentToolCallId);
+			return undefined;
 		}
 		let executionArgs: Record<string, unknown>;
 		try {