zidane 5.3.1 → 5.3.2

package/dist/{tools-CWEDS2ZT.js → tools-CCsL5SCO.js}

@@ -2,7 +2,7 @@ import { n as createProcessContext } from "./contexts-BwiHIr2w.js";
 import { a as AgentToolPairingError, l as toTypedError, r as AgentProviderError, s as errorMessage, t as AgentAbortedError } from "./errors-Byb0F8B9.js";
 import { t as toolOutputByteLength } from "./types-IcokUOyC.js";
 import { a as detectTurnInterruption, n as SYNTHETIC_TOOL_RESULT_PLACEHOLDER, o as ensureToolResultPairing, s as filterUnresolvedToolUses } from "./messages-D0xT979U.js";
-import { t as connectMcpServers } from "./mcp-ZsSFo4Dp.js";
+import { t as connectMcpServers } from "./mcp-DhmmJfxK.js";
 import { _ as validateResourcePath, b as createSkillActivationState, d as escapeXml, n as resolveSkills, p as installAllowedToolsGate, t as interpolateShellCommands, u as buildCatalog } from "./interpolate-ERgZUxgg.js";
 import { n as formatTokenUsage, t as flattenTurns } from "./stats-DgOvY7wd.js";
 import { createHooks } from "hookable";
@@ -107,8 +107,14 @@ function rewriteMessagesToWire(messages, maps) {
 const STATE = /* @__PURE__ */ new WeakMap();
 /**
 * Get or lazily create the per-session read-state map. Returns `undefined`
-* when no session is provided — tools should treat that as "no dedup, no
-* guard": the state has nowhere to live, so every read is fresh.
+* when no session is provided.
+*
+* Most tool callers should prefer {@link resolveReadStateMap}, which
+* additionally honors an explicit `ctx.readState` (the path
+* `spawn`'s `shareReadState: true` uses to forward the parent's map
+* into a sessionless child). Use this helper directly only when the
+* Session-keyed map is exactly what you want and you don't need to
+* accept an override.
 */
 function getReadState(session) {
 	if (!session) return void 0;
@@ -119,19 +125,38 @@ function getReadState(session) {
 	}
 	return map;
 }
-const TOOL_DEDUP_STATE = /* @__PURE__ */ new WeakMap();
 /**
-* Get or lazily create the per-session tool-dedup map. Returns `undefined`
-* when no session is provided — middleware should treat that as "no dedup".
+* Resolve the active read-state map from a tool context. An explicit
+* `ctx.readState` wins (used by `spawn`'s `shareReadState` opt-in to
+* forward the parent's map into a sessionless child); otherwise the
+* usual `Session`-keyed lookup applies.
+*
+* Tools should call this helper instead of `getReadState(ctx.session)`
+* directly so the `shareReadState` plumbing is honored uniformly.
 */
-function getToolDedupState(session) {
-	if (!session) return void 0;
-	let map = TOOL_DEDUP_STATE.get(session);
-	if (!map) {
-		map = /* @__PURE__ */ new Map();
-		TOOL_DEDUP_STATE.set(session, map);
-	}
-	return map;
+function resolveReadStateMap(ctx) {
+	return ctx.readState ?? getReadState(ctx.session);
+}
+/**
+* Canonical read-state key for a `(cwd, path)` pair.
+*
+* `ctx.execution.readFile(handle, path)` resolves the model-provided
+* path against `handle.cwd` before touching disk — so `src/App.tsx`,
+* `./src/App.tsx`, and `/abs/cwd/src/App.tsx` all read the **same**
+* bytes. The read-state map MUST mirror that resolution: without it,
+* a model that reads `src/App.tsx` and then edits `./src/App.tsx`
+* trips the `requireReadBeforeEdit` gate for a file it demonstrably
+* already saw (the gate's "has not been read in this session" message
+* fires on a stale key).
+*
+* `node:path`'s `resolve(cwd, path)` short-circuits when `path` is
+* already absolute, so absolute and relative shapes converge on the
+* same canonical form. We don't `realpath()` symlinks — the file IS
+* the path the model addressed, not the realpath behind it; the host's
+* execution context decides how to dereference.
+*/
+function readStateKey(cwd, path) {
+	return resolve(cwd, path);
 }
 /**
 * FNV-1a 32-bit hash, hex-encoded. Fast, non-cryptographic — we only need
@@ -147,6 +172,20 @@ function hashContent(text) {
 	}
 	return h.toString(16).padStart(8, "0");
 }
+const TOOL_DEDUP_STATE = /* @__PURE__ */ new WeakMap();
+/**
+* Get or lazily create the per-session tool-dedup map. Returns `undefined`
+* when no session is provided — middleware should treat that as "no dedup".
+*/
+function getToolDedupState(session) {
+	if (!session) return void 0;
+	let map = TOOL_DEDUP_STATE.get(session);
+	if (!map) {
+		map = /* @__PURE__ */ new Map();
+		TOOL_DEDUP_STATE.set(session, map);
+	}
+	return map;
+}
 //#endregion
 //#region src/dedup-tools.ts
 /**
@@ -1067,19 +1106,21 @@ function applyStaleReadElision(messages) {
 }
 /**
 * Drop read-state entries for paths whose reads got elided. Keys are
-* `${cwd}::${path}` (see `src/tools/read-file.ts`); we don't know the
-* cwd in this context, so we match by `::<path>` suffix. Safe because
-* paths inside the read-state map come from a single session bound to
-* one cwd in practice; an accidental cross-cwd collision would also
-* have to share an identical relative path, in which case force-fresh
-* is the correct behavior anyway.
+* canonical absolute paths produced by `readStateKey(cwd, path)` (see
+* `src/tools/read-state.ts`); the loop has `ctx.handle.cwd` in scope,
+* so we re-derive each elided path's canonical key and delete by
+* direct lookup. No suffix matching, no cross-cwd ambiguity.
+*
+* Resolves the map via `resolveReadStateMap` so a child agent running
+* with a parent's shared map (via `shareReadState`) invalidates the
+* shared entries too — otherwise a child's `read → edit → re-read`
+* would dedup-hit on the now-stale parent entry.
 */
-function invalidateReadStateForElidedPaths(session, elidedPaths) {
-	if (!session || elidedPaths.length === 0) return;
-	const readState = getReadState(session);
+function invalidateReadStateForElidedPaths(ctx, cwd, elidedPaths) {
+	if (elidedPaths.length === 0) return;
+	const readState = resolveReadStateMap(ctx);
 	if (!readState || readState.size === 0) return;
-	const suffixes = elidedPaths.map((p) => `::${p}`);
-	for (const key of [...readState.keys()]) if (suffixes.some((s) => key.endsWith(s))) readState.delete(key);
+	for (const p of elidedPaths) readState.delete(readStateKey(cwd, p));
 }
 /**
 * Run {@link ensureToolResultPairing} with the loop's hook + strict-mode
@@ -1265,7 +1306,7 @@ async function executeTurn(ctx, turn) {
 	if (ctx.elideStaleReads === true) {
 		const elision = applyStaleReadElision(canonicalMessages);
 		canonicalMessages = elision.messages;
-		invalidateReadStateForElidedPaths(ctx.session, elision.elidedPaths);
+		invalidateReadStateForElidedPaths(ctx, ctx.handle.cwd, elision.elidedPaths);
 	}
 	const wireMessages = rewriteMessagesToWire(canonicalMessages, ctx.aliasMaps);
 	let sanitizedMessages = sanitizeStoredToolResults(ctx.provider, wireMessages);
@@ -1539,17 +1580,35 @@ function stripImagesForNonVision(provider, output) {
 	if (provider.meta.capabilities?.vision !== false) return output;
 	return output.map((b) => b.type === "image" ? IMAGE_OMITTED_MARKER : b.text).join("\n");
 }
+/**
+* Build the per-call base for every `tool:*` hook ctx (and the
+* matching shape for `mcp:tool:*`). Centralized so the `runId` /
+* `parentRunId` / `depth` identity fields land uniformly on every
+* event the loop fires — without one helper they drift across ~14
+* inline construction sites. The returned object IS the
+* {@link ToolHookContext} canonical shape; specialized hook payloads
+* (`gateCtx`, `transformCtx`, etc.) spread it and append their own
+* fields.
+*/
+function buildToolHookBase(ctx, turnId, callId, name, displayName, input) {
+	return {
+		turnId,
+		callId,
+		name,
+		displayName,
+		input,
+		...ctx.runId !== void 0 ? { runId: ctx.runId } : {},
+		...ctx.parentRunId !== void 0 ? { parentRunId: ctx.parentRunId } : {},
+		...typeof ctx.depth === "number" ? { depth: ctx.depth } : {}
+	};
+}
 async function executeSingleTool(ctx, call, turnId) {
 	const toolDef = ctx.tools[call.name];
 	const callId = call.id;
 	const displayName = toWireName(call.name, ctx.aliasMaps);
 	const runToolCounts = Object.freeze({ ...ctx.runToolCounts });
 	const gateCtx = {
-		turnId,
-		callId,
-		name: call.name,
-		displayName,
-		input: call.input,
+		...buildToolHookBase(ctx, turnId, callId, call.name, displayName, call.input),
 		block: false,
 		reason: "Tool execution was blocked",
 		runToolCounts
@@ -1602,11 +1661,7 @@ async function executeSingleTool(ctx, call, turnId) {
 	let effectiveInput = gateCtx.input;
 	if (!toolDef) {
 		const unknownCtx = {
-			turnId,
-			callId,
-			name: call.name,
-			displayName,
-			input: effectiveInput,
+			...buildToolHookBase(ctx, turnId, callId, call.name, displayName, effectiveInput),
 			suppressError: false
 		};
 		await ctx.hooks.callHook("tool:unknown", unknownCtx);
@@ -1615,11 +1670,7 @@ async function executeSingleTool(ctx, call, turnId) {
 		if (!unknownCtx.suppressError) {
 			const err = /* @__PURE__ */ new Error(`Unknown tool: ${call.name}`);
 			await ctx.hooks.callHook("tool:error", {
-				turnId,
-				callId,
-				name: call.name,
-				displayName,
-				input: effectiveInput,
+				...buildToolHookBase(ctx, turnId, callId, call.name, displayName, effectiveInput),
 				error: err
 			});
 		}
@@ -1641,11 +1692,7 @@ async function executeSingleTool(ctx, call, turnId) {
 	const validation = validateToolArgs(effectiveInput, toolDef.spec.inputSchema);
 	if (!validation.valid) {
 		await ctx.hooks.callHook("validation:reject", {
-			turnId,
-			callId,
-			name: call.name,
-			displayName,
-			input: effectiveInput,
+			...buildToolHookBase(ctx, turnId, callId, call.name, displayName, effectiveInput),
 			reason: validation.error ?? "invalid input",
 			schema: toolDef.spec.inputSchema
 		});
@@ -1667,11 +1714,7 @@ async function executeSingleTool(ctx, call, turnId) {
 	effectiveInput = validation.coercedInput ?? effectiveInput;
 	const coercions = validation.coercions && validation.coercions.length > 0 ? validation.coercions : void 0;
 	if (coercions) await ctx.hooks.callHook("validation:coerce", {
-		turnId,
-		callId,
-		name: call.name,
-		displayName,
-		input: effectiveInput,
+		...buildToolHookBase(ctx, turnId, callId, call.name, displayName, effectiveInput),
 		coercions,
 		schema: toolDef.spec.inputSchema
 	});
@@ -1685,11 +1728,7 @@ async function executeSingleTool(ctx, call, turnId) {
 		runToolCounts
 	});
 	await ctx.hooks.callHook("tool:before", {
-		turnId,
-		callId,
-		name: call.name,
-		displayName,
-		input: effectiveInput,
+		...buildToolHookBase(ctx, turnId, callId, call.name, displayName, effectiveInput),
 		runToolCounts,
 		...coercions ? { coercions } : {}
 	});
@@ -1712,18 +1751,16 @@ async function executeSingleTool(ctx, call, turnId) {
 			turnId,
 			callId,
 			runId: ctx.runId,
+			...ctx.parentRunId !== void 0 ? { parentRunId: ctx.parentRunId } : {},
 			...ctx.session ? { session: ctx.session } : {},
+			...ctx.readState ? { readState: ctx.readState } : {},
 			...typeof ctx.depth === "number" ? { depth: ctx.depth } : {}
 		};
 		output = await toolDef.execute(effectiveInput, toolCtx);
 	} catch (err) {
 		const error = err instanceof Error ? err : new Error(String(err));
 		const errorCtx = {
-			turnId,
-			callId,
-			name: call.name,
-			displayName,
-			input: effectiveInput,
+			...buildToolHookBase(ctx, turnId, callId, call.name, displayName, effectiveInput),
 			error
 		};
 		await ctx.hooks.callHook("tool:error", errorCtx);
@@ -1761,9 +1798,11 @@ async function executeSingleTool(ctx, call, turnId) {
 * across five call sites.
 */
 async function fireDispatched(ctx, params) {
-	const { reason, ...rest } = params;
+	const { turnId, callId, name, displayName, input, outcome, reason, runToolCounts } = params;
 	await ctx.hooks.callHook("tool:dispatched", {
-		...rest,
+		...buildToolHookBase(ctx, turnId, callId, name, displayName, input),
+		outcome,
+		runToolCounts,
 		...reason !== void 0 ? { reason } : {}
 	});
 }
@@ -1784,11 +1823,7 @@ async function emitToolResult(ctx, params) {
 	let output = params.output;
 	let isError = params.isError;
 	const transformCtx = {
-		turnId,
-		callId,
-		name,
-		displayName,
-		input,
+		...buildToolHookBase(ctx, turnId, callId, name, displayName, input),
 		result: output,
 		isError,
 		outputBytes: toolOutputByteLength(output),
@@ -1813,11 +1848,7 @@ async function emitToolResult(ctx, params) {
 	}
 	output = stripImagesForNonVision(ctx.provider, output);
 	await ctx.hooks.callHook("tool:after", {
-		turnId,
-		callId,
-		name,
-		displayName,
-		input,
+		...buildToolHookBase(ctx, turnId, callId, name, displayName, input),
 		result: output,
 		outputBytes: toolOutputByteLength(output),
 		runToolCounts,
@@ -2745,7 +2776,7 @@ function initialRunCounter(session) {
 	for (const t of session.turns) consider(t.runId);
 	return max;
 }
-function createAgent({ provider, name: agentName, system: agentSystem, tools: agentTools, toolAliases, behavior: agentBehavior, execution, mcpServers, session, skills: agentSkills, mcpConnector, eager, hooks: initialHooks }) {
+function createAgent({ provider, name: agentName, system: agentSystem, tools: agentTools, toolAliases, behavior: agentBehavior, execution, mcpServers, session, readState: agentReadState, skills: agentSkills, mcpConnector, eager, hooks: initialHooks }) {
 	const hooks = createHooks();
 	const executionContext = execution ?? createProcessContext();
 	const sourceTools = agentTools ?? {};
@@ -3061,6 +3092,8 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 					maxTurns,
 					maxTokens,
 					...session ? { session } : {},
+					...agentReadState ? { readState: agentReadState } : {},
+					...options.parentRunId ? { parentRunId: options.parentRunId } : {},
 					depth: runDepth,
 					thinkingBudget,
 					schema,
@@ -3624,12 +3657,14 @@ const edit = {
 		} catch {
 			return `Edit error: file not found: ${target}.${await suggestionFor(ctx.execution, ctx.handle, target)}`;
 		}
-		if (ctx.behavior?.requireReadBeforeEdit && ctx.session) {
-			const readState = getReadState(ctx.session);
-			const absKey = `${ctx.handle.cwd}::${target}`;
-			const prior = readState?.get(absKey);
-			if (!prior) return `Edit error: ${target} has not been read in this session. Call read_file first so the edit applies against the current contents.`;
-			if (prior.contentHash !== hashContent(original)) return `Edit error: ${target} has changed on disk since the last read. Re-read the file before editing.`;
+		if (ctx.behavior?.requireReadBeforeEdit) {
+			const readState = resolveReadStateMap(ctx);
+			if (readState) {
+				const absKey = readStateKey(ctx.handle.cwd, target);
+				const prior = readState.get(absKey);
+				if (!prior) return `Edit error: ${target} has not been read in this session. Call read_file first so the edit applies against the current contents. (Reads inside a \`spawn\` subagent with \`persist: false\` and without \`shareReadState: true\` do NOT propagate to the parent — re-read in the calling context.)`;
+				if (prior.contentHash !== hashContent(original)) return `Edit error: ${target} has changed on disk since the last read. Re-read the file before editing.`;
+			}
 		}
 		const match = resolveOldString(original, find);
 		if (!match) {
@@ -3642,11 +3677,11 @@ const edit = {
 		const updated = replaceAll ? original.split(actual).join(styledReplacement) : original.replace(actual, styledReplacement);
 		if (updated === original) return `Edit error: replacement produced no change in ${target}.`;
 		await ctx.execution.writeFile(ctx.handle, target, updated);
-		if (ctx.session) {
-			const readState = getReadState(ctx.session);
-			const absKey = `${ctx.handle.cwd}::${target}`;
-			const prior = readState?.get(absKey);
-			if (readState && prior) readState.set(absKey, {
+		const readState = resolveReadStateMap(ctx);
+		if (readState) {
+			const absKey = readStateKey(ctx.handle.cwd, target);
+			const prior = readState.get(absKey);
+			if (prior) readState.set(absKey, {
 				...prior,
 				contentHash: hashContent(updated),
 				mtimeMs: Date.now()
@@ -4085,12 +4120,14 @@ const multiEdit = {
 		} catch {
 			return `multi_edit error: file not found: ${target}.${await suggestionFor(ctx.execution, ctx.handle, target)}`;
 		}
-		if (ctx.behavior?.requireReadBeforeEdit && ctx.session) {
-			const readState = getReadState(ctx.session);
-			const absKey = `${ctx.handle.cwd}::${target}`;
-			const prior = readState?.get(absKey);
-			if (!prior) return `multi_edit error: ${target} has not been read in this session. Call read_file first so the edits apply against the current contents.`;
-			if (prior.contentHash !== hashContent(current)) return `multi_edit error: ${target} has changed on disk since the last read. Re-read the file before editing.`;
+		if (ctx.behavior?.requireReadBeforeEdit) {
+			const readState = resolveReadStateMap(ctx);
+			if (readState) {
+				const absKey = readStateKey(ctx.handle.cwd, target);
+				const prior = readState.get(absKey);
+				if (!prior) return `multi_edit error: ${target} has not been read in this session. Call read_file first so the edits apply against the current contents. (Reads inside a \`spawn\` subagent with \`persist: false\` and without \`shareReadState: true\` do NOT propagate to the parent — re-read in the calling context.)`;
+				if (prior.contentHash !== hashContent(current)) return `multi_edit error: ${target} has changed on disk since the last read. Re-read the file before editing.`;
+			}
 		}
 		let totalReplacements = 0;
 		for (let i = 0; i < steps.length; i++) {
@@ -4110,11 +4147,11 @@ const multiEdit = {
 			totalReplacements += occurrences;
 		}
 		await ctx.execution.writeFile(ctx.handle, target, current);
-		if (ctx.session) {
-			const readState = getReadState(ctx.session);
-			const absKey = `${ctx.handle.cwd}::${target}`;
-			const prior = readState?.get(absKey);
-			if (readState && prior) readState.set(absKey, {
+		const readState = resolveReadStateMap(ctx);
+		if (readState) {
+			const absKey = readStateKey(ctx.handle.cwd, target);
+			const prior = readState.get(absKey);
+			if (prior) readState.set(absKey, {
 				...prior,
 				contentHash: hashContent(current),
 				mtimeMs: Date.now()
@@ -4264,14 +4301,16 @@ const readFile$1 = {
 			return `File not found: ${path}.${await suggestionFor(ctx.execution, ctx.handle, path)}`;
 		}
 		const totalBytes = Buffer.byteLength(raw);
-		const readState = ctx.behavior?.dedupReads !== false ? getReadState(ctx.session) : void 0;
-		const absKey = `${ctx.handle.cwd}::${path}`;
+		const dedupEnabled = ctx.behavior?.dedupReads !== false;
+		const gateEnabled = ctx.behavior?.requireReadBeforeEdit === true;
+		const readState = dedupEnabled || gateEnabled ? resolveReadStateMap(ctx) : void 0;
+		const absKey = readStateKey(ctx.handle.cwd, path);
 		const offsetForKey = normalizeInteger(offset, 1);
 		const limitForKey = normalizeInteger(limit, DEFAULT_LINE_LIMIT);
 		const maxBytesForKey = normalizeInteger(maxBytes, DEFAULT_BYTE_CAP);
 		const showLineNumbers = typeof lineNumbers === "boolean" ? lineNumbers : ctx.behavior?.readLineNumbers ?? true;
 		const currentHash = readState ? hashContent(raw) : "";
-		if (readState) {
+		if (dedupEnabled && readState) {
 			const prior = readState.get(absKey);
 			if (prior && prior.contentHash === currentHash && prior.offset === offsetForKey && prior.limit === limitForKey && prior.maxBytes === maxBytesForKey && prior.lineNumbers === showLineNumbers) return `File ${path} unchanged since the previous read in this session — the prior result is still current.`;
 		}
@@ -4717,18 +4756,23 @@ function createSpawnTool(options = {}) {
 			let result = "";
 			let unbubble;
 			try {
-				const agent = createAgent({
+				const parentPreset = {
 					...ctx.name !== void 0 ? { name: ctx.name } : {},
 					...ctx.system !== void 0 ? { system: ctx.system } : {},
 					tools: ctx.tools,
 					...ctx.toolAliases !== void 0 ? { toolAliases: ctx.toolAliases } : {},
 					...ctx.mcpServers !== void 0 ? { mcpServers: ctx.mcpServers } : {},
 					...ctx.skills !== void 0 ? { skills: ctx.skills } : {},
-					...ctx.behavior !== void 0 ? { behavior: ctx.behavior } : {},
+					...ctx.behavior !== void 0 ? { behavior: ctx.behavior } : {}
+				};
+				const sharedReadState = options.shareReadState ? resolveReadStateMap(ctx) : void 0;
+				const agent = createAgent({
+					...parentPreset,
 					...options.preset,
 					provider: ctx.provider,
 					execution: ctx.execution,
-					...options.persist && ctx.session ? { session: ctx.session } : {}
+					...options.persist && ctx.session ? { session: ctx.session } : {},
+					...sharedReadState ? { readState: sharedReadState } : {}
 				});
 				if (forwardHooks) {
 					const unregisterEnricher = agent.hooks.hook("tool:before", async (toolCtx) => {
@@ -4903,6 +4947,6 @@ const writeFile$1 = {
 	}
 };
 //#endregion
-export { PERSISTENCE_PREVIEW_BYTES as C, resolvePersistDir as D, maybePersistToolResult as E, getReadState as O, PERSISTED_STUB_PREFIX as S, cleanupPersistedSession as T, createSkillsReadTool as _, multiEdit as a, TOOL_USE_SKIPPED_MESSAGE as b, grep as c, resolveOldString as d, styleReplacementForVia as f, createSkillsRunScriptTool as g, createSkillsUseTool as h, readFile$1 as i, glob as l, createToolSearchTool as m, createSpawnTool as n, listFiles as o, createAgent as p, shell as r, createInteractionTool as s, writeFile$1 as t, edit as u, INTERRUPT_MESSAGE_FOR_TOOL_USE as v, buildPersistedStub as w, validateToolArgs as x, TOOL_USE_AFTER_ERROR_MESSAGE as y };
+export { readStateKey as A, PERSISTENCE_PREVIEW_BYTES as C, resolvePersistDir as D, maybePersistToolResult as E, getReadState as O, PERSISTED_STUB_PREFIX as S, cleanupPersistedSession as T, createSkillsReadTool as _, multiEdit as a, TOOL_USE_SKIPPED_MESSAGE as b, grep as c, resolveOldString as d, styleReplacementForVia as f, createSkillsRunScriptTool as g, createSkillsUseTool as h, readFile$1 as i, resolveReadStateMap as j, hashContent as k, glob as l, createToolSearchTool as m, createSpawnTool as n, listFiles as o, createAgent as p, shell as r, createInteractionTool as s, writeFile$1 as t, edit as u, INTERRUPT_MESSAGE_FOR_TOOL_USE as v, buildPersistedStub as w, validateToolArgs as x, TOOL_USE_AFTER_ERROR_MESSAGE as y };
 
-//# sourceMappingURL=tools-CWEDS2ZT.js.map
+//# sourceMappingURL=tools-CCsL5SCO.js.map