zidane 5.4.1 → 5.4.3

package/dist/{tools-PQH1Ge4M.js → tools-BK2vG9UX.js}

@@ -1,9 +1,9 @@
 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 { a as AgentToolPairingError, l as toTypedError, r as AgentProviderError, s as errorMessage, t as AgentAbortedError } from "./errors-CDwtPIMX.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-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 { a as detectTurnInterruption, n as SYNTHETIC_TOOL_RESULT_PLACEHOLDER, o as ensureToolResultPairing, s as filterUnresolvedToolUses } from "./messages-fTR19Ga6.js";
+import { t as connectMcpServers } from "./mcp-CNUbvbsy.js";
+import { _ as validateResourcePath, b as createSkillActivationState, d as escapeXml, n as resolveSkills, p as installAllowedToolsGate, t as interpolateShellCommands, u as buildCatalog } from "./interpolate-CmtjEyRJ.js";
 import { n as formatTokenUsage, t as flattenTurns } from "./stats-DgOvY7wd.js";
 import { createHooks } from "hookable";
 import { mkdir, rename, rm, stat, writeFile } from "node:fs/promises";
@@ -812,6 +812,27 @@ const INTERRUPT_MESSAGE_FOR_TOOL_USE = "[Request interrupted by user for tool us
 */
 const TOOL_USE_SKIPPED_MESSAGE = "[Tool use skipped — superseded by user message]";
 /**
+* Canonical tool_result text emitted when a single tool call is cancelled
+* mid-flight via `agent.cancelTool(callId)` (typically the TUI's
+* "cancel this tool" affordance). Distinguished from
+* {@link INTERRUPT_MESSAGE_FOR_TOOL_USE} (run-wide user abort) and
+* {@link TOOL_USE_SKIPPED_MESSAGE} (steered) so the model — and downstream
+* consumers — can tell the three apart by string match.
+*
+* Always paired with `isError: true` on the wire so the model treats the
+* call as failed rather than as a successful response. The remaining tool
+* calls in the batch continue running, in contrast with a full-run abort.
+*/
+const TOOL_USE_CANCELLED_MESSAGE = "[Tool call cancelled by user]";
+/**
+* Sentinel message rejected from the per-call cancellation promise inside
+* {@link executeSingleTool}'s race. Plain-string and module-private — only
+* the surrounding code reads it (via the `perCallAbort.signal.aborted`
+* guard, NOT the message itself), so it just needs to be a stable
+* non-empty identifier the rejection can carry.
+*/
+const CANCELLED_BY_USER_SENTINEL = "zidane:tool:cancelled-by-user";
+/**
 * Compute the effective thinking budget for a given run-relative turn, given
 * the configured decay schedule. Pure helper — exported for tests and so
 * downstream tooling can preview decay curves without spinning up the loop.
@@ -1184,7 +1205,14 @@ async function runLoop(ctx) {
 				await ctx.hooks.callHook("agent:abort", {});
 				break;
 			}
-			const result = await executeTurn(ctx, turn);
+			const result = await executeTurn(ctx, turn, {
+				input: totalIn,
+				output: totalOut,
+				cacheRead: totalCacheRead,
+				cacheCreation: totalCacheCreation,
+				priorCost: turnUsages.reduce((s, t) => s + (t.cost ?? 0), 0),
+				priorTurns: turnsCompleted
+			});
 			turnsCompleted = turn + 1;
 			totalIn += result.usage.input;
 			totalOut += result.usage.output;
@@ -1295,7 +1323,49 @@ function buildStreamErrorPlaceholder(err) {
 	const oneLine = raw.replace(/\s+/g, " ");
 	return `[✗ Streaming failed before any output: ${oneLine.length > ERROR_PLACEHOLDER_MAX ? `${oneLine.slice(0, ERROR_PLACEHOLDER_MAX - 1).trimEnd()}…` : oneLine}]`;
 }
-async function executeTurn(ctx, turn) {
+function buildCumulativeUsage(prior, turnUsage) {
+	const cost = prior.priorCost + (turnUsage.cost ?? 0);
+	return Object.freeze({
+		input: prior.input + turnUsage.input,
+		output: prior.output + turnUsage.output,
+		cacheRead: prior.cacheRead + (turnUsage.cacheRead ?? 0),
+		cacheCreation: prior.cacheCreation + (turnUsage.cacheCreation ?? 0),
+		...cost > 0 ? { cost } : {},
+		turns: prior.priorTurns + 1
+	});
+}
+/**
+* Best-effort extraction of `statusCode` / `requestId` from native provider
+* SDK exceptions, attached to `stream:error` ctx so observability handlers
+* don't have to walk `cause` chains. Recognized shapes:
+*
+* - Anthropic SDK `APIError` (`status`, `headers['request-id']`)
+* - OpenAI SDK error (`status`, `headers['x-request-id']`)
+* - OpenRouter / OpenAI-compat HTTP errors (`status`)
+* - Cerebras (`status`)
+*
+* Silent no-op for arbitrary `Error`s and primitives — the fields stay
+* undefined and the raw `err` is still forwarded for handlers that need
+* full context.
+*/
+function extractStreamErrorMeta(err) {
+	if (!err || typeof err !== "object") return {};
+	const e = err;
+	const out = {};
+	const statusCandidate = typeof e.status === "number" ? e.status : typeof e.statusCode === "number" ? e.statusCode : void 0;
+	if (typeof statusCandidate === "number" && Number.isFinite(statusCandidate)) out.statusCode = statusCandidate;
+	if (typeof e.requestId === "string") out.requestId = e.requestId;
+	else {
+		const headers = e.headers;
+		if (headers && typeof headers === "object") {
+			const h = headers;
+			const candidate = h["request-id"] ?? h["x-request-id"] ?? h.requestId;
+			if (typeof candidate === "string") out.requestId = candidate;
+		}
+	}
+	return out;
+}
+async function executeTurn(ctx, turn, priorUsage) {
 	const turnId = await ctx.generateTurnId();
 	let canonicalMessages = turnsToMessages(applyCompactSummaryCutoff(ctx.turns));
 	if (ctx.elideStaleReads === true) {
@@ -1343,10 +1413,20 @@ async function executeTurn(ctx, turn) {
 	});
 	let currentText = "";
 	let currentThinking = "";
+	const streamStartedAt = Date.now();
+	let turnTtftMs;
+	const markTurnTtft = () => {
+		if (turnTtftMs === void 0) turnTtftMs = Date.now() - streamStartedAt;
+	};
+	await ctx.hooks.callHook("stream:start", {
+		turnId,
+		startedAt: streamStartedAt
+	});
 	let result;
 	try {
 		result = await ctx.provider.stream(streamOptions, {
 			onText(delta) {
+				markTurnTtft();
 				currentText += delta;
 				ctx.hooks.callHook("stream:text", {
 					delta,
@@ -1355,6 +1435,7 @@ async function executeTurn(ctx, turn) {
 				});
 			},
 			onThinking(delta) {
+				markTurnTtft();
 				currentThinking += delta;
 				ctx.hooks.callHook("stream:thinking", {
 					delta,
@@ -1389,10 +1470,14 @@ async function executeTurn(ctx, turn) {
 			createdAt: Date.now()
 		};
 		ctx.turns.push(errorTurn);
-		if (!wasAborted) await ctx.hooks.callHook("stream:error", {
-			err,
-			turnId
-		});
+		if (!wasAborted) {
+			const meta = extractStreamErrorMeta(err);
+			await ctx.hooks.callHook("stream:error", {
+				err,
+				turnId,
+				...meta
+			});
+		}
 		await ctx.hooks.callHook("turn:after", {
 			turn,
 			turnId,
@@ -1401,7 +1486,8 @@ async function executeTurn(ctx, turn) {
 			toolCounts: {
 				turn: Object.freeze({}),
 				run: Object.freeze({ ...ctx.runToolCounts })
-			}
+			},
+			cumulativeUsage: buildCumulativeUsage(priorUsage, errorUsage)
 		});
 		throw wrapProviderError(err, ctx);
 	}
@@ -1409,11 +1495,13 @@ async function executeTurn(ctx, turn) {
 		text: currentText,
 		turnId
 	});
+	if (turnTtftMs === void 0 && result.toolCalls.length > 0) turnTtftMs = Date.now() - streamStartedAt;
 	const canonicalToolCalls = result.toolCalls.map((tc) => ({
 		...tc,
 		name: toCanonicalName(tc.name, ctx.aliasMaps)
 	}));
 	const canonicalContent = rewriteContentToCanonical(result.assistantMessage?.content ?? [], ctx.aliasMaps);
+	if (turnTtftMs !== void 0 && result.usage.timeToFirstTokenMs === void 0) result.usage.timeToFirstTokenMs = turnTtftMs;
 	const assistantTurn = {
 		id: turnId,
 		runId: ctx.runId,
@@ -1436,7 +1524,8 @@ async function executeTurn(ctx, turn) {
 		toolCounts: {
 			turn: Object.freeze(turnCounts),
 			run: Object.freeze({ ...ctx.runToolCounts })
-		}
+		},
+		cumulativeUsage: buildCumulativeUsage(priorUsage, result.usage)
 	});
 	if (result.done) {
 		if (ctx.schema && !ctx.signal.aborted) {
@@ -1602,6 +1691,29 @@ async function executeSingleTool(ctx, call, turnId) {
 	const callId = call.id;
 	const displayName = toWireName(call.name, ctx.aliasMaps);
 	const runToolCounts = Object.freeze({ ...ctx.runToolCounts });
+	const perCallAbort = new AbortController();
+	ctx.pendingToolCancels?.set(callId, perCallAbort);
+	try {
+		return await runSingleToolDispatch(ctx, call, turnId, {
+			toolDef,
+			callId,
+			displayName,
+			runToolCounts,
+			perCallAbort
+		});
+	} finally {
+		ctx.pendingToolCancels?.delete(callId);
+	}
+}
+/**
+* Body of {@link executeSingleTool}. Hoisted into its own function purely so
+* the per-call cancel registration (which spans every exit path) can sit in
+* a tight `try / finally` at the call site. Behavior is unchanged from the
+* pre-cancel implementation aside from the user-cancel branch in the
+* execute body — see {@link TOOL_USE_CANCELLED_MESSAGE}.
+*/
+async function runSingleToolDispatch(ctx, call, turnId, fixed) {
+	const { toolDef, callId, displayName, runToolCounts, perCallAbort } = fixed;
 	const gateCtx = {
 		...buildToolHookBase(ctx, turnId, callId, call.name, displayName, call.input),
 		block: false,
@@ -1727,12 +1839,14 @@ async function executeSingleTool(ctx, call, turnId) {
 		runToolCounts,
 		...coercions ? { coercions } : {}
 	});
-	let output;
+	let output = "";
 	let isError = false;
+	let cancelledByUser = false;
+	const childSignal = typeof AbortSignal.any === "function" ? AbortSignal.any([ctx.signal, perCallAbort.signal]) : ctx.signal;
 	try {
 		const toolCtx = {
 			provider: ctx.provider,
-			signal: ctx.signal,
+			signal: childSignal,
 			execution: ctx.execution,
 			handle: ctx.handle,
 			hooks: ctx.hooks,
@@ -1751,16 +1865,48 @@ async function executeSingleTool(ctx, call, turnId) {
 			...ctx.readState ? { readState: ctx.readState } : {},
 			...typeof ctx.depth === "number" ? { depth: ctx.depth } : {}
 		};
-		output = await toolDef.execute(effectiveInput, toolCtx);
+		const bodyPromise = toolDef.execute(effectiveInput, toolCtx);
+		bodyPromise.catch(() => {});
+		let removeAbortListener;
+		const cancellationPromise = new Promise((_, reject) => {
+			if (perCallAbort.signal.aborted) {
+				reject(new Error(CANCELLED_BY_USER_SENTINEL));
+				return;
+			}
+			const onAbort = () => reject(new Error(CANCELLED_BY_USER_SENTINEL));
+			perCallAbort.signal.addEventListener("abort", onAbort, { once: true });
+			removeAbortListener = () => perCallAbort.signal.removeEventListener("abort", onAbort);
+		});
+		try {
+			output = await Promise.race([bodyPromise, cancellationPromise]);
+		} finally {
+			removeAbortListener?.();
+		}
 	} catch (err) {
-		const error = err instanceof Error ? err : new Error(String(err));
-		const errorCtx = {
+		if (perCallAbort.signal.aborted && !ctx.signal.aborted) cancelledByUser = true;
+		else {
+			const error = err instanceof Error ? err : new Error(String(err));
+			const errorCtx = {
+				...buildToolHookBase(ctx, turnId, callId, call.name, displayName, effectiveInput),
+				error
+			};
+			await ctx.hooks.callHook("tool:error", errorCtx);
+			output = errorCtx.result ?? `Tool error: ${error.message}`;
+			isError = true;
+		}
+	}
+	if (cancelledByUser) {
+		const reason = typeof perCallAbort.signal.reason === "string" ? perCallAbort.signal.reason : "cancelled-by-user";
+		await ctx.hooks.callHook("tool:cancelled", {
 			...buildToolHookBase(ctx, turnId, callId, call.name, displayName, effectiveInput),
-			error
-		};
-		await ctx.hooks.callHook("tool:error", errorCtx);
-		output = errorCtx.result ?? `Tool error: ${error.message}`;
-		isError = true;
+			reason,
+			runToolCounts
+		});
+		return { result: {
+			id: callId,
+			content: TOOL_USE_CANCELLED_MESSAGE,
+			isError: true
+		} };
 	}
 	const emitted = await emitToolResult(ctx, {
 		turnId,
@@ -2412,14 +2558,21 @@ function createSkillsUseTool(options) {
 	return {
 		spec: {
 			name: "skills_use",
-			description: "Activate a specialized skill and load its full instructions. Call this when a task matches a skill's description from the catalog. After calling, follow the returned instructions; use skills_read to load referenced files and skills_run_script to execute bundled scripts.",
+			description: "Activate or deactivate a specialized skill. Call with `mode: \"activate\"` (default) to load a skill's full instructions when a task matches its catalog description. Call with `mode: \"deactivate\"` to release a skill whose allowed-tools restrictions are now in the way — e.g. when the skill's work is done or the active skill is blocking unrelated tool calls. After activating, follow the returned instructions; use skills_read to load referenced files and skills_run_script to execute bundled scripts.",
 			inputSchema: {
 				type: "object",
-				properties: { name: {
-					type: "string",
-					enum: options.catalog.map((s) => s.name),
-					description: "The name of the skill to activate (must be in the available skills catalog)."
-				} },
+				properties: {
+					name: {
+						type: "string",
+						enum: options.catalog.map((s) => s.name),
+						description: "The name of the skill to activate or deactivate (must be in the available skills catalog)."
+					},
+					mode: {
+						type: "string",
+						enum: ["activate", "deactivate"],
+						description: "Whether to activate (load + apply the skill) or deactivate (release an active skill). Default: \"activate\"."
+					}
+				},
 				required: ["name"],
 				additionalProperties: false
 			}
@@ -2428,8 +2581,18 @@ function createSkillsUseTool(options) {
 			const skillName = input.name;
 			const skill = byName.get(skillName);
 			if (!skill) return `Error: unknown skill "${skillName}". Available skills: ${[...byName.keys()].join(", ") || "<none>"}.`;
+			if ((input.mode ?? "activate") === "deactivate") {
+				const removed = options.state.deactivate(skillName);
+				if (!removed) return `Skill "${skillName}" was not active — nothing to deactivate.`;
+				await options.hooks.callHook("skills:deactivate", {
+					skill: removed.skill,
+					reason: "model"
+				});
+				const remaining = options.state.active().map((a) => a.skill.name);
+				return `Skill "${skillName}" deactivated — its allowed-tools restrictions no longer apply.${remaining.length > 0 ? ` Remaining active skills: ${remaining.join(", ")}.` : " No skills are currently active."}`;
+			}
 			if (!options.state.isActive(skillName)) {
-				if (options.state.activate(skill, "model") === "cap-reached") return `Error: cannot activate "${skillName}" — the maxActive skill cap has been reached. Currently active: ${options.state.active().map((a) => a.skill.name).join(", ")}. Deactivate an existing skill first.`;
+				if (options.state.activate(skill, "model") === "cap-reached") return `Error: cannot activate "${skillName}" — the maxActive skill cap has been reached. Currently active: ${options.state.active().map((a) => a.skill.name).join(", ")}. Call \`skills_use\` with \`mode: "deactivate"\` and one of those names first.`;
 				await options.hooks.callHook("skills:activate", {
 					skill,
 					via: "model"
@@ -2590,9 +2753,11 @@ function createToolSearchTool(options) {
 //#region src/agent.ts
 const HOOK_EVENT_SET = new Set([
 	"system:before",
+	"agent:start",
 	"turn:before",
 	"turn:after",
 	"tool-results:after",
+	"stream:start",
 	"stream:text",
 	"stream:end",
 	"stream:thinking",
@@ -2603,6 +2768,7 @@ const HOOK_EVENT_SET = new Set([
 	"tool:before",
 	"tool:after",
 	"tool:error",
+	"tool:cancelled",
 	"tool:transform",
 	"tool:unknown",
 	"validation:reject",
@@ -2624,6 +2790,7 @@ const HOOK_EVENT_SET = new Set([
 	"child:tool:after",
 	"child:tool:transform",
 	"child:tool:error",
+	"child:tool:cancelled",
 	"child:turn:after",
 	"mcp:connect",
 	"mcp:error",
@@ -2649,6 +2816,7 @@ const HOOK_EVENT_SET = new Set([
 	"budget:exceeded",
 	"tool-budget:exceeded",
 	"pairing:repair",
+	"tracing:redact",
 	"agent:abort",
 	"agent:done",
 	"session:start",
@@ -2902,6 +3070,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 	let running = false;
 	let idleResolve;
 	let idlePromise;
+	const pendingToolCancels = /* @__PURE__ */ new Map();
 	let executionHandle = null;
 	let mcpConnection = null;
 	let mcpWarmupPromise = null;
@@ -2983,6 +3152,16 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 					prompt: promptLabel
 				});
 			}
+			const runStartedAt = Date.now();
+			await hooks.callHook("agent:start", {
+				runId,
+				...options.parentRunId ? { parentRunId: options.parentRunId } : {},
+				depth: typeof options.depth === "number" ? options.depth : 0,
+				...agentName ? { agentName } : {},
+				...provider.name ? { providerName: provider.name } : {},
+				startedAt: runStartedAt,
+				...options.tracingContext ? { tracingContext: Object.freeze({ ...options.tracingContext }) } : {}
+			});
 			if (externalSignal) if (externalSignal.aborted) abortController.abort();
 			else {
 				externalAbortListener = () => abortController?.abort();
@@ -3009,20 +3188,27 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 			await ensureSkillsResolved();
 			if (resolvedSkills && session && session.turns.length > 0 && skillActivationState.active().length === 0) {
 				const skillsByName = new Map(resolvedSkills.map((s) => [s.name, s]));
+				const lastModeBySkill = /* @__PURE__ */ new Map();
 				for (const turn of session.turns) {
 					if (turn.role !== "assistant") continue;
 					for (const block of turn.content) {
 						if (block.type !== "tool_call" || block.name !== "skills_use") continue;
-						const skillName = block.input?.name;
+						const input = block.input;
+						const skillName = input?.name;
 						if (!skillName) continue;
-						const skill = skillsByName.get(skillName);
-						if (!skill) continue;
-						if (skillActivationState.activate(skill, "resume") === "ok") await hooks.callHook("skills:activate", {
-							skill,
-							via: "resume"
-						});
+						const mode = input?.mode === "deactivate" ? "deactivate" : "activate";
+						lastModeBySkill.set(skillName, mode);
 					}
 				}
+				for (const [skillName, mode] of lastModeBySkill) {
+					if (mode !== "activate") continue;
+					const skill = skillsByName.get(skillName);
+					if (!skill) continue;
+					if (skillActivationState.activate(skill, "resume") === "ok") await hooks.callHook("skills:activate", {
+						skill,
+						via: "resume"
+					});
+				}
 			}
 			const thinking = options.thinking ?? "off";
 			const model = options.model ?? provider.meta.defaultModel;
@@ -3220,7 +3406,8 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 					...strictToolPairing ? { strictToolPairing: true } : {},
 					providerName: provider.name,
 					runStartMs,
-					runToolCounts: {}
+					runToolCounts: {},
+					pendingToolCancels
 				});
 				const parentTurnCost = stats.turnUsage?.reduce((sum, t) => sum + (t.cost ?? 0), 0) ?? 0;
 				let childrenIn = 0;
@@ -3317,6 +3504,12 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 	function abort() {
 		abortController?.abort();
 	}
+	function cancelTool(callId, reason) {
+		const controller = pendingToolCancels.get(callId);
+		if (!controller || controller.signal.aborted) return false;
+		controller.abort(reason ?? "user-cancelled-tool");
+		return true;
+	}
 	function steer(message) {
 		steeringQueue.push(message);
 	}
@@ -3410,6 +3603,8 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 	async function destroy() {
 		if (destroyed) return;
 		destroyed = true;
+		for (const controller of pendingToolCancels.values()) if (!controller.signal.aborted) controller.abort("agent-destroyed");
+		pendingToolCancels.clear();
 		if (mcpWarmupPromise) try {
 			await mcpWarmupPromise;
 		} catch {}
@@ -3430,6 +3625,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 		hooks,
 		run,
 		abort,
+		cancelTool,
 		steer,
 		followUp: followUpFn,
 		waitForIdle,
@@ -4821,6 +5017,7 @@ const BUBBLED_EVENTS = [
 	"tool:before",
 	"tool:after",
 	"tool:error",
+	"tool:cancelled",
 	"turn:after"
 ];
 const BUBBLED_MUTABLE_EVENTS = [
@@ -4837,6 +5034,7 @@ const CHILD_EVENT_NAME = {
 	"tool:before": "child:tool:before",
 	"tool:after": "child:tool:after",
 	"tool:error": "child:tool:error",
+	"tool:cancelled": "child:tool:cancelled",
 	"turn:after": "child:turn:after"
 };
 const CHILD_MUTABLE_EVENT_NAME = {
@@ -5065,7 +5263,7 @@ function createSpawnTool(options = {}) {
 				});
 				if (forwardHooks) {
 					const unregisterEnricher = agent.hooks.hook("tool:before", async (toolCtx) => {
-						if (toolCtx.name !== "write_file") return;
+						if (toolCtx.name !== "write_file" && toolCtx.name !== "edit" && toolCtx.name !== "multi_edit") return;
 						if (!agent.handle) return;
 						const inputPath = toolCtx.input?.path;
 						if (typeof inputPath !== "string") return;
@@ -5080,11 +5278,14 @@ function createSpawnTool(options = {}) {
 					};
 				}
 				options.onSpawn?.(child);
-				await ctx.hooks.callHook("spawn:before", {
+				const spawnHookCtx = {
 					id,
 					task,
-					depth: childDepth
-				});
+					depth: childDepth,
+					tracingContext: {}
+				};
+				await ctx.hooks.callHook("spawn:before", spawnHookCtx);
+				const propagatedTracing = Object.keys(spawnHookCtx.tracingContext).length > 0 ? Object.freeze({ ...spawnHookCtx.tracingContext }) : void 0;
 				const runPromise = agent.run({
 					prompt: task,
 					model: options.model,
@@ -5092,7 +5293,8 @@ function createSpawnTool(options = {}) {
 					thinking: options.thinking,
 					signal: ctx.signal,
 					depth: childDepth,
-					...options.persist && ctx.runId ? { parentRunId: ctx.runId } : {}
+					...options.persist && ctx.runId ? { parentRunId: ctx.runId } : {},
+					...propagatedTracing ? { tracingContext: propagatedTracing } : {}
 				});
 				try {
 					finalStats = await raceWithTimeout(runPromise, options.timeoutMs);
@@ -5236,6 +5438,6 @@ const writeFile$1 = {
 	}
 };
 //#endregion
-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, SHELL_CASCADE_CANCEL_MESSAGE as y };
+export { hashContent as A, PERSISTED_STUB_PREFIX as C, maybePersistToolResult as D, cleanupPersistedSession as E, resolveReadStateMap as M, resolvePersistDir as O, validateToolArgs as S, buildPersistedStub as T, createSkillsReadTool as _, multiEdit as a, TOOL_USE_CANCELLED_MESSAGE as b, grep as c, resolveOldString as d, styleReplacementForVia as f, createSkillsRunScriptTool as g, createSkillsUseTool as h, readFile$1 as i, readStateKey as j, getReadState 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, PERSISTENCE_PREVIEW_BYTES as w, TOOL_USE_SKIPPED_MESSAGE as x, SHELL_CASCADE_CANCEL_MESSAGE as y };
 
-//# sourceMappingURL=tools-PQH1Ge4M.js.map
+//# sourceMappingURL=tools-BK2vG9UX.js.map