zidane 5.3.0 → 5.3.1

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

@@ -1,9 +1,9 @@
 import { n as createProcessContext } from "./contexts-BwiHIr2w.js";
-import { c as toTypedError, o as errorMessage, r as AgentProviderError, t as AgentAbortedError } from "./errors-COmsomd5.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 { i as sanitizeOrphanedToolCalls } from "./messages-DsbMYNmt.js";
-import { t as connectMcpServers } from "./mcp-B1psg7jf.js";
-import { _ as validateResourcePath, b as createSkillActivationState, d as escapeXml, n as resolveSkills, p as installAllowedToolsGate, t as interpolateShellCommands, u as buildCatalog } from "./interpolate-BhmHKD6x.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 { _ 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";
 import { mkdir, rename, rm, stat, writeFile } from "node:fs/promises";
@@ -480,6 +480,7 @@ function validateToolArgs(input, schema) {
 	};
 	let coerced;
 	const coercions = [];
+	let droppedItems;
 	for (const [key, value] of Object.entries(input)) {
 		const propSchema = properties[key];
 		if (!propSchema?.type) continue;
@@ -494,11 +495,138 @@ function validateToolArgs(input, schema) {
 			coerced[key] = outcome.value;
 			coercions.push(key);
 		}
+		const arrayValue = outcome.changed ? outcome.value : value;
+		if (propSchema.type === "array" && propSchema.items && Array.isArray(arrayValue)) {
+			const itemOutcome = validateArrayItems(arrayValue, propSchema);
+			if (itemOutcome.error) return {
+				valid: false,
+				error: `Field "${key}": ${itemOutcome.error}`
+			};
+			if (itemOutcome.changed || itemOutcome.dropped.length > 0 || itemOutcome.truncated) {
+				if (!coerced) coerced = { ...input };
+				coerced[key] = itemOutcome.items;
+				if (!coercions.includes(key)) coercions.push(key);
+			}
+			if (itemOutcome.dropped.length > 0) {
+				if (!droppedItems) droppedItems = {};
+				droppedItems[key] = itemOutcome.dropped;
+			}
+		}
 	}
 	return {
 		valid: true,
 		coercedInput: coerced ?? input,
-		coercions
+		coercions,
+		...droppedItems ? { droppedItems } : {}
+	};
+}
+function validateArrayItems(items, schema) {
+	if (schema.minItems !== void 0 && items.length < schema.minItems) return {
+		items,
+		changed: false,
+		truncated: false,
+		dropped: [],
+		error: `expected at least ${schema.minItems} item${schema.minItems === 1 ? "" : "s"}, got ${items.length}`
+	};
+	const itemSchema = schema.items;
+	if (!itemSchema) return {
+		items,
+		changed: false,
+		truncated: false,
+		dropped: []
+	};
+	const out = [];
+	const outOriginalIdx = [];
+	const dropped = [];
+	let changed = false;
+	for (let i = 0; i < items.length; i++) {
+		const item = items[i];
+		const v = validateOneItem(item, itemSchema);
+		if (v.dropped) {
+			dropped.push(i);
+			changed = true;
+			continue;
+		}
+		if (v.changed) changed = true;
+		out.push(v.value);
+		outOriginalIdx.push(i);
+	}
+	let truncated = false;
+	if (schema.maxItems !== void 0 && out.length > schema.maxItems) {
+		for (let i = schema.maxItems; i < out.length; i++) dropped.push(outOriginalIdx[i]);
+		out.length = schema.maxItems;
+		truncated = true;
+		changed = true;
+	}
+	dropped.sort((a, b) => a - b);
+	return {
+		items: out,
+		changed,
+		truncated,
+		dropped
+	};
+}
+function validateOneItem(item, schema) {
+	if (schema.type === "object") {
+		if (!item || typeof item !== "object" || Array.isArray(item)) return {
+			value: item,
+			changed: false,
+			dropped: true
+		};
+		const obj = item;
+		const required = schema.required ?? [];
+		for (const field of required) {
+			const v = obj[field];
+			if (v === void 0 || v === null) return {
+				value: item,
+				changed: false,
+				dropped: true
+			};
+		}
+		const properties = schema.properties ?? {};
+		let coercedItem;
+		for (const [key, value] of Object.entries(obj)) {
+			const subSchema = properties[key];
+			if (!subSchema?.type) continue;
+			if (value === void 0 || value === null) continue;
+			const outcome = coerceValue(value, subSchema);
+			if (outcome.error) return {
+				value: item,
+				changed: false,
+				dropped: true
+			};
+			if (outcome.changed) {
+				if (!coercedItem) coercedItem = { ...obj };
+				coercedItem[key] = outcome.value;
+			}
+		}
+		return coercedItem ? {
+			value: coercedItem,
+			changed: true,
+			dropped: false
+		} : {
+			value: item,
+			changed: false,
+			dropped: false
+		};
+	}
+	if (schema.type) {
+		const outcome = coerceValue(item, schema);
+		if (outcome.error) return {
+			value: item,
+			changed: false,
+			dropped: true
+		};
+		return {
+			value: outcome.value,
+			changed: outcome.changed,
+			dropped: false
+		};
+	}
+	return {
+		value: item,
+		changed: false,
+		dropped: false
 	};
 }
 function coerceValue(value, schema) {
@@ -628,6 +756,30 @@ function formatValue(value) {
 //#region src/loop.ts
 const IMAGE_OMITTED_MARKER = "[image omitted — model does not support vision]";
 /**
+* Canonical tool_result text emitted when a tool call is interrupted by the
+* user mid-flight (Esc / Ctrl-C / external `AbortSignal`). Mirrors Claude
+* Code's `INTERRUPT_MESSAGE_FOR_TOOL_USE` so downstream consumers can pattern
+* match a single string across both harnesses. Always paired with
+* `isError: true` on the wire — the model treats it as a failed call rather
+* than a successful tool response.
+*/
+const INTERRUPT_MESSAGE_FOR_TOOL_USE = "[Request interrupted by user for tool use]";
+/**
+* Canonical tool_result text emitted when a tool call is skipped because a
+* sibling sequential call errored or a steering message arrived between
+* iterations of {@link executeToolsSequential}. Distinguished from
+* {@link INTERRUPT_MESSAGE_FOR_TOOL_USE} so consumers can distinguish "user
+* cancelled" from "framework superseded".
+*/
+const TOOL_USE_SKIPPED_MESSAGE = "[Tool use skipped — superseded by user message]";
+/**
+* Canonical tool_result text emitted when the loop catches a sequential
+* sibling that threw and synthesizes follow-up results for the remaining
+* queued calls. Distinct from {@link TOOL_USE_SKIPPED_MESSAGE} so telemetry
+* can split "skipped by user steering" from "skipped after error".
+*/
+const TOOL_USE_AFTER_ERROR_MESSAGE = "[Tool use skipped — previous tool call in batch threw]";
+/**
 * 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.
@@ -929,6 +1081,32 @@ function invalidateReadStateForElidedPaths(session, elidedPaths) {
 	const suffixes = elidedPaths.map((p) => `::${p}`);
 	for (const key of [...readState.keys()]) if (suffixes.some((s) => key.endsWith(s))) readState.delete(key);
 }
+/**
+* Run {@link ensureToolResultPairing} with the loop's hook + strict-mode
+* context plugged in. Centralized so the pre-send path and the schema-
+* enforcement path share identical telemetry + throw semantics.
+*
+* The captured `repairs` array is what `AgentToolPairingError` carries on
+* strict-mode throws, and it's what `pairing:repair` fires from. Hook
+* notifications run AFTER the pass completes so they don't interfere with
+* the synchronous walk — and we drop them on the floor in strict mode (the
+* throw is more informative than a fire-and-forget log).
+*/
+function applyPairingRepair(ctx, messages, turnId) {
+	const repairs = [];
+	const repaired = ensureToolResultPairing(messages, { onRepair: (repair) => repairs.push(repair) });
+	if (repairs.length === 0) return repaired;
+	if (ctx.strictToolPairing) throw new AgentToolPairingError({
+		message: `Tool pairing corruption detected (${repairs.length} repair${repairs.length === 1 ? "" : "s"}); strict mode is on so the request was not sent.`,
+		...ctx.providerName ? { provider: ctx.providerName } : {},
+		repairs
+	});
+	for (const repair of repairs) ctx.hooks.callHook("pairing:repair", {
+		...repair,
+		turnId
+	});
+	return repaired;
+}
 function sanitizeStoredToolResults(provider, messages) {
 	if (provider.meta.capabilities?.vision !== false) return messages;
 	return messages.map((msg) => {
@@ -1060,6 +1238,27 @@ function wrapProviderError(err, ctx) {
 		cause: err
 	});
 }
+/** Max bytes of provider error text inlined into the assistant turn placeholder. */
+const ERROR_PLACEHOLDER_MAX = 280;
+/**
+* Build the assistant-turn placeholder text when the provider throws before
+* streaming any output. Inlines the underlying error message (truncated and
+* stripped of stack-like newlines) so the persisted turn carries a useful
+* diagnostic — the human reading the transcript sees the failure mode
+* without having to attach a debugger, and `tool_search` schema rejections
+* become self-explanatory.
+*
+* The bracketed `[✗ Streaming failed: ...]` shape preserves the prior
+* format that hosts may pattern-match on while adding the new payload
+* suffix. Falls back to the original generic placeholder when no message
+* can be extracted.
+*/
+function buildStreamErrorPlaceholder(err) {
+	const raw = errorMessage(err).trim();
+	if (raw.length === 0) return "[✗ Streaming failed before any output.]";
+	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) {
 	const turnId = await ctx.generateTurnId();
 	let canonicalMessages = turnsToMessages(applyCompactSummaryCutoff(ctx.turns));
@@ -1091,7 +1290,7 @@ async function executeTurn(ctx, turn) {
 	const transformCtx = { messages: streamOptions.messages };
 	await ctx.hooks.callHook("context:transform", transformCtx);
 	streamOptions.messages = transformCtx.messages;
-	streamOptions.messages = sanitizeOrphanedToolCalls(streamOptions.messages);
+	streamOptions.messages = applyPairingRepair(ctx, streamOptions.messages, turnId);
 	const systemCtx = {
 		system: streamOptions.system,
 		messages: streamOptions.messages,
@@ -1137,12 +1336,13 @@ async function executeTurn(ctx, turn) {
 			input: 0,
 			output: 0
 		};
+		const placeholderText = wasAborted ? "[⏹ Streaming was aborted.]" : buildStreamErrorPlaceholder(err);
 		const errorContent = currentText ? [{
 			type: "text",
 			text: currentText
 		}] : [{
 			type: "text",
-			text: wasAborted ? "[⏹ Streaming was aborted.]" : "[✗ Streaming failed before any output.]"
+			text: placeholderText
 		}];
 		const errorTurn = {
 			id: turnId,
@@ -1153,6 +1353,10 @@ async function executeTurn(ctx, turn) {
 			createdAt: Date.now()
 		};
 		ctx.turns.push(errorTurn);
+		if (!wasAborted) await ctx.hooks.callHook("stream:error", {
+			err,
+			turnId
+		});
 		await ctx.hooks.callHook("turn:after", {
 			turn,
 			turnId,
@@ -1205,7 +1409,7 @@ async function executeTurn(ctx, turn) {
 				description: "Return the final structured output matching the required schema.",
 				inputSchema: ctx.schema
 			};
-			const schemaMessages = sanitizeOrphanedToolCalls(rewriteMessagesToWire(turnsToMessages(applyCompactSummaryCutoff(ctx.turns)), ctx.aliasMaps));
+			const schemaMessages = applyPairingRepair(ctx, rewriteMessagesToWire(turnsToMessages(applyCompactSummaryCutoff(ctx.turns)), ctx.aliasMaps), turnId);
 			let schemaResult;
 			try {
 				schemaResult = await ctx.provider.stream({
@@ -1351,14 +1555,35 @@ async function executeSingleTool(ctx, call, turnId) {
 		runToolCounts
 	};
 	await ctx.hooks.callHook("tool:gate", gateCtx);
-	if (gateCtx.block) return { result: {
-		id: callId,
-		content: `Blocked: ${gateCtx.reason}`
-	} };
+	if (gateCtx.block) {
+		await fireDispatched(ctx, {
+			turnId,
+			callId,
+			name: call.name,
+			displayName,
+			input: gateCtx.input,
+			outcome: "gate-block",
+			reason: gateCtx.reason,
+			runToolCounts
+		});
+		return { result: {
+			id: callId,
+			content: `Blocked: ${gateCtx.reason}`,
+			isError: true
+		} };
+	}
 	ctx.runToolCounts[call.name] = (ctx.runToolCounts[call.name] ?? 0) + 1;
-	if (gateCtx.result !== void 0) return { result: {
-		id: callId,
-		content: await emitToolResult(ctx, {
+	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,
@@ -1367,8 +1592,13 @@ async function executeSingleTool(ctx, call, turnId) {
 			output: gateCtx.result,
 			isError: false,
 			runToolCounts
-		})
-	} };
+		});
+		return { result: {
+			id: callId,
+			content: emitted.output,
+			...emitted.isError ? { isError: true } : {}
+		} };
+	}
 	let effectiveInput = gateCtx.input;
 	if (!toolDef) {
 		const unknownCtx = {
@@ -1381,6 +1611,7 @@ async function executeSingleTool(ctx, call, turnId) {
 		};
 		await ctx.hooks.callHook("tool:unknown", unknownCtx);
 		const content = unknownCtx.result ?? `Tool error: Unknown tool: ${call.name}`;
+		const isError = unknownCtx.result === void 0;
 		if (!unknownCtx.suppressError) {
 			const err = /* @__PURE__ */ new Error(`Unknown tool: ${call.name}`);
 			await ctx.hooks.callHook("tool:error", {
@@ -1392,9 +1623,19 @@ async function executeSingleTool(ctx, call, turnId) {
 				error: err
 			});
 		}
+		await fireDispatched(ctx, {
+			turnId,
+			callId,
+			name: call.name,
+			displayName,
+			input: effectiveInput,
+			outcome: "unknown",
+			runToolCounts
+		});
 		return { result: {
 			id: callId,
-			content
+			content,
+			...isError ? { isError: true } : {}
 		} };
 	}
 	const validation = validateToolArgs(effectiveInput, toolDef.spec.inputSchema);
@@ -1408,9 +1649,19 @@ async function executeSingleTool(ctx, call, turnId) {
 			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 { result: {
 			id: callId,
-			content: `Validation error: ${validation.error}`
+			content: `Validation error: ${validation.error}`,
+			isError: true
 		} };
 	}
 	effectiveInput = validation.coercedInput ?? effectiveInput;
@@ -1424,6 +1675,15 @@ async function executeSingleTool(ctx, call, turnId) {
 		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", {
 		turnId,
 		callId,
@@ -1470,26 +1730,54 @@ async function executeSingleTool(ctx, call, turnId) {
 		output = errorCtx.result ?? `Tool error: ${error.message}`;
 		isError = true;
 	}
+	const emitted = await emitToolResult(ctx, {
+		turnId,
+		callId,
+		name: call.name,
+		displayName,
+		input: effectiveInput,
+		output,
+		isError,
+		runToolCounts,
+		...coercions ? { coercions } : {}
+	});
 	return { result: {
 		id: callId,
-		content: await emitToolResult(ctx, {
-			turnId,
-			callId,
-			name: call.name,
-			displayName,
-			input: effectiveInput,
-			output,
-			isError,
-			runToolCounts,
-			...coercions ? { coercions } : {}
-		})
+		content: emitted.output,
+		...emitted.isError ? { isError: true } : {}
 	} };
 }
 /**
+* Fire `tool:dispatched` with the resolved path discriminator. Every code
+* path in {@link executeSingleTool} that produces a tool_result must call
+* this exactly once — that contract is what makes `tool:dispatched` ↔
+* `tool:after` a guaranteed symmetric pairing for live-event consumers
+* (the chat layer, SDK consumers reconstructing wire history from events,
+* tracing spans that want to record refused calls separately from
+* executed ones).
+*
+* Helper exists to centralize the optional-field plumbing for `reason`
+* (only set on `gate-block`) without sprinkling spread-conditional logic
+* across five call sites.
+*/
+async function fireDispatched(ctx, params) {
+	const { reason, ...rest } = params;
+	await ctx.hooks.callHook("tool:dispatched", {
+		...rest,
+		...reason !== void 0 ? { reason } : {}
+	});
+}
+/**
 * Shared post-output emission: fire `tool:transform` (mutate-allowed), strip
 * images for non-vision providers, fire `tool:after`. Used by both the
 * gate-substitute (Z20) and post-execute paths so they stay byte-for-byte
 * identical from the consumer's perspective.
+*
+* Returns both the (possibly transformed) output and the final `isError`
+* flag — `tool:transform` listeners can flip the flag in either direction
+* (e.g. rewrite a structured error response to a graceful retry hint), and
+* the caller needs the post-transform value to populate `ToolResult.isError`
+* on the wire.
 */
 async function emitToolResult(ctx, params) {
 	const { turnId, callId, name, displayName, input, runToolCounts, coercions } = params;
@@ -1535,7 +1823,10 @@ async function emitToolResult(ctx, params) {
 		runToolCounts,
 		...coercions ? { coercions } : {}
 	});
-	return output;
+	return {
+		output,
+		isError
+	};
 }
 async function executeToolsSequential(ctx, toolCalls, turnId) {
 	const results = [];
@@ -1544,14 +1835,16 @@ async function executeToolsSequential(ctx, toolCalls, turnId) {
 		if (ctx.signal.aborted) {
 			for (let j = i; j < toolCalls.length; j++) results.push({
 				id: toolCalls[j].id,
-				content: "Aborted: run was cancelled"
+				content: INTERRUPT_MESSAGE_FOR_TOOL_USE,
+				isError: true
 			});
 			return results;
 		}
 		if (ctx.steeringQueue.length > 0) {
 			for (let j = i; j < toolCalls.length; j++) results.push({
 				id: toolCalls[j].id,
-				content: "Skipped: steering message received"
+				content: TOOL_USE_SKIPPED_MESSAGE,
+				isError: true
 			});
 			return results;
 		}
@@ -1561,11 +1854,13 @@ async function executeToolsSequential(ctx, toolCalls, turnId) {
 		} catch (err) {
 			results.push({
 				id: call.id,
-				content: `Error: ${errorMessage(err)}`
+				content: `Error: ${errorMessage(err)}`,
+				isError: true
 			});
 			for (let j = i + 1; j < toolCalls.length; j++) results.push({
 				id: toolCalls[j].id,
-				content: "Skipped: previous tool call threw"
+				content: TOOL_USE_AFTER_ERROR_MESSAGE,
+				isError: true
 			});
 			return results;
 		}
@@ -1576,9 +1871,12 @@ async function executeToolsParallel(ctx, toolCalls, turnId) {
 	const executions = toolCalls.map((call) => executeSingleTool(ctx, call, turnId));
 	return (await Promise.allSettled(executions)).map((s, i) => {
 		if (s.status === "fulfilled") return s.value.result;
+		const reason = s.reason;
+		const isAbort = ctx.signal.aborted || reason instanceof Error && reason.name === "AbortError";
 		return {
 			id: toolCalls[i].id,
-			content: `Error: ${s.reason instanceof Error ? s.reason.message : String(s.reason)}`
+			content: isAbort ? INTERRUPT_MESSAGE_FOR_TOOL_USE : `Error: ${reason instanceof Error ? reason.message : String(reason)}`,
+			isError: true
 		};
 	});
 }
@@ -2157,8 +2455,10 @@ const HOOK_EVENT_SET = new Set([
 	"stream:text",
 	"stream:end",
 	"stream:thinking",
+	"stream:error",
 	"oauth:refresh",
 	"tool:gate",
+	"tool:dispatched",
 	"tool:before",
 	"tool:after",
 	"tool:error",
@@ -2175,8 +2475,10 @@ const HOOK_EVENT_SET = new Set([
 	"child:stream:text",
 	"child:stream:thinking",
 	"child:stream:end",
+	"child:stream:error",
 	"child:tool:gate",
 	"child:mcp:tool:gate",
+	"child:tool:dispatched",
 	"child:tool:before",
 	"child:tool:after",
 	"child:tool:transform",
@@ -2205,6 +2507,7 @@ const HOOK_EVENT_SET = new Set([
 	"output",
 	"budget:exceeded",
 	"tool-budget:exceeded",
+	"pairing:repair",
 	"agent:abort",
 	"agent:done",
 	"session:start",
@@ -2224,6 +2527,16 @@ function isKnownHookEvent(event) {
 * loop from leaving the persisted session with an orphan tool_use — which
 * Anthropic rejects on resume.
 *
+* Each synthetic result carries the shared
+* {@link SYNTHETIC_TOOL_RESULT_PLACEHOLDER} text (so consumers can pattern-
+* match the same way they would on a live pre-send repair) and
+* `isError: true` so the model treats it as a failed call.
+*
+* Fires `pairing:repair` (mode `orphan-tool-use-append`) for each synthetic
+* result, mirroring the wire-level repair pass's observability so postmortem
+* dashboards see the same telemetry shape regardless of where the orphan
+* was detected.
+*
 * No-op when:
 * - The trailing turn isn't an assistant turn (already closed, or session
 *   ends with the seeded user prompt).
@@ -2231,7 +2544,7 @@ function isKnownHookEvent(event) {
 * - All tool_use ids are already answered by a tool_result somewhere later
 *   in the conversation (defensive — shouldn't happen but cheap to check).
 */
-function synthesizeMissingToolResults(turns, syntheticTurnId, runId, provider) {
+async function synthesizeMissingToolResults(turns, syntheticTurnId, runId, provider, hooks) {
 	if (turns.length === 0) return;
 	const last = turns[turns.length - 1];
 	if (last.role !== "assistant") return;
@@ -2244,7 +2557,8 @@ function synthesizeMissingToolResults(turns, syntheticTurnId, runId, provider) {
 	if (dangling.length === 0) return;
 	const results = dangling.map((id) => ({
 		id,
-		content: "Aborted: run failed before tool execution completed"
+		content: SYNTHETIC_TOOL_RESULT_PLACEHOLDER,
+		isError: true
 	}));
 	const msg = provider.toolResultsMessage(results);
 	turns.push({
@@ -2254,6 +2568,11 @@ function synthesizeMissingToolResults(turns, syntheticTurnId, runId, provider) {
 		content: msg.content,
 		createdAt: Date.now()
 	});
+	for (const callId of dangling) await hooks.callHook("pairing:repair", {
+		mode: "orphan-tool-use-append",
+		callId,
+		messageIndex: turns.length - 2
+	});
 }
 function resolveBehavior(agentBehavior, runBehavior) {
 	return {
@@ -2278,7 +2597,8 @@ function resolveBehavior(agentBehavior, runBehavior) {
 		toolSearch: runBehavior?.toolSearch ?? agentBehavior?.toolSearch,
 		persistThreshold: runBehavior?.persistThreshold ?? agentBehavior?.persistThreshold,
 		persistExcludeTools: runBehavior?.persistExcludeTools ?? agentBehavior?.persistExcludeTools,
-		persistDir: runBehavior?.persistDir ?? agentBehavior?.persistDir
+		persistDir: runBehavior?.persistDir ?? agentBehavior?.persistDir,
+		strictToolPairing: runBehavior?.strictToolPairing ?? agentBehavior?.strictToolPairing ?? false
 	};
 }
 /**
@@ -2366,7 +2686,7 @@ function buildSearchableCatalog(entries, options) {
 	}
 	const serverNames = [...byServer.keys()].sort();
 	const parts = [];
-	if (options.discoveryToolName) parts.push("The following tools are available but their input schemas are NOT loaded in your context.", `Call the \`${options.discoveryToolName}\` tool to load schemas before invoking them. Surfaced tools persist for the rest of the run.`, "");
+	if (options.discoveryToolName) parts.push("The following tools are available but their input schemas are NOT loaded in your context.", `Call the \`${options.discoveryToolName}\` tool to load schemas for any tool below that you have not already surfaced. Surfaced tools persist for the rest of the run.`, "");
 	parts.push("<searchable_tools>");
 	for (const server of serverNames) {
 		parts.push(`  <server name="${escapeXml(server)}">`);
@@ -2494,9 +2814,14 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 		if (running) throw new Error("Agent is already running. Use steer() or followUp() to queue messages, or waitForIdle().");
 		const hasSessionTurns = session && session.turns.length > 0;
 		if (!options.prompt && !hasSessionTurns) throw new Error("prompt is required when no session with existing turns is provided");
-		if (!options.prompt && hasSessionTurns) {
-			const lastTurn = session.turns.at(-1);
-			if (lastTurn && lastTurn.role !== "user") throw new Error("cannot resume without prompt: last session turn must be a user message");
+		let resumeFilteredTurns;
+		if (hasSessionTurns) resumeFilteredTurns = filterUnresolvedToolUses(session.turns);
+		if (!options.prompt && resumeFilteredTurns) {
+			const lastTurn = resumeFilteredTurns.at(-1);
+			if (lastTurn && lastTurn.role !== "user") {
+				const detail = detectTurnInterruption(resumeFilteredTurns) === "completed" ? "last turn is a completed assistant message" : "last turn is mid-stream assistant content";
+				throw new Error(`cannot resume without prompt: ${detail}. Pass a prompt to agent.run({ prompt: … }).`);
+			}
 		}
 		let externalAbortListener;
 		const externalSignal = options.signal;
@@ -2561,7 +2886,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 { toolExecution, maxTurns, maxTokens, thinkingBudget, schema, cache, toolOutputBudget, compactStrategy, compactThreshold, compactKeepTurns, thinkingDecay, dedupTools, toolBudgets, elideStaleReads, toolDisclosure, toolSearch, persistThreshold, persistExcludeTools, persistDir } = resolvedBehavior;
+			const { toolExecution, maxTurns, maxTokens, thinkingBudget, schema, cache, toolOutputBudget, compactStrategy, compactThreshold, compactKeepTurns, thinkingDecay, dedupTools, toolBudgets, elideStaleReads, toolDisclosure, toolSearch, persistThreshold, persistExcludeTools, persistDir, strictToolPairing } = resolvedBehavior;
 			let system = options.system || agentSystem || "You are a helpful assistant.";
 			if (skillsCatalog) system = `${system}\n\n${skillsCatalog}`;
 			const runBaseTools = options.tools !== void 0 ? options.tools : mcpConnection ? {
@@ -2626,7 +2951,8 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 			if (isResume) {
 				const childRunIds = new Set(session.runs.filter((r) => (r.depth ?? 0) > 0).map((r) => r.id));
 				const resumed = childRunIds.size === 0 ? session.turns : session.turns.filter((t) => !t.runId || !childRunIds.has(t.runId));
-				turns.push(...resumed);
+				const filteredForRuntime = resumeFilteredTurns && resumed === session.turns ? resumeFilteredTurns : filterUnresolvedToolUses(resumed);
+				turns.push(...filteredForRuntime);
 			}
 			const runTurnStart = turns.length;
 			if (options.system) await hooks.callHook("system:before", { system: options.system });
@@ -2669,7 +2995,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 			const unregisterToolResultsSync = session ? hooks.hook("tool-results:after", persistPendingTurns) : void 0;
 			async function flushTurns(opts = {}) {
 				if (!session) return;
-				if (opts.failureFallback) synthesizeMissingToolResults(turns, await session.generateTurnId?.() ?? crypto.randomUUID(), runId, provider);
+				if (opts.failureFallback) await synthesizeMissingToolResults(turns, await session.generateTurnId?.() ?? crypto.randomUUID(), runId, provider, hooks);
 				const remaining = turns.slice(lastPersistedTurnCount);
 				if (remaining.length > 0) {
 					await session.appendTurns(remaining);
@@ -2748,6 +3074,8 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 					...persistThreshold !== void 0 ? { persistThreshold } : {},
 					...persistExcludeTools !== void 0 ? { persistExcludeTools } : {},
 					...persistDir !== void 0 ? { persistDir } : {},
+					...strictToolPairing ? { strictToolPairing: true } : {},
+					providerName: provider.name,
 					runStartMs,
 					runToolCounts: {}
 				});
@@ -4161,6 +4489,8 @@ const BUBBLED_EVENTS = [
 	"stream:text",
 	"stream:thinking",
 	"stream:end",
+	"stream:error",
+	"tool:dispatched",
 	"tool:before",
 	"tool:after",
 	"tool:error",
@@ -4175,6 +4505,8 @@ const CHILD_EVENT_NAME = {
 	"stream:text": "child:stream:text",
 	"stream:thinking": "child:stream:thinking",
 	"stream:end": "child:stream:end",
+	"stream:error": "child:stream:error",
+	"tool:dispatched": "child:tool:dispatched",
 	"tool:before": "child:tool:before",
 	"tool:after": "child:tool:after",
 	"tool:error": "child:tool:error",
@@ -4571,6 +4903,6 @@ const writeFile$1 = {
 	}
 };
 //#endregion
-export { maybePersistToolResult as C, cleanupPersistedSession as S, getReadState as T, createSkillsReadTool as _, multiEdit as a, PERSISTENCE_PREVIEW_BYTES 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, validateToolArgs as v, resolvePersistDir as w, buildPersistedStub as x, PERSISTED_STUB_PREFIX as y };
+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 };
 
-//# sourceMappingURL=tools-CMVruxF0.js.map
+//# sourceMappingURL=tools-CWEDS2ZT.js.map