zidane 5.13.26 → 5.14.0

package/dist/messages-YZQLKaz2.js

@@ -0,0 +1,1157 @@
+import { t as fnv1aBase36 } from "./hash-DJRzmcPI.js";
+import { i as documentBlockMarker, n as assertResolvedMediaBlock } from "./types-CyVGdbia.js";
+import { i as TOOL_RESULTS_TAG, t as ASSISTANT_TOOL_CALLS_TAG } from "./openai-compat-0Y7jcncn.js";
+import { n as reconcileImageMediaType, t as audioFormatFromMediaType } from "./media-sniff-Bn76JxAu.js";
+//#region src/session/messages.ts
+/**
+* Decode an Anthropic `tool_result.content` wire value back to zidane's canonical
+* `string | ToolResultContent[]` shape.
+*
+* Anthropic accepts three shapes in the wire: `string`, `Array<{type:'text',text}>`,
+* or `Array<{type:'text'|'image', ...}>`. We collapse to `string` only when every
+* block is text to keep simple cases readable.
+*/
+function decodeAnthropicToolResultContent(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return JSON.stringify(content);
+	const blocks = [];
+	for (const raw of content) {
+		if (!raw || typeof raw !== "object") continue;
+		const b = raw;
+		if (b.type === "text" && typeof b.text === "string") {
+			blocks.push({
+				type: "text",
+				text: b.text
+			});
+			continue;
+		}
+		if (b.type === "image" && b.source && typeof b.source === "object") {
+			const src = b.source;
+			if (src.type === "base64" && typeof src.data === "string" && typeof src.media_type === "string") {
+				blocks.push({
+					type: "image",
+					mediaType: src.media_type,
+					data: src.data
+				});
+				continue;
+			}
+		}
+		blocks.push({
+			type: "text",
+			text: JSON.stringify(raw)
+		});
+	}
+	if (blocks.length === 0) return "";
+	if (!blocks.some((b) => b.type !== "text")) return blocks.map((b) => b.text).join("\n");
+	return blocks;
+}
+/**
+* Build an Anthropic `image.source` block, reconciling the declared media
+* type against the actual magic bytes.
+*
+* Anthropic's API rejects the entire request when `media_type` disagrees
+* with the payload (`messages.N.content.K.image.source.base64: The image
+* was specified using the X media type, but the image appears to be a
+* Y image`). The upstream sources of `{type:'image'}` blocks each sniff
+* before producing the block (read_file / MCP / TUI paste), but this
+* wire-boundary reconciliation is a final safety net for any future code
+* path or host-supplied prompt part that slips through without sniffing.
+*
+* The reconciler is conservative: it overrides only when the magic bytes
+* positively identify a *different* known format. Unknown / too-short
+* payloads pass `mediaType` through unchanged.
+*/
+function anthropicImageSource(mediaType, data) {
+	return {
+		type: "base64",
+		media_type: reconcileImageMediaType(mediaType, data),
+		data
+	};
+}
+function anthropicDocumentBlocks(doc) {
+	if (doc.encoding === "base64" && doc.mediaType === "application/pdf") return [{
+		type: "document",
+		source: {
+			type: "base64",
+			media_type: "application/pdf",
+			data: doc.data
+		},
+		...doc.name ? { title: doc.name } : {}
+	}];
+	return [{
+		type: "text",
+		text: `${doc.name ? `<attachment name="${doc.name}" media_type="${doc.mediaType}" encoding="${doc.encoding}">` : `<attachment media_type="${doc.mediaType}" encoding="${doc.encoding}">`}\n${doc.data}\n</attachment>`
+	}];
+}
+function documentMarker(doc) {
+	return documentBlockMarker(doc, "document attached");
+}
+function isContentRefBlock(block) {
+	return (block.type === "image" || block.type === "document") && typeof block.ref === "string";
+}
+function unresolvedContentRefError(block) {
+	return /* @__PURE__ */ new Error(`Cannot project content ref "${block.ref}" to provider wire messages without resolveContentRef.`);
+}
+/**
+* Coerce a tool-call id to Anthropic's wire constraint `^[a-zA-Z0-9_-]+$`.
+*
+* Sessions started under another provider (OpenAI-compat / OpenRouter /
+* Cerebras) or carrying MCP-namespaced calls can hold ids with `.`, `:`,
+* `/` or other characters that 400 the request the moment the user switches
+* to an Anthropic model (`messages.N.content.M.tool_use.id: String should
+* match pattern '^[a-zA-Z0-9_-]+$'`).
+*
+* The mapping is deterministic — every disallowed char becomes `_` — so a
+* `tool_use` and its paired `tool_result` (sanitized identically below) keep
+* matching ids and the pairing survives. When sanitization actually changed
+* the id, a short hash of the ORIGINAL id is appended so distinct inputs
+* that would collapse to the same replacement (`call.1` vs `call_1` vs
+* `call:1`) stay distinct on the wire. Empty ids get a stable placeholder
+* so the block stays well-formed.
+*/
+const ANTHROPIC_TOOL_ID_INVALID = /[^\w-]/g;
+function sanitizeAnthropicToolId(id) {
+	if (!id) return "tool_0";
+	const sanitized = id.replace(ANTHROPIC_TOOL_ID_INVALID, "_");
+	if (sanitized === id) return id;
+	return `${sanitized}_${fnv1aBase36(id)}`;
+}
+/**
+* Encode zidane's canonical `string | ToolResultContent[]` shape to Anthropic's
+* wire format for `tool_result.content`.
+*/
+function encodeAnthropicToolResultContent(output) {
+	if (typeof output === "string") return output;
+	return output.map((b) => {
+		if (b.type === "text") return {
+			type: "text",
+			text: b.text
+		};
+		if (b.type === "document") {
+			assertResolvedMediaBlock(b, "Anthropic wire messages");
+			return {
+				type: "text",
+				text: documentMarker(b)
+			};
+		}
+		if (b.type === "audio") return {
+			type: "text",
+			text: `[audio omitted: ${b.mediaType}]`
+		};
+		if (b.type === "video") return {
+			type: "text",
+			text: `[video omitted: ${b.mediaType}]`
+		};
+		assertResolvedMediaBlock(b, "Anthropic wire messages");
+		return {
+			type: "image",
+			source: anthropicImageSource(b.mediaType, b.data)
+		};
+	});
+}
+function fromAnthropic(msg) {
+	const role = msg.role;
+	const content = [];
+	if (typeof msg.content === "string") {
+		content.push({
+			type: "text",
+			text: msg.content
+		});
+		return {
+			role,
+			content
+		};
+	}
+	if (Array.isArray(msg.content)) for (const block of msg.content) {
+		if (!block || typeof block !== "object") continue;
+		const b = block;
+		if (b.type === "text") content.push({
+			type: "text",
+			text: b.text
+		});
+		else if (b.type === "image") {
+			const source = b.source;
+			if (source?.type === "base64") content.push({
+				type: "image",
+				mediaType: source.media_type,
+				data: source.data
+			});
+		} else if (b.type === "document") {
+			const source = b.source;
+			if (source?.type === "base64" && typeof source.media_type === "string" && typeof source.data === "string") content.push({
+				type: "document",
+				mediaType: source.media_type,
+				data: source.data,
+				encoding: "base64",
+				...typeof b.title === "string" ? { name: b.title } : {}
+			});
+			else if (source?.type === "text" && typeof source.media_type === "string" && typeof source.data === "string") content.push({
+				type: "document",
+				mediaType: source.media_type,
+				data: source.data,
+				encoding: "text",
+				...typeof b.title === "string" ? { name: b.title } : {}
+			});
+		} else if (b.type === "tool_use") content.push({
+			type: "tool_call",
+			id: b.id,
+			name: b.name,
+			input: b.input
+		});
+		else if (b.type === "tool_result") {
+			const output = decodeAnthropicToolResultContent(b.content);
+			const block = {
+				type: "tool_result",
+				callId: b.tool_use_id,
+				output
+			};
+			if (b.is_error === true) block.isError = true;
+			content.push(block);
+		} else if (b.type === "thinking") {
+			const block = {
+				type: "thinking",
+				text: b.thinking ?? ""
+			};
+			if (typeof b.signature === "string") {
+				block.signature = b.signature;
+				block.signatureProducer = "anthropic";
+			}
+			content.push(block);
+		} else if (b.type === "redacted_thinking") content.push({
+			type: "redacted_thinking",
+			data: b.data ?? ""
+		});
+		else if (b.type === "server_tool_use") content.push({
+			type: "server_tool_use",
+			producer: "anthropic",
+			id: b.id ?? "",
+			name: b.name ?? "",
+			input: b.input ?? {}
+		});
+		else if (b.type === "web_search_tool_result") content.push({
+			type: "server_tool_result",
+			producer: "anthropic",
+			toolUseId: b.tool_use_id ?? "",
+			toolName: "web_search",
+			content: b.content
+		});
+	}
+	return {
+		role,
+		content
+	};
+}
+function fromOpenAI(msg) {
+	const role = msg.role;
+	const content = [];
+	const c = msg.content;
+	if (c == null) return {
+		role,
+		content
+	};
+	if (typeof c === "string") {
+		content.push({
+			type: "text",
+			text: c
+		});
+		return {
+			role,
+			content
+		};
+	}
+	if (typeof c === "object" && !Array.isArray(c) && c._tag === "__zidane_assistant_tc__") {
+		const tagged = c;
+		if (typeof tagged.text === "string" && tagged.text) content.push({
+			type: "text",
+			text: tagged.text
+		});
+		if (Array.isArray(tagged.tool_calls)) for (const raw of tagged.tool_calls) {
+			if (!raw || typeof raw !== "object") continue;
+			const tc = raw;
+			const rawArgs = tc.function?.arguments;
+			let input = {};
+			if (typeof rawArgs === "string") try {
+				input = JSON.parse(rawArgs);
+			} catch {
+				input = {};
+			}
+			else if (rawArgs && typeof rawArgs === "object") input = rawArgs;
+			content.push({
+				type: "tool_call",
+				id: tc.id ?? "",
+				name: tc.function?.name ?? "",
+				input
+			});
+		}
+		return {
+			role,
+			content
+		};
+	}
+	if (typeof c === "object" && !Array.isArray(c) && c._tag === "__zidane_tool_results__") {
+		const tagged = c;
+		if (Array.isArray(tagged.results)) for (const raw of tagged.results) {
+			if (!raw || typeof raw !== "object") continue;
+			const r = raw;
+			content.push({
+				type: "tool_result",
+				callId: r.tool_call_id ?? "",
+				output: r.content ?? ""
+			});
+		}
+		if (typeof tagged.text === "string" && tagged.text) content.push({
+			type: "text",
+			text: tagged.text
+		});
+		return {
+			role,
+			content
+		};
+	}
+	if (Array.isArray(c)) {
+		for (const block of c) {
+			if (!block || typeof block !== "object") continue;
+			const b = block;
+			if (b.type === "text") content.push({
+				type: "text",
+				text: b.text
+			});
+			else if (b.type === "image_url") {
+				const imageUrl = b.image_url?.url;
+				if (imageUrl?.startsWith("data:")) {
+					const [meta, data] = imageUrl.slice(5).split(",", 2);
+					const mediaType = meta.replace(";base64", "");
+					content.push({
+						type: "image",
+						mediaType,
+						data
+					});
+				}
+			}
+		}
+		return {
+			role,
+			content
+		};
+	}
+	return {
+		role,
+		content
+	};
+}
+function toAnthropic(msg) {
+	const blocks = msg.content.filter((b) => {
+		if (b.type === "provider_reasoning") return false;
+		if (b.type !== "thinking") return true;
+		if (b.signatureProducer === "openai") return false;
+		if (!b.signature) return false;
+		return true;
+	}).flatMap((block) => {
+		switch (block.type) {
+			case "text": return [{
+				type: "text",
+				text: block.text
+			}];
+			case "image":
+				assertResolvedMediaBlock(block, "Anthropic wire messages");
+				return [{
+					type: "image",
+					source: anthropicImageSource(block.mediaType, block.data)
+				}];
+			case "audio": return [{
+				type: "text",
+				text: `[audio omitted: ${block.mediaType}]`
+			}];
+			case "video": return [{
+				type: "text",
+				text: `[video omitted: ${block.mediaType}]`
+			}];
+			case "document":
+				assertResolvedMediaBlock(block, "Anthropic wire messages");
+				return anthropicDocumentBlocks(block);
+			case "tool_call": return [{
+				type: "tool_use",
+				id: sanitizeAnthropicToolId(block.id),
+				name: block.name,
+				input: block.input
+			}];
+			case "tool_result": {
+				const out = {
+					type: "tool_result",
+					tool_use_id: sanitizeAnthropicToolId(block.callId),
+					content: encodeAnthropicToolResultContent(block.output)
+				};
+				if (block.isError) out.is_error = true;
+				return [out, ...(typeof block.output === "string" ? [] : block.output.filter((part) => part.type === "document" && typeof part.data === "string")).flatMap(anthropicDocumentBlocks)];
+			}
+			case "thinking": return [{
+				type: "thinking",
+				thinking: block.text,
+				signature: block.signature ?? ""
+			}];
+			case "redacted_thinking": return [{
+				type: "redacted_thinking",
+				data: block.data
+			}];
+			case "server_tool_use": return [{
+				type: "server_tool_use",
+				id: sanitizeAnthropicToolId(block.id),
+				name: block.name,
+				input: block.input
+			}];
+			case "server_tool_result": return [{
+				type: "web_search_tool_result",
+				tool_use_id: sanitizeAnthropicToolId(block.toolUseId),
+				content: block.content
+			}];
+			default: return [{
+				type: "text",
+				text: ""
+			}];
+		}
+	});
+	const first = blocks[0];
+	if (blocks.length === 1 && first.type === "text") return {
+		role: msg.role,
+		content: first.text
+	};
+	return {
+		role: msg.role,
+		content: blocks
+	};
+}
+function toOpenAI(msg) {
+	const toolCalls = msg.content.filter((b) => b.type === "tool_call");
+	const toolResults = msg.content.filter((b) => b.type === "tool_result");
+	const textBlocks = msg.content.filter((b) => b.type === "text");
+	const imageBlocks = msg.content.filter((b) => b.type === "image");
+	const audioBlocks = msg.content.filter((b) => b.type === "audio");
+	const videoBlocks = msg.content.filter((b) => b.type === "video");
+	const documentBlocks = msg.content.filter((b) => b.type === "document");
+	if (toolResults.length > 0) {
+		const siblingText = textBlocks.map((b) => b.text).join("\n");
+		return {
+			role: msg.role,
+			content: {
+				_tag: TOOL_RESULTS_TAG,
+				results: toolResults.map((tr) => ({
+					tool_call_id: tr.callId,
+					content: tr.output
+				})),
+				...siblingText ? { text: siblingText } : {}
+			}
+		};
+	}
+	if (toolCalls.length > 0) {
+		const textContent = textBlocks.length > 0 ? textBlocks[0].text : null;
+		return {
+			role: msg.role,
+			content: {
+				_tag: ASSISTANT_TOOL_CALLS_TAG,
+				text: textContent,
+				tool_calls: toolCalls.map((tc) => ({
+					id: tc.id,
+					type: "function",
+					function: {
+						name: tc.name,
+						arguments: JSON.stringify(tc.input)
+					}
+				}))
+			}
+		};
+	}
+	if (imageBlocks.length > 0 || audioBlocks.length > 0 || videoBlocks.length > 0 || documentBlocks.length > 0) {
+		const parts = [];
+		for (const img of imageBlocks) {
+			assertResolvedMediaBlock(img, "OpenAI-compatible wire messages");
+			parts.push({
+				type: "image_url",
+				image_url: { url: `data:${img.mediaType};base64,${img.data}` }
+			});
+		}
+		for (const b of audioBlocks) parts.push({
+			type: "input_audio",
+			input_audio: {
+				data: b.data,
+				format: audioFormatFromMediaType(b.mediaType)
+			}
+		});
+		for (const b of videoBlocks) parts.push({
+			type: "video_url",
+			video_url: { url: `data:${b.mediaType};base64,${b.data}` }
+		});
+		for (const b of documentBlocks) {
+			assertResolvedMediaBlock(b, "OpenAI-compatible wire messages");
+			parts.push({
+				type: "text",
+				text: documentMarker(b)
+			});
+		}
+		for (const b of textBlocks) parts.push({
+			type: "text",
+			text: b.text
+		});
+		return {
+			role: msg.role,
+			content: parts
+		};
+	}
+	if (textBlocks.length === 1) return {
+		role: msg.role,
+		content: textBlocks[0].text
+	};
+	if (textBlocks.length > 1) return {
+		role: msg.role,
+		content: textBlocks.map((b) => ({
+			type: "text",
+			text: b.text
+		}))
+	};
+	return {
+		role: msg.role,
+		content: null
+	};
+}
+/**
+* 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.
+*
+* Six repair modes — modeled after Anthropic's Claude Code defenses:
+*
+* | # | 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 |
+*
+* **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 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 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 ensureToolResultPairing(messages, options = {}) {
+	if (messages.length === 0) return messages;
+	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") 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;
+			}
+			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 (seenCallIds.has(block.callId)) {
+			modifiedHere = true;
+			fireRepair({
+				mode: "duplicate-tool-result-strip",
+				callId: block.callId,
+				messageIndex: index
+			});
+			continue;
+		}
+		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;
+		}
+		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: [{
+				type: "text",
+				text: ORPHANED_TOOL_RESULT_MARKER
+			}]
+		});
+		return;
+	}
+	out.push({
+		...msg,
+		content: finalContent
+	});
+}
+/**
+* Re-mint tool-call ids that collide with ids already present in the
+* transcript (or with an earlier sibling in the same turn), BEFORE the turn
+* is persisted and its tools dispatched.
+*
+* Why this exists: some providers/serving stacks emit non-globally-unique
+* tool_use ids (per-turn counters like `call_0`, retry-replay duplicates,
+* Kimi-K2.6 on Fireworks). The wire-time pairing pass
+* ({@link ensureToolResultPairing}) can only STRIP such duplicates — which
+* erases the model's tool calls and results from the wire view, stalls
+* progress, and re-accumulates repairs quadratically because the persisted
+* session keeps the corrupted ids. Re-minting at persist time keeps the
+* pairing intact instead: the call, its execution, and its tool_result all
+* carry the fresh id, so the pairing pass has nothing to strip on any later
+* turn.
+*
+* Fresh ids are `${oldId}_r{n}` with `n` bumped until unique — deterministic
+* shape, Anthropic-wire-safe charset (given a safe input id), and visibly
+* traceable back to the original.
+*
+* Alignment contract: `toolCalls` and the `tool_call` blocks inside
+* `content` are two views of the same emission and MUST be in the same
+* order (true for every provider — both are built from one source array).
+* Occurrences are matched positionally per old id so intra-turn duplicates
+* map to distinct fresh ids on both views.
+*
+* Pure: returns the input references unchanged when no id collides.
+*/
+function remintDuplicateToolCallIds(toolCalls, content, priorIds) {
+	const seen = new Set(priorIds);
+	const reminted = [];
+	const finalIdQueues = /* @__PURE__ */ new Map();
+	let changed = false;
+	const outCalls = toolCalls.map((tc) => {
+		let finalId = tc.id;
+		if (seen.has(tc.id)) {
+			let n = 1;
+			while (seen.has(`${tc.id}_r${n}`)) n++;
+			finalId = `${tc.id}_r${n}`;
+			reminted.push({
+				oldId: tc.id,
+				newId: finalId
+			});
+			changed = true;
+		}
+		seen.add(finalId);
+		const queue = finalIdQueues.get(tc.id);
+		if (queue) queue.push(finalId);
+		else finalIdQueues.set(tc.id, [finalId]);
+		return finalId === tc.id ? tc : {
+			...tc,
+			id: finalId
+		};
+	});
+	if (!changed) return {
+		toolCalls,
+		content,
+		reminted
+	};
+	return {
+		toolCalls: outCalls,
+		content: content.map((block) => {
+			if (block.type !== "tool_call") return block;
+			const finalId = finalIdQueues.get(block.id)?.shift();
+			if (finalId === void 0 || finalId === block.id) return block;
+			return {
+				...block,
+				id: finalId
+			};
+		}),
+		reminted
+	};
+}
+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;
+}
+/**
+* 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 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";
+}
+/**
+* Default directive injected by {@link ensureEndsWithUserMessage} when the
+* caller doesn't pass one. Neutral enough to read sensibly in any context —
+* compaction passes its own directive, the agent loop falls back to this.
+*
+* The trailing newline is omitted on purpose; provider `userMessage()`
+* helpers wrap the content in the right block shape and any trailing
+* whitespace would land in the wire payload as-is.
+*/
+const DEFAULT_USER_TAIL_DIRECTIVE = "Continue.";
+/**
+* Guarantee a message list ends with a `role: 'user'` message, appending a
+* synthetic directive when it doesn't.
+*
+* Why: Anthropic's API (and several OpenAI-compat reasoning models — opus
+* 4.7, the o-series translation layers on Bedrock/Vertex) rejects requests
+* whose final message is `role: 'assistant'` with
+* "This model does not support assistant message prefill. The conversation
+* must end with a user message."
+*
+* Triggers in zidane:
+*   - Compaction over a session whose last turn is the agent's response
+*     (the common case — autocompact fires right after `agent.run()`).
+*   - Schema enforcement after an assistant text turn (no `tool_use`, so
+*     `ensureToolResultPairing` doesn't synthesize a user tail).
+*   - `context:transform` hooks that strip the trailing user turn.
+*
+* The pair-repair pass {@link ensureToolResultPairing} already covers the
+* orphan-`tool_use` case via mode 2; this helper closes the plain-text
+* assistant-tail case. They compose: run pair-repair first, then this
+* pass, so an assistant turn with orphan tool_uses gets its synthetic
+* `tool_result` user turn AND this pass is a no-op (the synthetic turn
+* is already user-role).
+*
+* Empty input passes through unchanged — the caller's "nothing to send"
+* guard is responsible for that case; we don't materialize a conversation
+* out of an empty list.
+*
+* Idempotent: returns the input reference unchanged when the list is
+* already user-terminated (or empty).
+*
+* @param messages   Wire-ready message list.
+* @param provider   Provider whose `userMessage()` shape we use so the
+*                   synthetic turn matches the wire format the rest of
+*                   the list already follows.
+* @param directive  Text to put in the synthetic user message. Defaults
+*                   to {@link DEFAULT_USER_TAIL_DIRECTIVE} ("Continue.").
+*                   Compaction overrides this with a summary-specific cue.
+*/
+function ensureEndsWithUserMessage(messages, provider, directive = DEFAULT_USER_TAIL_DIRECTIVE) {
+	if (messages.length === 0) return messages;
+	if (messages[messages.length - 1].role === "user") return messages;
+	return [...messages, provider.userMessage(directive)];
+}
+async function resolveRefContentBlock(block, resolveContentRef) {
+	if (isContentRefBlock(block)) {
+		if (!resolveContentRef) throw unresolvedContentRefError(block);
+		const { data } = await resolveContentRef({
+			type: block.type,
+			ref: block.ref,
+			mediaType: block.mediaType,
+			...block.type === "document" ? { encoding: block.encoding } : {},
+			...block.name ? { name: block.name } : {}
+		});
+		if (block.type === "image") return {
+			block: {
+				type: "image",
+				mediaType: block.mediaType,
+				data,
+				...block.name ? { name: block.name } : {}
+			},
+			changed: true
+		};
+		return {
+			block: {
+				type: "document",
+				mediaType: block.mediaType,
+				encoding: block.encoding,
+				data,
+				...block.name ? { name: block.name } : {}
+			},
+			changed: true
+		};
+	}
+	if (block.type !== "tool_result" || typeof block.output === "string") return {
+		block,
+		changed: false
+	};
+	const resolved = await resolveToolResultContent(block.output, resolveContentRef);
+	if (!resolved.changed) return {
+		block,
+		changed: false
+	};
+	return {
+		block: {
+			...block,
+			output: resolved.output
+		},
+		changed: true
+	};
+}
+async function resolveToolResultContent(output, resolveContentRef) {
+	let changed = false;
+	const next = [];
+	for (const part of output) {
+		if (!isContentRefBlock(part)) {
+			next.push(part);
+			continue;
+		}
+		if (!resolveContentRef) throw unresolvedContentRefError(part);
+		const { data } = await resolveContentRef({
+			type: part.type,
+			ref: part.ref,
+			mediaType: part.mediaType,
+			...part.type === "document" ? { encoding: part.encoding } : {},
+			...part.name ? { name: part.name } : {}
+		});
+		changed = true;
+		if (part.type === "image") next.push({
+			type: "image",
+			mediaType: part.mediaType,
+			data,
+			...part.name ? { name: part.name } : {}
+		});
+		else next.push({
+			type: "document",
+			mediaType: part.mediaType,
+			encoding: part.encoding,
+			data,
+			...part.name ? { name: part.name } : {}
+		});
+	}
+	return {
+		output: changed ? next : output,
+		changed
+	};
+}
+/**
+* Resolve image/document ref blocks into data blocks for provider wire use.
+* This is intentionally wire-only: callers must never persist the returned
+* messages back into `session.turns`.
+*
+* Returns the input array reference unchanged when no block carried a ref —
+* the common case (most turns hold no refs, and re-running on already-resolved
+* output is a no-op), so the multi-pass wire pipeline doesn't pay per-message
+* copies for nothing.
+*/
+async function resolveContentRefsInMessages(messages, options = {}) {
+	let anyChanged = false;
+	const out = [];
+	for (const msg of messages) {
+		let changed = false;
+		const content = [];
+		for (const block of msg.content) {
+			const resolved = await resolveRefContentBlock(block, options.resolveContentRef);
+			if (resolved.changed) changed = true;
+			content.push(resolved.block);
+		}
+		if (changed) anyChanged = true;
+		out.push(changed ? {
+			...msg,
+			content
+		} : msg);
+	}
+	return anyChanged ? out : messages;
+}
+function finalizeWireMessages(messages, options) {
+	const paired = ensureToolResultPairing(messages, options.onRepair ? { onRepair: options.onRepair } : {});
+	if (!options.provider) return paired;
+	return ensureEndsWithUserMessage(paired, options.provider, options.userTailDirective);
+}
+/**
+* Build a wire-ready `SessionMessage[]` from raw persisted `SessionTurn[]`.
+*
+* **The canonical "I want to send these to a provider" projection.** Use
+* this — not raw `session.turns` / `store.getTurns()` — when constructing a
+* provider request outside `agent.run()`. The agent's own wire pipeline
+* (`executeTurn` in `src/loop.ts`) applies the same repair just-in-time;
+* downstream consumers that bypass the loop hit `tool_result must be
+* preceded by a tool_call` 400s precisely because they shipped raw turns.
+*
+* Pipeline:
+*   1. Filter `system`-role turns (the wire only carries user/assistant).
+*   2. {@link ensureToolResultPairing} — repairs all six orphan / dup
+*      corruption modes by inserting synthetic placeholders rather than
+*      dropping (preserves the model's tool_use shape).
+*   3. {@link ensureEndsWithUserMessage} when `options.provider` is set —
+*      guards against assistant-tail prefill rejection (opus 4.7, o-series).
+*
+* Pure + idempotent. Does not mutate the input turns. Re-running on the
+* output is a no-op.
+*
+* **Do not feed the result back into `session.setTurns` / `appendTurns`.**
+* The repair can insert `SYNTHETIC_TOOL_RESULT_PLACEHOLDER` / `[Orphaned
+* tool result removed …]` markers; round-tripping those into persisted
+* state contaminates the session's reasoning history and defeats the
+* "don't rewrite the past" invariant the wire-only repair was designed
+* around.
+*/
+async function toWireMessages(turns, options = {}) {
+	const messages = [];
+	for (const t of turns) {
+		if (t.role === "system") continue;
+		messages.push({
+			role: t.role,
+			content: t.content
+		});
+	}
+	return finalizeWireMessages(await resolveContentRefsInMessages(messages, { resolveContentRef: options.resolveContentRef }), options);
+}
+function autoDetectAndConvert(msg) {
+	const c = msg.content;
+	if (c && typeof c === "object" && !Array.isArray(c)) {
+		const tag = c._tag;
+		if (typeof tag === "string" && tag.startsWith("__zidane_")) return fromOpenAI(msg);
+	}
+	if (Array.isArray(c)) {
+		for (const block of c) {
+			if (!block || typeof block !== "object") continue;
+			const b = block;
+			if (b.type === "tool_use" || b.type === "tool_result" && "tool_use_id" in b) return fromAnthropic(msg);
+			if (b.type === "image_url") return fromOpenAI(msg);
+		}
+		return fromAnthropic(msg);
+	}
+	if (typeof c === "string") return fromAnthropic(msg);
+	return fromAnthropic(msg);
+}
+//#endregion
+export { detectTurnInterruption as a, filterUnresolvedToolUses as c, remintDuplicateToolCallIds as d, resolveContentRefsInMessages as f, toWireMessages as h, autoDetectAndConvert as i, fromAnthropic as l, toOpenAI as m, SYNTHETIC_TOOL_RESULT_PLACEHOLDER as n, ensureEndsWithUserMessage as o, toAnthropic as p, TOOL_USE_INTERRUPTED_MARKER as r, ensureToolResultPairing as s, ORPHANED_TOOL_RESULT_MARKER as t, fromOpenAI as u };
+
+//# sourceMappingURL=messages-YZQLKaz2.js.map