zidane 5.2.1 → 5.3.1

package/dist/{messages-DsbMYNmt.js → messages-D0xT979U.js}

@@ -1,4 +1,4 @@
-import { o as errorMessage, s as matchesContextExceeded } from "./errors-COmsomd5.js";
+import { c as matchesContextExceeded, s as errorMessage } from "./errors-Byb0F8B9.js";
 import { getModel } from "@mariozechner/pi-ai";
 //#region src/providers/cost.ts
 /**
@@ -36,6 +36,323 @@ function fillEstimatedCost(usage, provider) {
 	};
 }
 //#endregion
+//#region src/providers/schema-sanitize.ts
+/** Max nesting depth before sub-schemas are replaced with `{}`. */
+const MAX_DEPTH = 32;
+/** Max `$ref` hop count before resolution gives up. */
+const MAX_REF_HOPS = 16;
+/** Keys that hold a single sub-schema. */
+const SUBSCHEMA_KEYS = [
+	"items",
+	"additionalProperties",
+	"contains",
+	"not",
+	"if",
+	"then",
+	"else",
+	"propertyNames"
+];
+/**
+* Keys that hold a record of sub-schemas.
+*
+* `$defs` / `definitions` are intentionally NOT included — they're
+* metaschema storage, only reached via `$ref` resolution (which has its
+* own walker in `resolveRef`), and `enforceRoot` strips them at the
+* wire layer once inlining is done. Recursing into them would cost
+* cycles and produce warnings about sub-trees the provider never sees.
+*/
+const SUBSCHEMA_RECORD_KEYS = [
+	"properties",
+	"patternProperties",
+	"dependentSchemas"
+];
+/** Keys that hold an array of sub-schemas. */
+const SUBSCHEMA_ARRAY_KEYS = [
+	"oneOf",
+	"anyOf",
+	"allOf",
+	"prefixItems"
+];
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Resolve a JSON pointer like `#/$defs/Foo` against `root`. Returns
+* `undefined` when the pointer doesn't resolve or hops past `MAX_REF_HOPS`.
+* The caller treats `undefined` as "give up, leave as a permissive schema".
+*/
+function resolveRef(root, ref, hops = 0) {
+	if (hops > MAX_REF_HOPS) return void 0;
+	if (!ref.startsWith("#/")) return void 0;
+	const parts = ref.slice(2).split("/").map(decodeRefSegment);
+	let cursor = root;
+	for (const part of parts) {
+		if (!isPlainObject(cursor)) return void 0;
+		cursor = cursor[part];
+	}
+	if (!isPlainObject(cursor)) return void 0;
+	if (typeof cursor.$ref === "string") return resolveRef(root, cursor.$ref, hops + 1);
+	return cursor;
+}
+function decodeRefSegment(seg) {
+	return seg.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+/**
+* Recursively sanitize a sub-schema. Returns the **original** reference
+* when nothing needed to change — every turn's `formatTools` re-runs the
+* sanitizer, and the no-alloc fast path keeps the hot loop cheap when
+* the registered tool set is already clean. Returns a fresh object when
+* any rewrite happened; never mutates the input.
+*
+* The dirty-tracking is local to each frame so a clean sub-tree under a
+* dirty parent doesn't get cloned uselessly.
+*/
+function sanitizeNode(node, ctx, depth, path) {
+	if (depth > MAX_DEPTH) {
+		ctx.warnings.push(`${ctx.prefix}schema nested deeper than ${MAX_DEPTH} levels at ${path || "$"} — replaced with permissive {}`);
+		return {};
+	}
+	if (!isPlainObject(node)) return {};
+	let dirty = false;
+	let working = node;
+	if (typeof working.$ref === "string") {
+		const ref = working.$ref;
+		const resolved = resolveRef(ctx.root, ref);
+		const { $ref: _drop, ...rest } = working;
+		if (resolved) {
+			ctx.warnings.push(`${ctx.prefix}inlined $ref "${ref}" at ${path || "$"}`);
+			working = {
+				...resolved,
+				...rest
+			};
+		} else {
+			ctx.warnings.push(`${ctx.prefix}dropped unresolvable $ref "${ref}" at ${path || "$"}`);
+			working = rest;
+		}
+		dirty = true;
+	}
+	if (working.nullable === true) {
+		if (!dirty) {
+			working = { ...working };
+			dirty = true;
+		}
+		const t = working.type;
+		if (typeof t === "string") {
+			working.type = [t, "null"];
+			ctx.warnings.push(`${ctx.prefix}converted nullable:true → type:[${t},null] at ${path || "$"}`);
+		} else if (Array.isArray(t) && !t.includes("null")) {
+			working.type = [...t, "null"];
+			ctx.warnings.push(`${ctx.prefix}converted nullable:true → type:[…,null] at ${path || "$"}`);
+		} else if (Array.isArray(t)) {} else ctx.warnings.push(`${ctx.prefix}stripped nullable:true at ${path || "$"} (no base type)`);
+		delete working.nullable;
+	}
+	for (const key of SUBSCHEMA_KEYS) {
+		const child = working[key];
+		if (isPlainObject(child)) {
+			const sanitized = sanitizeNode(child, ctx, depth + 1, `${path}/${key}`);
+			if (sanitized !== child) {
+				if (!dirty) {
+					working = { ...working };
+					dirty = true;
+				}
+				working[key] = sanitized;
+			}
+		}
+	}
+	for (const key of SUBSCHEMA_RECORD_KEYS) {
+		const rec = working[key];
+		if (isPlainObject(rec)) {
+			let recDirty = false;
+			let out = rec;
+			for (const [k, v] of Object.entries(rec)) {
+				const sanitized = sanitizeNode(v, ctx, depth + 1, `${path}/${key}/${k}`);
+				if (sanitized !== v) {
+					if (!recDirty) {
+						out = { ...rec };
+						recDirty = true;
+					}
+					out[k] = sanitized;
+				}
+			}
+			if (recDirty) {
+				if (!dirty) {
+					working = { ...working };
+					dirty = true;
+				}
+				working[key] = out;
+			}
+		}
+	}
+	for (const key of SUBSCHEMA_ARRAY_KEYS) {
+		const arr = working[key];
+		if (Array.isArray(arr)) {
+			let arrDirty = false;
+			let out = arr;
+			for (let i = 0; i < arr.length; i++) {
+				const sanitized = sanitizeNode(arr[i], ctx, depth + 1, `${path}/${key}/${i}`);
+				if (sanitized !== arr[i]) {
+					if (!arrDirty) {
+						out = [...arr];
+						arrDirty = true;
+					}
+					out[i] = sanitized;
+				}
+			}
+			if (arrDirty) {
+				if (!dirty) {
+					working = { ...working };
+					dirty = true;
+				}
+				working[key] = out;
+			}
+		}
+	}
+	return working;
+}
+/**
+* Apply root-level coercions every supported provider expects:
+*
+*   - `type === 'object'` (Anthropic requires it; OpenAI tolerates more
+*     but rejects unions at root in strict mode).
+*   - `properties` is a plain object (Anthropic 400s when missing).
+*   - No root-level `$ref` / `oneOf` / `anyOf` / `allOf` (Anthropic rejects;
+*     OpenAI behaviour varies by endpoint).
+*   - `$defs` / `definitions` stripped (recursive pass already inlined
+*     refs; the metaschema storage is dead weight at the wire layer).
+*
+* Applied for every profile because portability matters more than the
+* marginal permissiveness of any one host. Profile-specific extras
+* (currently `$schema` stripping on `anthropic`) are gated below.
+*/
+function enforceRoot(schema, ctx) {
+	let out = schema;
+	let dirty = false;
+	const dirtyOnce = () => {
+		if (!dirty) {
+			out = { ...schema };
+			dirty = true;
+		}
+	};
+	const t = out.type;
+	if (Array.isArray(t)) if (t.includes("object")) {
+		dirtyOnce();
+		out.type = "object";
+		if (t.length > 1) ctx.warnings.push(`${ctx.prefix}collapsed root type:[${t.join(",")}] to 'object'`);
+	} else {
+		dirtyOnce();
+		ctx.warnings.push(`${ctx.prefix}root type:[${t.join(",")}] does not include 'object' — coerced to 'object'`);
+		out.type = "object";
+	}
+	else if (typeof t === "string" && t !== "object") {
+		dirtyOnce();
+		ctx.warnings.push(`${ctx.prefix}coerced root type:'${t}' → 'object'`);
+		out.type = "object";
+	} else if (t === void 0) {
+		dirtyOnce();
+		out.type = "object";
+	}
+	if (!isPlainObject(out.properties)) {
+		if ("properties" in out) ctx.warnings.push(`${ctx.prefix}replaced non-object 'properties' at root with {}`);
+		dirtyOnce();
+		out.properties = {};
+	}
+	for (const key of [
+		"oneOf",
+		"anyOf",
+		"allOf"
+	]) if (key in out) {
+		dirtyOnce();
+		ctx.warnings.push(`${ctx.prefix}stripped root '${key}' (providers require a single object schema)`);
+		delete out[key];
+	}
+	if ("$ref" in out) {
+		dirtyOnce();
+		ctx.warnings.push(`${ctx.prefix}stripped root $ref`);
+		delete out.$ref;
+	}
+	if ("$defs" in out) {
+		dirtyOnce();
+		delete out.$defs;
+	}
+	if ("definitions" in out) {
+		dirtyOnce();
+		delete out.definitions;
+	}
+	if (ctx.profile === "anthropic" && "$schema" in out) {
+		dirtyOnce();
+		delete out.$schema;
+	}
+	return out;
+}
+/**
+* Sanitize a single tool's `inputSchema` for safe forwarding to the
+* provider. Returns the rewritten schema + a list of warnings describing
+* everything that changed.
+*
+* Never mutates the input. Returns the **same reference** when no rewrite
+* was needed (clean-schema fast path) — `sanitizeToolSpecs` relies on
+* this to keep the formatTools hot loop allocation-free across turns
+* when the registered tool set is already wire-valid.
+*/
+function sanitizeToolSchema(input, options = {}) {
+	const profile = options.profile ?? "permissive";
+	const prefix = options.toolName ? `[tool:${options.toolName}] ` : "";
+	if (!isPlainObject(input)) return {
+		schema: {
+			type: "object",
+			properties: {}
+		},
+		warnings: []
+	};
+	const ctx = {
+		root: input,
+		warnings: [],
+		profile,
+		prefix
+	};
+	return {
+		schema: enforceRoot(sanitizeNode(input, ctx, 0, ""), ctx),
+		warnings: ctx.warnings
+	};
+}
+/**
+* Convenience: sanitize a batch of tools and emit a single de-duped
+* `console.warn` per unique warning line. Returns the rewritten tools
+* preserving original ordering and reference identity for clean schemas
+* (no reallocation when nothing needed to change).
+*
+* The sanitiser runs every request, so log noise from a stable bad
+* schema would multiply across turns; the de-dupe keeps the signal
+* useful in production logs without dropping the first occurrence.
+*/
+function sanitizeToolSpecs(tools, options = {}) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const tool of tools) {
+		const result = sanitizeToolSchema(tool.inputSchema, {
+			profile: options.profile,
+			toolName: tool.name
+		});
+		if (result.warnings.length === 0 && result.schema === tool.inputSchema) {
+			out.push(tool);
+			continue;
+		}
+		for (const line of result.warnings) {
+			if (seen.has(line)) continue;
+			seen.add(line);
+			(options.onWarning ?? defaultWarn)(line);
+		}
+		out.push({
+			...tool,
+			inputSchema: result.schema
+		});
+	}
+	return out;
+}
+function defaultWarn(line) {
+	console.warn(`[zidane:schema] ${line}`);
+}
+//#endregion
 //#region src/providers/openai-compat.ts
 const TOOL_RESULTS_TAG = "__zidane_tool_results__";
 const ASSISTANT_TOOL_CALLS_TAG = "__zidane_assistant_tc__";
@@ -415,7 +732,7 @@ function applyOAIToolCacheBreakpoint(tools) {
 	} : tool);
 }
 function formatTools(tools) {
-	return tools.map((t) => ({
+	return sanitizeToolSpecs(tools, { profile: "openai" }).map((t) => ({
 		type: "function",
 		function: {
 			name: t.name,
@@ -448,7 +765,8 @@ function toolResultsMessage(results) {
 		content: results.map((r) => ({
 			type: "tool_result",
 			callId: r.id,
-			output: r.content
+			output: r.content,
+			...r.isError ? { isError: true } : {}
 		}))
 	};
 }
@@ -1028,97 +1346,342 @@ function toOpenAI(msg) {
 	};
 }
 /**
-* Drop assistant `tool_call` blocks whose `id` has no matching
-* `tool_result.callId` in the immediately-following user message, and drop
-* user `tool_result` blocks whose `callId` has no match in the
-* immediately-preceding assistant message.
+* Placeholder content inserted into a synthetic `tool_result` when the harness
+* has to repair an orphan `tool_use`. Exported so downstream consumers
+* (training-data collectors, HFI submission) can reject any payload containing
+* it — the marker satisfies the wire-level pairing contract structurally but
+* the content itself is fake and would poison fine-tuning data.
+*/
+const SYNTHETIC_TOOL_RESULT_PLACEHOLDER = "[Tool result missing due to internal error]";
+/**
+* Replacement text for an assistant message whose every content block was
+* stripped during pairing repair (e.g. the only blocks were orphan
+* `tool_call`s). Providers reject empty `content` arrays — the marker keeps
+* the turn shape valid while signaling "this assistant turn lost its
+* outputs" to the model so it can recover.
+*/
+const TOOL_USE_INTERRUPTED_MARKER = "[Tool use interrupted]";
+/**
+* Replacement text for a user message whose every content block was a
+* `tool_result` with no matching upstream `tool_call` (e.g. the assistant
+* pair was stripped by an earlier compaction). Same role as
+* {@link TOOL_USE_INTERRUPTED_MARKER} on the user side.
+*/
+const ORPHANED_TOOL_RESULT_MARKER = "[Orphaned tool result removed due to conversation resume]";
+/**
+* Defensive repair pass that rewrites a message list so it satisfies the
+* wire-level `tool_use` ↔ `tool_result` adjacency contract every modern
+* provider enforces.
+*
+* Anthropic 400s on orphans with `'tool_use' ids were found without
+* 'tool_result' blocks immediately after` (and its inverse, `tool_result
+* must be preceded by a tool_call with the same toolCallId`). OpenAI's
+* Chat Completions API rejects most mismatches with a 400 too.
 *
-* Anthropic strictly requires every `tool_use` block to be paired with a
-* `tool_result` block in the next user message (`messages.N: 'tool_use' ids
-* were found without 'tool_result' blocks immediately after`). OpenAI is
-* looser but still rejects most mismatches. Orphans reach the wire layer from:
+* Six repair modes — modeled after Anthropic's Claude Code defenses:
 *
-*   1. Interrupted runs (signal, crash, network drop) between persisting the
-*      assistant turn (`turn:after`) and persisting its tool results turn
-*      (`tool-results:after`).
-*   2. The schema-enforcement path — a synthetic `__output__` assistant
-*      tool_call is appended without a matching tool_result. Any resume after
-*      that turn would 400 without this pass.
-*   3. Consumer `context:transform` hooks that prune messages without
-*      preserving the `tool_use ↔ tool_result` pairing.
+* | # | Corruption | Repair |
+* |---|------------|--------|
+* | 1 | assistant `tool_use` whose next user msg lacks a matching `tool_result` | **Prepend** a synthetic `tool_result` block carrying {@link SYNTHETIC_TOOL_RESULT_PLACEHOLDER} with `isError: true` |
+* | 2 | assistant `tool_use` followed by nothing (or by a non-user msg) | **Insert** a new synthetic user message with the same placeholder |
+* | 3 | user `tool_result` with no preceding assistant `tool_call` | **Strip** the orphan block; if it empties the msg, replace with {@link ORPHANED_TOOL_RESULT_MARKER} text block |
+* | 4 | duplicate `tool_call.id` across assistant messages (CC-1212) | **Strip** later instances + their matching tool_results |
+* | 5 | duplicate `tool_result.callId` within a single user message | **Dedupe** by `callId`, keep first |
+* | 6 | assistant message emptied by mode-4 stripping | **Replace** content with {@link TOOL_USE_INTERRUPTED_MARKER} text block |
 *
-* Strategy: drop the orphan blocks rather than synthesizing fake results —
-* the model never sees a half-done call, so it can't confabulate on phantom
-* outputs. Messages emptied by the cleanup are removed entirely (providers
-* reject empty `content` arrays).
+* **Repair, not drop.** Earlier versions of this pass simply dropped orphan
+* blocks, which (a) silently rewrote history the model had reasoned over and
+* (b) cascaded — dropping an assistant tool_call would orphan its
+* tool_result, which would then get dropped too, removing any trace of
+* "what the model tried to do" from the transcript. The repair-based pass
+* preserves the model's tool_use shape and patches the dangling result with
+* an `is_error` placeholder so the model sees "I tried X, the result was
+* lost" and can retry intelligently.
 *
-* Adjacency rules:
-*  - Assistant tool_calls are matched against the ORIGINAL next user message
-*    (the wire still has to satisfy the per-message adjacency contract).
-*  - User tool_results are matched against the previously-emitted message in
-*    the cleaned output, so a tool_result whose entire assistant prefix was
-*    dropped cascades and gets dropped too.
+* Adjacency contract: `tool_result` blocks must live in the user message
+* IMMEDIATELY following the assistant message that emitted the matching
+* `tool_use`. The pass enforces strict adjacency — a tool_result two
+* messages downstream of its tool_call is still an orphan.
 *
-* Idempotent: returns the input reference when no orphans are found.
+* Idempotent: returns the input reference unchanged when no repairs were
+* necessary. Re-running on already-repaired output is a no-op.
+*
+* Pure: does not mutate input messages or their content arrays — every
+* repair allocates a fresh array / object.
 */
-function sanitizeOrphanedToolCalls(messages) {
+function ensureToolResultPairing(messages, options = {}) {
 	if (messages.length === 0) return messages;
-	const out = [];
+	const fireRepair = options.onRepair ?? (() => {});
+	const firstSeenAt = /* @__PURE__ */ new Map();
+	for (let i = 0; i < messages.length; i++) {
+		const msg = messages[i];
+		if (msg.role !== "assistant") continue;
+		for (const block of msg.content) if (block.type === "tool_call" && !firstSeenAt.has(block.id)) firstSeenAt.set(block.id, i);
+	}
+	const pendingOrphansByUserIndex = /* @__PURE__ */ new Map();
 	let changed = false;
+	const markChanged = () => {
+		changed = true;
+	};
+	const out = [];
 	for (let i = 0; i < messages.length; i++) {
 		const msg = messages[i];
-		if (msg.role === "assistant") {
-			const callIds = collectIds(msg.content, "tool_call", (b) => b.id);
-			if (callIds.size === 0) {
-				out.push(msg);
-				continue;
-			}
-			const next = messages[i + 1];
-			const matched = next && next.role === "user" ? intersectIds(next.content, "tool_result", (b) => b.callId, callIds) : /* @__PURE__ */ new Set();
-			if (matched.size === callIds.size) {
-				out.push(msg);
+		if (msg.role === "assistant") processAssistantMessage({
+			index: i,
+			msg,
+			messages,
+			firstSeenAt,
+			pendingOrphansByUserIndex,
+			out,
+			fireRepair,
+			markChanged
+		});
+		else processUserMessage({
+			index: i,
+			msg,
+			pendingOrphansByUserIndex,
+			out,
+			fireRepair,
+			markChanged
+		});
+	}
+	return changed ? out : messages;
+}
+/**
+* Process one assistant message: strip mode-4 duplicates, queue mode-1 / 2
+* orphan-tool-use repairs for the next user message (or insert a synthetic
+* one), and emit a mode-6 marker when dedup empties the message.
+*/
+function processAssistantMessage(args) {
+	const { index, msg, messages, firstSeenAt, pendingOrphansByUserIndex, out, fireRepair, markChanged } = args;
+	const dedupedContent = [];
+	const seenHere = /* @__PURE__ */ new Set();
+	let dedupedChanged = false;
+	for (const block of msg.content) {
+		if (block.type === "tool_call") {
+			const isCrossMsgDup = firstSeenAt.get(block.id) !== index;
+			const isIntraMsgDup = seenHere.has(block.id);
+			if (isCrossMsgDup || isIntraMsgDup) {
+				dedupedChanged = true;
+				fireRepair({
+					mode: "duplicate-tool-use-strip",
+					callId: block.id,
+					messageIndex: index
+				});
 				continue;
 			}
-			const cleaned = msg.content.filter((b) => b.type !== "tool_call" || matched.has(b.id));
-			changed = true;
-			if (cleaned.length > 0) out.push({
-				...msg,
-				content: cleaned
-			});
+			seenHere.add(block.id);
+		}
+		dedupedContent.push(block);
+	}
+	const surviving = collectIds(dedupedContent, "tool_call", (b) => b.id);
+	const next = messages[index + 1];
+	const nextIsUser = next && next.role === "user";
+	const nextResultIds = nextIsUser ? collectResultIds(next.content) : /* @__PURE__ */ new Set();
+	const orphans = [];
+	for (const id of surviving) if (!nextResultIds.has(id)) orphans.push(id);
+	emitAssistantAfterDedup({
+		index,
+		msg,
+		dedupedContent,
+		dedupedChanged,
+		out,
+		fireRepair,
+		markChanged
+	});
+	if (orphans.length === 0) return;
+	if (nextIsUser) {
+		markChanged();
+		pendingOrphansByUserIndex.set(index + 1, orphans);
+		for (const callId of orphans) fireRepair({
+			mode: "orphan-tool-use-prepend",
+			callId,
+			messageIndex: index
+		});
+		return;
+	}
+	markChanged();
+	out.push({
+		role: "user",
+		content: orphans.map((callId) => syntheticResultBlock(callId))
+	});
+	for (const callId of orphans) fireRepair({
+		mode: "orphan-tool-use-append",
+		callId,
+		messageIndex: index
+	});
+}
+function emitAssistantAfterDedup(args) {
+	const { index, msg, dedupedContent, dedupedChanged, out, fireRepair, markChanged } = args;
+	if (!dedupedChanged) {
+		out.push(msg);
+		return;
+	}
+	markChanged();
+	if (dedupedContent.length === 0) {
+		out.push({
+			...msg,
+			content: [{
+				type: "text",
+				text: TOOL_USE_INTERRUPTED_MARKER
+			}]
+		});
+		fireRepair({
+			mode: "empty-assistant-marker",
+			messageIndex: index
+		});
+		return;
+	}
+	out.push({
+		...msg,
+		content: dedupedContent
+	});
+}
+/**
+* Process one user message: dedup mode-5 duplicate tool_results, strip
+* mode-3 orphans whose tool_call is missing from the previously-emitted
+* assistant message, and prepend any synthetic results queued by the prior
+* assistant's mode-1 repair.
+*/
+function processUserMessage(args) {
+	const { index, msg, pendingOrphansByUserIndex, out, fireRepair, markChanged } = args;
+	const queuedOrphans = pendingOrphansByUserIndex.get(index);
+	pendingOrphansByUserIndex.delete(index);
+	const prev = out.length > 0 ? out[out.length - 1] : null;
+	const validIds = prev && prev.role === "assistant" ? collectIds(prev.content, "tool_call", (b) => b.id) : /* @__PURE__ */ new Set();
+	const seenCallIds = /* @__PURE__ */ new Set();
+	let modifiedHere = false;
+	const afterDedup = [];
+	for (const block of msg.content) {
+		if (block.type !== "tool_result") {
+			afterDedup.push(block);
 			continue;
 		}
-		if (!msg.content.some((b) => b.type === "tool_result")) {
-			out.push(msg);
+		if (seenCallIds.has(block.callId)) {
+			modifiedHere = true;
+			fireRepair({
+				mode: "duplicate-tool-result-strip",
+				callId: block.callId,
+				messageIndex: index
+			});
 			continue;
 		}
-		const prev = out.length > 0 ? out[out.length - 1] : null;
-		const validIds = prev && prev.role === "assistant" ? collectIds(prev.content, "tool_call", (b) => b.id) : /* @__PURE__ */ new Set();
-		const cleaned = msg.content.filter((b) => b.type !== "tool_result" || validIds.has(b.callId));
-		if (cleaned.length === msg.content.length) {
-			out.push(msg);
+		seenCallIds.add(block.callId);
+		afterDedup.push(block);
+	}
+	const afterStrip = [];
+	for (const block of afterDedup) {
+		if (block.type === "tool_result" && !validIds.has(block.callId)) {
+			modifiedHere = true;
+			fireRepair({
+				mode: "orphan-tool-result-strip",
+				callId: block.callId,
+				messageIndex: index
+			});
 			continue;
 		}
-		changed = true;
-		if (cleaned.length > 0) out.push({
+		afterStrip.push(block);
+	}
+	const finalContent = queuedOrphans ? [...queuedOrphans.map(syntheticResultBlock), ...afterStrip] : afterStrip;
+	if (!modifiedHere && queuedOrphans === void 0) {
+		out.push(msg);
+		return;
+	}
+	markChanged();
+	if (finalContent.length === 0) {
+		out.push({
 			...msg,
-			content: cleaned
+			content: [{
+				type: "text",
+				text: ORPHANED_TOOL_RESULT_MARKER
+			}]
 		});
+		return;
 	}
-	return changed ? out : messages;
+	out.push({
+		...msg,
+		content: finalContent
+	});
+}
+function syntheticResultBlock(callId) {
+	return {
+		type: "tool_result",
+		callId,
+		output: SYNTHETIC_TOOL_RESULT_PLACEHOLDER,
+		isError: true
+	};
+}
+function collectResultIds(content) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const block of content) if (block.type === "tool_result") ids.add(block.callId);
+	return ids;
 }
 function collectIds(content, type, getId) {
 	const ids = /* @__PURE__ */ new Set();
 	for (const block of content) if (block.type === type) ids.add(getId(block));
 	return ids;
 }
-function intersectIds(content, type, getId, candidates) {
-	const matched = /* @__PURE__ */ new Set();
-	for (const block of content) {
-		if (block.type !== type) continue;
-		const id = getId(block);
-		if (candidates.has(id)) matched.add(id);
+/**
+* Drop ASSISTANT turns whose every `tool_call` block is unresolved
+* (no matching `tool_result` block anywhere later in the transcript).
+* Tool_call blocks with at least one matching tool_result are kept — modes
+* 1/3 of {@link ensureToolResultPairing} handle the partial-pair case at
+* wire-send time.
+*
+* Use case: session resume. A turn that emitted three `tool_use` blocks but
+* never persisted the matching `tool_result` turn (process death, crash,
+* `kill -9`) leaves the transcript with an orphan that Anthropic rejects on
+* the FIRST API call after reload. Dropping the whole assistant turn — not
+* just the orphan blocks — preserves text-only turns that legitimately
+* carry reasoning the model wants to see again.
+*
+* Does NOT mint fresh ids: re-id'ing on every resume would cause
+* exponential transcript growth across repeated resumes of an interrupted
+* session.
+*
+* Pure: returns the input reference unchanged when no turn was dropped.
+*/
+function filterUnresolvedToolUses(turns) {
+	if (turns.length === 0) return turns;
+	const resolvedIds = /* @__PURE__ */ new Set();
+	for (const turn of turns) for (const block of turn.content) if (block.type === "tool_result") resolvedIds.add(block.callId);
+	let changed = false;
+	const out = [];
+	for (const turn of turns) {
+		if (turn.role !== "assistant") {
+			out.push(turn);
+			continue;
+		}
+		const toolCalls = turn.content.filter((b) => b.type === "tool_call");
+		if (toolCalls.length === 0) {
+			out.push(turn);
+			continue;
+		}
+		if (toolCalls.every((b) => b.type === "tool_call" && !resolvedIds.has(b.id))) {
+			changed = true;
+			continue;
+		}
+		out.push(turn);
 	}
-	return matched;
+	return changed ? out : turns;
+}
+/**
+* Inspect a session's trailing turn to classify whether the run was
+* interrupted mid-tool-call. Pure / synchronous — does not modify the input.
+*
+* Pair with {@link filterUnresolvedToolUses} on the resume path: filter
+* first so the result reflects the post-cleanup state (a turn whose orphans
+* were stripped reads as 'completed', not 'interrupted').
+*/
+function detectTurnInterruption(turns) {
+	if (turns.length === 0) return "clean";
+	const last = turns[turns.length - 1];
+	if (last.role === "user") return "clean";
+	if (last.role !== "assistant") return "clean";
+	const resolvedIds = /* @__PURE__ */ new Set();
+	for (const turn of turns) for (const block of turn.content) if (block.type === "tool_result") resolvedIds.add(block.callId);
+	for (const block of last.content) if (block.type === "tool_call" && !resolvedIds.has(block.id)) return "interrupted";
+	return "completed";
 }
 function autoDetectAndConvert(msg) {
 	const c = msg.content;
@@ -1139,6 +1702,6 @@ function autoDetectAndConvert(msg) {
 	return fromAnthropic(msg);
 }
 //#endregion
-export { toAnthropic as a, assistantMessage as c, openaiCompat as d, toolResultsMessage as f, sanitizeOrphanedToolCalls as i, classifyOpenAICompatError as l, fillEstimatedCost as m, fromAnthropic as n, toOpenAI as o, userMessage as p, fromOpenAI as r, OpenAICompatHttpError as s, autoDetectAndConvert as t, mapOAIFinishReason as u };
+export { toolResultsMessage as _, detectTurnInterruption as a, sanitizeToolSpecs as b, fromAnthropic as c, toOpenAI as d, OpenAICompatHttpError as f, openaiCompat as g, mapOAIFinishReason as h, autoDetectAndConvert as i, fromOpenAI as l, classifyOpenAICompatError as m, SYNTHETIC_TOOL_RESULT_PLACEHOLDER as n, ensureToolResultPairing as o, assistantMessage as p, TOOL_USE_INTERRUPTED_MARKER as r, filterUnresolvedToolUses as s, ORPHANED_TOOL_RESULT_MARKER as t, toAnthropic as u, userMessage as v, fillEstimatedCost as x, sanitizeToolSchema as y };
 
-//# sourceMappingURL=messages-DsbMYNmt.js.map
+//# sourceMappingURL=messages-D0xT979U.js.map