zidane 5.8.5 → 5.9.2

package/dist/{tools-DOUtulS5.js → tools-CAdllmWO.js}

@@ -1,5 +1,5 @@
 import { c as formatTaskStatus, f as buildContextBreakdown, h as utf8ByteLength, l as formatTaskSummary, n as stripLineNumberPrefixes, r as styleReplacementForVia, s as formatDuration, t as resolveOldString, u as previewLine } from "./edit-utils-DnfNoj16.js";
-import { a as createCursorOAuthProvider, c as anthropic, d as ANTHROPIC_EXTRA_MODELS, f as FAST_MODE_OPTIONS, n as openai, o as generatePkce, r as local, s as cerebras, t as openrouter } from "./providers-ByITfqRA.js";
+import { a as createCursorOAuthProvider, c as anthropic, d as ANTHROPIC_EXTRA_MODELS, f as FAST_MODE_OPTIONS, n as openai, o as generatePkce, r as local, s as cerebras, t as openrouter } from "./providers-CezC9my7.js";
 import { i as AgentProviderError, l as errorMessage, n as AgentBudgetExceededError, o as AgentToolPairingError, p as toTypedError, t as AgentAbortedError } from "./errors-B-GeaKTX.js";
 import { E as appendStaticSection, a as detectTurnInterruption, c as filterUnresolvedToolUses, k as renderSystemForWire, n as SYNTHETIC_TOOL_RESULT_PLACEHOLDER, o as ensureEndsWithUserMessage, s as ensureToolResultPairing } from "./messages-Dhva-Ewy.js";
 import { t as reconcileImageMediaType } from "./image-sniff-B7uFSNO1.js";
@@ -3022,7 +3022,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 		const totalBytes = toolResults.reduce((sum, r) => {
 			if (excludeSet && nameById) {
 				const name = nameById.get(r.id);
-				if (name !== void 0 && excludeSet.has(name)) return sum;
+				if (typeof name === "string" && excludeSet.has(name)) return sum;
 			}
 			return sum + toolOutputByteLength(r.content);
 		}, 0);
@@ -3307,6 +3307,7 @@ async function runSingleToolDispatch(ctx, call, turnId, fixed) {
 			isError = true;
 		} else {
 			const error = err instanceof Error ? err : new Error(String(err));
+			if (ctx.shouldRethrowToolError?.(error)) throw error;
 			const errorCtx = {
 				...buildToolHookBase(ctx, turnId, callId, call.name, displayName, effectiveInput),
 				error
@@ -3492,6 +3493,381 @@ function resolveConcurrencySafe(def, input) {
 * AND carries the shell-cascade signal — siblings see one signal source.
 */
 async function executeToolBatch(ctx, toolCalls, turnId) {
+	if (ctx.toolBatchExecutor) return executeCustomToolBatch(ctx, toolCalls, turnId, ctx.toolBatchExecutor);
+	return executeNativeToolBatch(ctx, toolCalls, turnId);
+}
+async function executeCustomToolBatch(ctx, toolCalls, turnId, executor) {
+	if (toolCalls.length === 0) return [];
+	const N = toolCalls.length;
+	const maxConcurrent = Math.max(1, ctx.maxConcurrentTools ?? DEFAULT_MAX_CONCURRENT_TOOLS);
+	const safe = Array.from({ length: N });
+	for (let i = 0; i < N; i++) safe[i] = resolveConcurrencySafe(ctx.tools[toolCalls[i].name], toolCalls[i].input);
+	const siblingAbort = new AbortController();
+	let parentAbortListener;
+	if (ctx.signal.aborted) siblingAbort.abort(ctx.signal.reason ?? "parent-aborted");
+	else {
+		parentAbortListener = () => siblingAbort.abort(ctx.signal.reason ?? "parent-aborted");
+		ctx.signal.addEventListener("abort", parentAbortListener, { once: true });
+	}
+	const childCtx = {
+		...ctx,
+		signal: siblingAbort.signal,
+		toolBatchExecutor: void 0
+	};
+	const cancelMessage = () => {
+		if (ctx.signal.aborted) return INTERRUPT_MESSAGE_FOR_TOOL_USE;
+		if (siblingAbort.signal.reason === SHELL_CASCADE_REASON) return SHELL_CASCADE_CANCEL_MESSAGE;
+		return INTERRUPT_MESSAGE_FOR_TOOL_USE;
+	};
+	const execute = async (index) => {
+		const call = toolCalls[index];
+		try {
+			const { result } = await executeSingleTool(childCtx, call, turnId);
+			const isUserCancel = typeof result.content === "string" && result.content === "[Tool call cancelled by user]";
+			if (result.isError && !isUserCancel && call.name === SHELL_TOOL_NAME && !siblingAbort.signal.aborted) siblingAbort.abort(SHELL_CASCADE_REASON);
+			return result;
+		} catch (err) {
+			if (ctx.shouldRethrowToolError?.(err)) throw err;
+			const isAbort = siblingAbort.signal.aborted || ctx.signal.aborted || err instanceof Error && err.name === "AbortError";
+			return {
+				id: call.id,
+				content: isAbort ? cancelMessage() : `Error: ${errorMessage(err)}`,
+				isError: true
+			};
+		}
+	};
+	const executeDurable = async (indices, all) => {
+		const starts = [];
+		const results = /* @__PURE__ */ new Map();
+		try {
+			for (const index of indices) {
+				const started = await startDurableToolExecution(childCtx, toolCalls[index], turnId, index);
+				if (started.kind === "result") results.set(index, started.result);
+				else starts.push(started.start);
+			}
+			if (starts.length > 0) {
+				const settledPromises = [];
+				for (const start of starts) {
+					if (!hasDurableMap(start.promise)) throw new TypeError(`Tool ${start.name} is marked durable but did not return a mappable durable promise. Wrap the tool with the runtime adapter before enabling durable parallel scheduling.`);
+					settledPromises.push(start.promise.map((value, failure) => {
+						if (failure !== void 0) return {
+							ok: false,
+							error: serializeToolFailure(failure)
+						};
+						return {
+							ok: true,
+							value: value ?? ""
+						};
+					}));
+				}
+				const settlements = await all(settledPromises);
+				for (let i = 0; i < starts.length; i++) {
+					const start = starts[i];
+					const settlement = settlements[i];
+					if (settlement.ok) {
+						const result = await completeDurableToolExecution(childCtx, start, settlement.value);
+						results.set(start.index, result);
+						const isUserCancel = typeof result.content === "string" && result.content === "[Tool call cancelled by user]";
+						if (result.isError && !isUserCancel && start.call.name === SHELL_TOOL_NAME && !siblingAbort.signal.aborted) siblingAbort.abort(SHELL_CASCADE_REASON);
+					} else {
+						const result = await failDurableToolExecution(childCtx, start, errorFromSerializedFailure(settlement.error), cancelMessage);
+						results.set(start.index, result);
+					}
+				}
+			}
+			return indices.map((index) => results.get(index) ?? {
+				id: toolCalls[index].id,
+				content: "Error: durable tool execution did not produce a result",
+				isError: true
+			});
+		} finally {
+			for (const start of starts) childCtx.pendingToolCancels?.delete(start.callId);
+		}
+	};
+	const executionCtx = {
+		toolCalls,
+		turnId,
+		maxConcurrentTools: maxConcurrent,
+		signal: ctx.signal,
+		steeringQueue: ctx.steeringQueue,
+		isConcurrencySafe: (index) => safe[index] === true,
+		execute,
+		canExecuteDurably: (index) => typeof ctx.tools[toolCalls[index].name]?.durableExecute === "function",
+		executeDurable,
+		interruptedResult: (index) => ({
+			id: toolCalls[index].id,
+			content: INTERRUPT_MESSAGE_FOR_TOOL_USE,
+			isError: true
+		}),
+		skippedResult: (index) => ({
+			id: toolCalls[index].id,
+			content: TOOL_USE_SKIPPED_MESSAGE,
+			isError: true
+		})
+	};
+	try {
+		return await executor(executionCtx);
+	} finally {
+		if (parentAbortListener) ctx.signal.removeEventListener("abort", parentAbortListener);
+	}
+}
+async function startDurableToolExecution(ctx, call, turnId, index) {
+	const toolDef = ctx.tools[call.name];
+	const durableExecute = toolDef?.durableExecute;
+	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);
+	const cleanupResult = (result) => {
+		ctx.pendingToolCancels?.delete(callId);
+		return {
+			kind: "result",
+			result
+		};
+	};
+	const gateCtx = {
+		...buildToolHookBase(ctx, turnId, callId, call.name, displayName, call.input),
+		block: false,
+		reason: "Tool execution was blocked",
+		runToolCounts
+	};
+	await ctx.hooks.callHook("tool:gate", gateCtx);
+	if (gateCtx.block) {
+		await fireDispatched(ctx, {
+			turnId,
+			callId,
+			name: call.name,
+			displayName,
+			input: gateCtx.input,
+			outcome: "gate-block",
+			reason: gateCtx.reason,
+			runToolCounts
+		});
+		return cleanupResult({
+			id: callId,
+			content: `Blocked: ${gateCtx.reason}`,
+			isError: true
+		});
+	}
+	ctx.runToolCounts[call.name] = (ctx.runToolCounts[call.name] ?? 0) + 1;
+	if (gateCtx.result !== void 0) {
+		await fireDispatched(ctx, {
+			turnId,
+			callId,
+			name: call.name,
+			displayName,
+			input: gateCtx.input,
+			outcome: "gate-substitute",
+			runToolCounts
+		});
+		const emitted = await emitToolResult(ctx, {
+			turnId,
+			callId,
+			name: call.name,
+			displayName,
+			input: gateCtx.input,
+			output: gateCtx.result,
+			isError: false,
+			runToolCounts
+		});
+		return cleanupResult({
+			id: callId,
+			content: emitted.output,
+			...emitted.isError ? { isError: true } : {}
+		});
+	}
+	let effectiveInput = gateCtx.input;
+	if (!toolDef || !durableExecute) return cleanupResult({
+		id: callId,
+		content: `Tool error: ${toolDef ? "Tool is not durable-execution capable" : `Unknown tool: ${call.name}`}`,
+		isError: true
+	});
+	const validation = validateToolArgs(effectiveInput, toolDef.spec.inputSchema);
+	if (!validation.valid) {
+		await ctx.hooks.callHook("validation:reject", {
+			...buildToolHookBase(ctx, turnId, callId, call.name, displayName, effectiveInput),
+			reason: validation.error ?? "invalid input",
+			schema: toolDef.spec.inputSchema
+		});
+		await fireDispatched(ctx, {
+			turnId,
+			callId,
+			name: call.name,
+			displayName,
+			input: effectiveInput,
+			outcome: "invalid-input",
+			runToolCounts
+		});
+		return cleanupResult({
+			id: callId,
+			content: `Validation error: ${validation.error}`,
+			isError: true
+		});
+	}
+	effectiveInput = validation.coercedInput ?? effectiveInput;
+	const coercions = validation.coercions && validation.coercions.length > 0 ? validation.coercions : void 0;
+	if (coercions) await ctx.hooks.callHook("validation:coerce", {
+		...buildToolHookBase(ctx, turnId, callId, call.name, displayName, effectiveInput),
+		coercions,
+		schema: toolDef.spec.inputSchema
+	});
+	await fireDispatched(ctx, {
+		turnId,
+		callId,
+		name: call.name,
+		displayName,
+		input: effectiveInput,
+		outcome: "execute",
+		runToolCounts
+	});
+	await ctx.hooks.callHook("tool:before", {
+		...buildToolHookBase(ctx, turnId, callId, call.name, displayName, effectiveInput),
+		runToolCounts,
+		...coercions ? { coercions } : {}
+	});
+	const childSignal = typeof AbortSignal.any === "function" ? AbortSignal.any([ctx.signal, perCallAbort.signal]) : ctx.signal;
+	let reportedOutcome;
+	const toolCtx = {
+		provider: ctx.provider,
+		signal: childSignal,
+		execution: ctx.execution,
+		handle: ctx.handle,
+		hooks: ctx.hooks,
+		tools: ctx.agentTools,
+		...ctx.agentName !== void 0 ? { name: ctx.agentName } : {},
+		...ctx.agentSystem !== void 0 ? { system: ctx.agentSystem } : {},
+		...ctx.agentToolAliases !== void 0 ? { toolAliases: ctx.agentToolAliases } : {},
+		...ctx.agentMcpServers !== void 0 ? { mcpServers: ctx.agentMcpServers } : {},
+		...ctx.agentSkills !== void 0 ? { skills: ctx.agentSkills } : {},
+		...ctx.agentBehavior !== void 0 ? { behavior: ctx.agentBehavior } : {},
+		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 } : {},
+		clock: ctx.clock,
+		reportOutcome: (outcome) => {
+			reportedOutcome = outcome;
+		}
+	};
+	return {
+		kind: "start",
+		start: {
+			index,
+			call,
+			turnId,
+			callId,
+			name: call.name,
+			displayName,
+			input: effectiveInput,
+			runToolCounts,
+			perCallAbort,
+			...coercions ? { coercions } : {},
+			promise: durableExecute(effectiveInput, toolCtx),
+			reportedOutcome: () => reportedOutcome
+		}
+	};
+}
+async function completeDurableToolExecution(ctx, start, output) {
+	const reportedOutcome = start.reportedOutcome();
+	const emitted = await emitToolResult(ctx, {
+		turnId: start.turnId,
+		callId: start.callId,
+		name: start.name,
+		displayName: start.displayName,
+		input: start.input,
+		output,
+		isError: false,
+		runToolCounts: start.runToolCounts,
+		...start.coercions ? { coercions: start.coercions } : {},
+		...reportedOutcome ? { outcome: reportedOutcome } : {}
+	});
+	return {
+		id: start.callId,
+		content: emitted.output,
+		...emitted.isError ? { isError: true } : {}
+	};
+}
+async function failDurableToolExecution(ctx, start, err, cancelMessage) {
+	if (ctx.shouldRethrowToolError?.(err)) throw err;
+	const isAbortError = err instanceof Error && err.name === "AbortError";
+	if (isAbortError && start.perCallAbort.signal.aborted) {
+		const reason = typeof start.perCallAbort.signal.reason === "string" ? start.perCallAbort.signal.reason : "cancelled-by-user";
+		await ctx.hooks.callHook("tool:cancelled", {
+			...buildToolHookBase(ctx, start.turnId, start.callId, start.name, start.displayName, start.input),
+			reason,
+			runToolCounts: start.runToolCounts
+		});
+		return {
+			id: start.callId,
+			content: TOOL_USE_CANCELLED_MESSAGE,
+			isError: true
+		};
+	}
+	if (ctx.signal.aborted || isAbortError) return {
+		id: start.callId,
+		content: cancelMessage(),
+		isError: true
+	};
+	const error = err instanceof Error ? err : new Error(String(err));
+	const errorCtx = {
+		...buildToolHookBase(ctx, start.turnId, start.callId, start.name, start.displayName, start.input),
+		error
+	};
+	await ctx.hooks.callHook("tool:error", errorCtx);
+	const emitted = await emitToolResult(ctx, {
+		turnId: start.turnId,
+		callId: start.callId,
+		name: start.name,
+		displayName: start.displayName,
+		input: start.input,
+		output: errorCtx.result ?? `Tool error: ${error.message}`,
+		isError: true,
+		runToolCounts: start.runToolCounts,
+		...start.coercions ? { coercions: start.coercions } : {}
+	});
+	return {
+		id: start.callId,
+		content: emitted.output,
+		...emitted.isError ? { isError: true } : {}
+	};
+}
+function serializeToolFailure(failure) {
+	if (failure instanceof Error) {
+		const codeValue = Reflect.get(failure, "code");
+		const code = typeof codeValue === "number" ? codeValue : void 0;
+		return {
+			name: failure.name,
+			message: failure.message,
+			...code !== void 0 ? { code } : {},
+			constructorName: failure.constructor?.name
+		};
+	}
+	return {
+		name: "Error",
+		message: String(failure)
+	};
+}
+function hasDurableMap(promise) {
+	return typeof Reflect.get(promise, "map") === "function";
+}
+function errorFromSerializedFailure(failure) {
+	const error = new Error(failure.message);
+	error.name = failure.name;
+	if (failure.code !== void 0) Object.defineProperty(error, "code", {
+		value: failure.code,
+		enumerable: true
+	});
+	if (failure.constructorName && failure.constructorName !== failure.name) Object.defineProperty(error, "constructorName", {
+		value: failure.constructorName,
+		enumerable: true
+	});
+	return error;
+}
+async function executeNativeToolBatch(ctx, toolCalls, turnId) {
 	if (toolCalls.length === 0) return [];
 	const N = toolCalls.length;
 	const maxConcurrent = Math.max(1, ctx.maxConcurrentTools ?? DEFAULT_MAX_CONCURRENT_TOOLS);
@@ -3530,6 +3906,7 @@ async function executeToolBatch(ctx, toolCalls, turnId) {
 			const isUserCancel = typeof result.content === "string" && result.content === "[Tool call cancelled by user]";
 			if (result.isError && !isUserCancel && call.name === SHELL_TOOL_NAME && !siblingAbort.signal.aborted) siblingAbort.abort(SHELL_CASCADE_REASON);
 		}, (err) => {
+			if (ctx.shouldRethrowToolError?.(err)) throw err;
 			const isAbort = siblingAbort.signal.aborted || ctx.signal.aborted || err instanceof Error && err.name === "AbortError";
 			results[index] = {
 				id: call.id,
@@ -5104,6 +5481,8 @@ async function synthesizeMissingToolResults(turns, syntheticTurnId, runId, provi
 function resolveBehavior(agentBehavior, runBehavior) {
 	return {
 		maxConcurrentTools: runBehavior?.maxConcurrentTools ?? agentBehavior?.maxConcurrentTools,
+		toolBatchExecutor: runBehavior?.toolBatchExecutor ?? agentBehavior?.toolBatchExecutor,
+		shouldRethrowToolError: runBehavior?.shouldRethrowToolError ?? agentBehavior?.shouldRethrowToolError,
 		maxTurns: runBehavior?.maxTurns ?? agentBehavior?.maxTurns,
 		maxCostUsd: runBehavior?.maxCostUsd ?? agentBehavior?.maxCostUsd,
 		retry: runBehavior?.retry ?? agentBehavior?.retry,
@@ -5437,11 +5816,15 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 			abortController = new AbortController();
 			syncRunCounter();
 			const runId = `run_${++runCounter}`;
+			const runStartedAt = await clock.now();
+			const mintTurnId = async () => session ? await session.generateTurnId() : clock.randomUUID();
 			const promptLabel = typeof options.prompt === "string" ? options.prompt : Array.isArray(options.prompt) ? options.prompt.filter((p) => p.type === "text").map((p) => p.text).join("\n") : "";
 			session?.startRun(runId, promptLabel, {
 				...options.parentRunId ? { parentRunId: options.parentRunId } : {},
 				depth: typeof options.depth === "number" ? options.depth : 0
 			});
+			const sessionRun = session?.runs.find((r) => r.id === runId);
+			if (sessionRun) sessionRun.startedAt = runStartedAt;
 			if (session) {
 				await session.updateStatus("running");
 				await hooks.callHook("session:start", {
@@ -5450,7 +5833,6 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 					prompt: promptLabel
 				});
 			}
-			const runStartedAt = await clock.now();
 			await hooks.callHook("agent:start", {
 				runId,
 				...options.parentRunId ? { parentRunId: options.parentRunId } : {},
@@ -5511,7 +5893,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 			const thinking = options.thinking ?? "off";
 			const model = options.model ?? provider.meta.defaultModel;
 			const resolvedBehavior = resolveBehavior(agentBehavior, options.behavior);
-			const { maxConcurrentTools, maxTurns, maxCostUsd, maxTotalTokens, maxTokens, retry, thinkingBudget, modelOptions: behaviorModelOptions, schema, cache, toolOutputBudget, toolOutputBudgetExcludeTools, compactStrategy, compactThreshold, compactKeepTurns, thinkingDecay, dedupTools, toolBudgets, repeatGuard, elideStaleReads, toolDisclosure, toolSearch, surfaceMcpInstructions, persistThreshold, persistExcludeTools, persistDir, persistMaxBytes, strictToolPairing, maxConsecutivePauseTurns, persistTurns } = resolvedBehavior;
+			const { maxConcurrentTools, toolBatchExecutor, shouldRethrowToolError, maxTurns, maxCostUsd, maxTotalTokens, maxTokens, retry, thinkingBudget, modelOptions: behaviorModelOptions, schema, cache, toolOutputBudget, toolOutputBudgetExcludeTools, compactStrategy, compactThreshold, compactKeepTurns, thinkingDecay, dedupTools, toolBudgets, repeatGuard, elideStaleReads, toolDisclosure, toolSearch, surfaceMcpInstructions, persistThreshold, persistExcludeTools, persistDir, persistMaxBytes, strictToolPairing, maxConsecutivePauseTurns, persistTurns } = resolvedBehavior;
 			const modelOptions = options.modelOptions ?? behaviorModelOptions;
 			let system = options.system || agentSystem || "You are a helpful assistant.";
 			const baseSystemForBreakdown = renderSystemForWire(system);
@@ -5683,7 +6065,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 				const promptMsg = promptParts ? buildPromptMessage(provider, promptParts) : null;
 				const content = [...drainedNotifications, ...promptMsg ? promptMsg.content : []];
 				turns.push({
-					id: clock.randomUUID(),
+					id: await mintTurnId(),
 					runId,
 					role: promptMsg ? promptMsg.role : "user",
 					content,
@@ -5718,7 +6100,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 			const unregisterToolResultsSync = perTurnSync ? hooks.hook("tool-results:after", persistPendingTurns) : void 0;
 			async function flushTurns(opts = {}) {
 				if (!session) return;
-				if (opts.failureFallback) await synthesizeMissingToolResults(turns, await session.generateTurnId?.() ?? clock.randomUUID(), runId, provider, hooks, clock);
+				if (opts.failureFallback) await synthesizeMissingToolResults(turns, await mintTurnId(), runId, provider, hooks, clock);
 				const remaining = turns.slice(lastPersistedTurnCount);
 				if (remaining.length > 0) {
 					await session.appendTurns(remaining);
@@ -5748,12 +6130,16 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 					turnRange: [runTurnStart, turns.length - 1]
 				});
 			}
+			async function stampSessionRunEnd() {
+				const run = session?.runs.find((r) => r.id === runId);
+				if (run) run.endedAt = await clock.now();
+			}
 			const uninstallAllowedToolsGate = installAllowedToolsGate(hooks, skillActivationState);
 			const uninstallToolBudgets = installToolBudgetsGate(hooks, () => toolBudgets, (msg) => steeringQueue.push(msg));
 			const uninstallRepeatGuard = installRepeatGuard(hooks, () => repeatGuard, () => abortController?.abort());
 			const uninstallDedupTools = installDedupToolsGate(hooks, () => dedupTools, () => session ?? void 0);
 			const uninstallLazyDisclosureGate = installLazyDisclosureGate(hooks, disclosure.lazyCanonicalNames, unlocked, discoveryToolName);
-			const runStartMs = await clock.now();
+			const runStartMs = runStartedAt;
 			const runDepth = typeof options.depth === "number" ? options.depth : 0;
 			try {
 				const stats = await runLoop({
@@ -5774,6 +6160,8 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 					system,
 					thinking,
 					...maxConcurrentTools !== void 0 ? { maxConcurrentTools } : {},
+					...toolBatchExecutor !== void 0 ? { toolBatchExecutor } : {},
+					...shouldRethrowToolError !== void 0 ? { shouldRethrowToolError } : {},
 					signal: abortController.signal,
 					execution: executionContext,
 					handle: executionHandle,
@@ -5781,7 +6169,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 					followUpQueue,
 					turns,
 					runId,
-					generateTurnId: () => session?.generateTurnId() ?? clock.randomUUID(),
+					generateTurnId: mintTurnId,
 					clock,
 					maxTurns,
 					...maxCostUsd !== void 0 ? { maxCostUsd } : {},
@@ -5846,6 +6234,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 						turnUsage: stats.turnUsage,
 						cost: parentTurnCost > 0 ? parentTurnCost : void 0
 					});
+					await stampSessionRunEnd();
 					await finalizeSession("aborted");
 					await hooks.callHook("agent:done", finalStats);
 					return finalStats;
@@ -5857,6 +6246,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 					turnUsage: stats.turnUsage,
 					cost: parentTurnCost > 0 ? parentTurnCost : void 0
 				});
+				await stampSessionRunEnd();
 				await finalizeSession("completed");
 				await hooks.callHook("agent:done", finalStats);
 				return finalStats;
@@ -5869,6 +6259,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 						...typeof abortReason === "string" && abortReason.length > 0 ? { reason: abortReason } : {}
 					});
 					session?.abortRun(runId);
+					await stampSessionRunEnd();
 					await finalizeSession("aborted");
 					const stats = {
 						totalIn: 0,
@@ -5883,6 +6274,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 				}
 				if (err instanceof AgentBudgetExceededError) {
 					session?.abortRun(runId);
+					await stampSessionRunEnd();
 					await finalizeSession("aborted");
 					await hooks.callHook("agent:done", {
 						totalIn: 0,
@@ -5895,6 +6287,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 					throw err;
 				}
 				session?.errorRun(runId, errorMessage(err));
+				await stampSessionRunEnd();
 				await finalizeSession("error");
 				throw err;
 			} finally {
@@ -7752,4 +8145,4 @@ const writeFile$1 = {
 //#endregion
 export { resolveTasksDir as A, effectiveContextWindow as B, PERSISTED_STUB_PREFIX as C, maybePersistToolResult as D, cleanupPersistedSession as E, BUILTIN_PROVIDERS as F, modelOptionsFor as G, getContextWindow as H, OUTPUT_RESERVE_TOKENS as I, openaiDescriptor as J, modelSupportsReasoning as K, anthropicDescriptor as L, hashContent as M, readStateKey as N, resolveMcpWarningsDir as O, resolveReadStateMap as P, cerebrasDescriptor as R, validateToolArgs as S, buildPersistedStub as T, getModelInfo as U, enabledModelOptions as V, localDescriptor as W, piIdOf as X, openrouterDescriptor as Y, restoreModelOptions as Z, shell as _, multiEdit as a, TOOL_USE_CANCELLED_MESSAGE as b, grep as c, createAgent as d, createToolSearchTool as f, createShellTool as g, createSkillsReadTool as h, readFile$1 as i, getReadState as j, resolvePersistDir as k, glob$1 as l, createSkillsRunScriptTool as m, createSpawnTool as n, listFiles as o, createSkillsUseTool as p, modelsForDescriptor as q, shellKill 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, credKeyOf as z };
 
-//# sourceMappingURL=tools-DOUtulS5.js.map
+//# sourceMappingURL=tools-CAdllmWO.js.map