zidane 7.2.5 → 8.0.4

package/dist/{messages-2jcOA_5R.js → messages-BqiwcD2Q.js}

@@ -1,1119 +1,1122 @@
-import { U as fnv1aBase36, i as TOOL_RESULTS_TAG, t as ASSISTANT_TOOL_CALLS_TAG } from "./openai-compat-Dy56weK8.js";
-import { a as documentBlockMarker, o as isWireTurn, r as assertResolvedMediaBlock } from "./types-CWgENVLY.js";
+import { a as documentBlockMarker, r as assertResolvedMediaBlock, s as isWireTurn } from "./types-Cu0ZGDu9.js";
 import { n as reconcileImageMediaType, t as audioFormatFromMediaType } from "./media-sniff-UKijEaiQ.js";
-//#region src/session/messages.ts
+import { c as fnv1aBase36 } from "./aliasing-lVFbm81n.js";
+import { r as TOOL_RESULTS_TAG, t as ASSISTANT_TOOL_CALLS_TAG } from "./openai-compat-CFrpH7uq.js";
+//#region src/session/messages-pairing.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.
+* 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.
 */
-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;
-}
+const SYNTHETIC_TOOL_RESULT_PLACEHOLDER = "[Tool result missing due to internal error]";
 /**
-* 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.
+* 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.
 */
-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.`);
-}
+const TOOL_USE_INTERRUPTED_MARKER = "[Tool use interrupted]";
 /**
-* Coerce a tool-call id to Anthropic's wire constraint `^[a-zA-Z0-9_-]+$`.
+* 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.
 *
-* 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_-]+$'`).
+* 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.
 *
-* 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.
+* 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.
 */
-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)}`;
+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;
 }
 /**
-* Encode zidane's canonical `string | ToolResultContent[]` shape to Anthropic's
-* wire format for `tool_result.content`.
+* 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 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)
-			};
+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);
 		}
-		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
-		};
+		dedupedContent.push(block);
 	}
-	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
+	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;
 	}
-	return {
-		role,
-		content
-	};
+	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 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
-		};
+function emitAssistantAfterDedup(args) {
+	const { index, msg, dedupedContent, dedupedChanged, out, fireRepair, markChanged } = args;
+	if (!dedupedChanged) {
+		out.push(msg);
+		return;
 	}
-	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
+	markChanged();
+	if (dedupedContent.length === 0) {
+		out.push({
+			...msg,
+			content: [{
+				type: "text",
+				text: TOOL_USE_INTERRUPTED_MARKER
+			}]
 		});
-		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
+		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;
 		}
-		return {
-			role,
-			content
-		};
+		seenCallIds.add(block.callId);
+		afterDedup.push(block);
 	}
-	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 ?? ""
+	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;
 		}
-		if (typeof tagged.text === "string" && tagged.text) content.push({
-			type: "text",
-			text: tagged.text
-		});
-		return {
-			role,
-			content
-		};
+		afterStrip.push(block);
 	}
-	if (Array.isArray(c)) {
-		for (const block of c) {
-			if (!block || typeof block !== "object") continue;
-			const b = block;
-			if (b.type === "text") content.push({
+	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: 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
-		};
+				text: ORPHANED_TOOL_RESULT_MARKER
+			}]
+		});
+		return;
 	}
-	return {
-		role,
-		content
-	};
+	out.push({
+		...msg,
+		content: finalContent
+	});
 }
 /**
-* Single source of truth for whether a signature-bearing reasoning block
-* (`thinking` / `redacted_thinking`) may be forwarded to a provider. Both
-* wire builders ({@link toAnthropic}, the OpenAI assistant-message shaper)
-* and the host-facing {@link sanitizeHistoryForProvider} apply this same
-* policy — keeping them one function means the sanitizer can never drift
-* from what the wire actually sends.
+* 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.
 *
-* Rules, each driven by an API constraint hit in production:
+* 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.
 *
-* - target `anthropic`:
-*   - `redacted_thinking` → keep (native Anthropic block; must be echoed).
-*   - `thinking` tagged `openai` → drop (OpenAI `encrypted_content` is not
-*     a valid Anthropic HMAC; 400s).
-*   - unsigned `thinking` → drop (`ThinkingBlockParam` requires a
-*     signature; unsigned blocks come from non-signing producers).
-*   - signed but UNTAGGED `thinking` (pre-tagging sessions) → keep: it is
-*     most plausibly legacy Anthropic output, and the signature-400
-*     recovery converges if it is not.
+* 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.
 *
-* - target `openai`:
-*   - `redacted_thinking` → drop (Anthropic-only block type).
-*   - `thinking` tagged `anthropic` → drop (an Anthropic HMAC is not
-*     valid `encrypted_content`).
-*   - signed but UNTAGGED `thinking` → strip-signature: unlike the
-*     Anthropic direction there is no signature-error recovery on this
-*     path, so forwarding a possibly-foreign signature risks an
-*     unrecoverable 400 — the reasoning text survives, only the opaque
-*     signature is withheld.
+* 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 reasoningWireAction(block, target) {
-	if (block.type === "redacted_thinking") return target === "anthropic" ? "keep" : "drop";
-	if (target === "anthropic") {
-		if (block.signatureProducer === "openai") return "drop";
-		if (!block.signature) return "drop";
-		return "keep";
-	}
-	if (block.signatureProducer === "anthropic") return "drop";
-	if (block.signature && block.signatureProducer !== "openai") return "strip-signature";
-	return "keep";
+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
+	};
 }
 /**
-* Host-facing history sanitizer — applies {@link reasoningWireAction} to a
-* turn set BEFORE it is handed to an agent targeting `target`. The in-loop
-* wire builders already enforce the same policy per call, so this is for
-* hosts that seed history from an external durable store (or hydrate
-* pre-provenance-tagging sessions) and want the poison removed from their
-* source of truth in one call instead of re-deriving block semantics.
+* Drop-only normalization of persisted history: delete structurally invalid
+* tool blocks so the transcript never re-triggers wire-time pairing repairs
+* turn after turn.
 *
-* Returns new turn objects only where something changed (unchanged turns
-* pass through by reference). A turn whose content empties keeps the same
-* neutral marker the wire repair uses, so role boundaries stay intact.
+* Unlike {@link ensureToolResultPairing} — which SYNTHESIZES placeholder
+* content and must therefore stay wire-only (fabricated results would poison
+* persisted history and training data) — this pass performs pure deletions of
+* blocks that are provably invalid regardless of interpretation:
+*
+* | Corruption | Action |
+* |------------|--------|
+* | duplicate `tool_call` id within one run lane (across or within turns) | drop the later instance |
+* | duplicate `tool_result.callId` within one turn | drop the later instance |
+* | `tool_result` with no matching `tool_call` in the immediately preceding same-lane assistant turn | drop the block |
+* | turn emptied by the drops above (reasoning-only remainders count as empty) | drop the whole turn |
+*
+* Duplicate detection is scoped to the WIRE-VIEW lane: tool_call ids only
+* collide when both instances reach one model request. By default a turn's
+* lane is its raw `runId` — correct for parent/subagent interleaving, where
+* providers minting per-conversation counter ids (`call_0`, `call_1`)
+* legitimately reuse the same id across lanes. Callers that know the run
+* topology (see `createSession`) pass `laneForRun` to widen lanes to true
+* wire views: all depth-0 runs share the main conversation view, and a
+* resumed subagent shares its resume-chain ancestors' view — duplicates
+* across those runIds DO reach a single request (wire-time
+* `ensureToolResultPairing` mode 4 would strip them on every send) and are
+* healed here.
+*
+* Orphan `tool_use` blocks (a call whose result was never persisted —
+* interrupted run) are deliberately KEPT: they are authentic model output,
+* and the wire-time pass patches them with a synthetic result on every send
+* without touching history.
+*
+* Deletions cascade by design: dropping a duplicate `tool_call` orphans its
+* `tool_result`, which is then dropped too; a turn emptied by either is
+* removed entirely.
+*
+* Safe to persist: deterministic, idempotent (re-running on healed output is
+* a no-op returning the same reference), and fabricates nothing.
+*
+* Pure: does not mutate input turns or their content arrays.
 */
-function sanitizeHistoryForProvider(turns, target) {
-	let removed = 0;
-	let stripped = 0;
-	return {
-		turns: turns.map((turn) => {
-			let changed = false;
-			const content = [];
+function dropInvalidToolPairings(turns, options = {}) {
+	if (turns.length === 0) return turns;
+	const onDrop = options.onDrop ?? (() => {});
+	const laneForRun = options.laneForRun ?? ((runId) => runId ?? "");
+	const laneOf = (turn) => laneForRun(turn.runId);
+	const laneKey = (turn, id) => `${laneOf(turn)}\u0000${id}`;
+	const firstSeenAt = /* @__PURE__ */ new Map();
+	for (let i = 0; i < turns.length; i++) {
+		const turn = turns[i];
+		if (turn.role !== "assistant") continue;
+		for (const block of turn.content) if (block.type === "tool_call" && !firstSeenAt.has(laneKey(turn, block.id))) firstSeenAt.set(laneKey(turn, block.id), i);
+	}
+	let changed = false;
+	const out = [];
+	for (let i = 0; i < turns.length; i++) {
+		const turn = turns[i];
+		if (turn.role === "assistant") {
+			const kept = [];
+			const seenHere = /* @__PURE__ */ new Set();
+			let dropped = false;
 			for (const block of turn.content) {
-				if (block.type !== "thinking" && block.type !== "redacted_thinking") {
-					content.push(block);
-					continue;
-				}
-				const action = reasoningWireAction(block, target);
-				if (action === "drop") {
-					removed += 1;
-					changed = true;
-					continue;
-				}
-				if (action === "strip-signature" && block.type === "thinking") {
-					const { signature: _sig, signatureProducer: _producer, ...rest } = block;
-					content.push(rest);
-					stripped += 1;
-					changed = true;
-					continue;
+				if (block.type === "tool_call") {
+					if (firstSeenAt.get(laneKey(turn, block.id)) !== i || seenHere.has(block.id)) {
+						dropped = true;
+						onDrop({
+							kind: "duplicate-tool-call",
+							callId: block.id,
+							index: i
+						});
+						continue;
+					}
+					seenHere.add(block.id);
 				}
-				content.push(block);
+				kept.push(block);
 			}
-			if (!changed) return turn;
-			return {
+			if (!dropped) {
+				out.push(turn);
+				continue;
+			}
+			changed = true;
+			const onlyReasoning = kept.every((b) => b.type === "thinking" || b.type === "redacted_thinking" || b.type === "provider_reasoning");
+			if (kept.length === 0 || onlyReasoning) {
+				onDrop({
+					kind: "empty-turn",
+					index: i
+				});
+				continue;
+			}
+			out.push({
 				...turn,
-				content: content.length > 0 ? content : [{
-					type: "text",
-					text: "[historical reasoning omitted]"
-				}]
-			};
-		}),
-		removed,
-		stripped
-	};
-}
-function toAnthropic(msg) {
-	const nonEmpty = msg.content.filter((b) => {
-		if (b.type === "provider_reasoning") return false;
-		if (b.type !== "thinking" && b.type !== "redacted_thinking") return true;
-		return reasoningWireAction(b, "anthropic") === "keep";
-	}).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: ""
-			}];
+				content: kept
+			});
+			continue;
 		}
-	}).filter((b) => !(b.type === "text" && b.text.length === 0));
-	if (nonEmpty.length === 0) return {
-		role: msg.role,
-		content: ""
-	};
-	const first = nonEmpty[0];
-	if (nonEmpty.length === 1 && first.type === "text") return {
-		role: msg.role,
-		content: first.text
-	};
-	return {
-		role: msg.role,
-		content: nonEmpty
-	};
-}
-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 (turn.role !== "user") {
+			out.push(turn);
+			continue;
+		}
+		const lane = laneOf(turn);
+		let prev = null;
+		for (let j = out.length - 1; j >= 0; j--) {
+			const candidate = out[j];
+			if (candidate.role === "system" || candidate.role === "command") continue;
+			if (laneOf(candidate) !== lane) continue;
+			prev = candidate;
+			break;
+		}
+		const validIds = prev && prev.role === "assistant" ? collectIds(prev.content, "tool_call", (b) => b.id) : /* @__PURE__ */ new Set();
+		const kept = [];
+		const seenCallIds = /* @__PURE__ */ new Set();
+		let dropped = false;
+		for (const block of turn.content) {
+			if (block.type !== "tool_result") {
+				kept.push(block);
+				continue;
 			}
-		};
-	}
-	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 (seenCallIds.has(block.callId)) {
+				dropped = true;
+				onDrop({
+					kind: "duplicate-tool-result",
+					callId: block.callId,
+					index: i
+				});
+				continue;
 			}
-		};
-	}
-	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)
+			seenCallIds.add(block.callId);
+			if (!validIds.has(block.callId)) {
+				dropped = true;
+				onDrop({
+					kind: "orphan-tool-result",
+					callId: block.callId,
+					index: i
+				});
+				continue;
 			}
-		});
-		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)
+			kept.push(block);
+		}
+		if (!dropped) {
+			out.push(turn);
+			continue;
+		}
+		changed = true;
+		if (kept.length === 0) {
+			onDrop({
+				kind: "empty-turn",
+				index: i
 			});
+			continue;
 		}
-		for (const b of textBlocks) parts.push({
-			type: "text",
-			text: b.text
+		out.push({
+			...turn,
+			content: kept
 		});
-		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 changed ? out : turns;
+}
+function syntheticResultBlock(callId) {
 	return {
-		role: msg.role,
-		content: null
+		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;
+}
+//#endregion
+//#region src/session/messages.ts
 /**
-* 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.
+* 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.
 */
-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]";
+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;
+}
 /**
-* 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 |
+* Build an Anthropic `image.source` block, reconciling the declared media
+* type against the actual magic bytes.
 *
-* **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.
+* 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.
 *
-* 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.
+* 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_-]+$`.
 *
-* Idempotent: returns the input reference unchanged when no repairs were
-* necessary. Re-running on already-repaired output is a no-op.
+* 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_-]+$'`).
 *
-* Pure: does not mutate input messages or their content arrays — every
-* repair allocates a fresh array / object.
+* 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.
 */
-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;
+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)}`;
 }
 /**
-* 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.
+* Encode zidane's canonical `string | ToolResultContent[]` shape to Anthropic's
+* wire format for `tool_result.content`.
 */
-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);
+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)
+			};
 		}
-		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
+		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 emitAssistantAfterDedup(args) {
-	const { index, msg, dedupedContent, dedupedChanged, out, fireRepair, markChanged } = args;
-	if (!dedupedChanged) {
-		out.push(msg);
-		return;
+function fromAnthropic(msg) {
+	const role = msg.role;
+	const content = [];
+	if (typeof msg.content === "string") {
+		content.push({
+			type: "text",
+			text: msg.content
+		});
+		return {
+			role,
+			content
+		};
 	}
-	markChanged();
-	if (dedupedContent.length === 0) {
-		out.push({
-			...msg,
-			content: [{
-				type: "text",
-				text: TOOL_USE_INTERRUPTED_MARKER
-			}]
+	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
 		});
-		fireRepair({
-			mode: "empty-assistant-marker",
-			messageIndex: index
+		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;
 	}
-	out.push({
-		...msg,
-		content: dedupedContent
-	});
+	return {
+		role,
+		content
+	};
 }
-/**
-* 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
+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
 			});
-			continue;
 		}
-		seenCallIds.add(block.callId);
-		afterDedup.push(block);
+		return {
+			role,
+			content
+		};
 	}
-	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
+	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 ?? ""
 			});
-			continue;
 		}
-		afterStrip.push(block);
-	}
-	const finalContent = queuedOrphans ? [...queuedOrphans.map(syntheticResultBlock), ...afterStrip] : afterStrip;
-	if (!modifiedHere && queuedOrphans === void 0) {
-		out.push(msg);
-		return;
+		if (typeof tagged.text === "string" && tagged.text) content.push({
+			type: "text",
+			text: tagged.text
+		});
+		return {
+			role,
+			content
+		};
 	}
-	markChanged();
-	if (finalContent.length === 0) {
-		out.push({
-			...msg,
-			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: ORPHANED_TOOL_RESULT_MARKER
-			}]
-		});
-		return;
+				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
+		};
 	}
-	out.push({
-		...msg,
-		content: finalContent
-	});
+	return {
+		role,
+		content
+	};
 }
 /**
-* 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.
+* Single source of truth for whether a signature-bearing reasoning block
+* (`thinking` / `redacted_thinking`) may be forwarded to a provider. Both
+* wire builders ({@link toAnthropic}, the OpenAI assistant-message shaper)
+* and the host-facing {@link sanitizeHistoryForProvider} apply this same
+* policy — keeping them one function means the sanitizer can never drift
+* from what the wire actually sends.
 *
-* 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.
+* Rules, each driven by an API constraint hit in production:
 *
-* 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.
+* - target `anthropic`:
+*   - `redacted_thinking` → keep (native Anthropic block; must be echoed).
+*   - `thinking` tagged `openai` → drop (OpenAI `encrypted_content` is not
+*     a valid Anthropic HMAC; 400s).
+*   - unsigned `thinking` → drop (`ThinkingBlockParam` requires a
+*     signature; unsigned blocks come from non-signing producers).
+*   - signed but UNTAGGED `thinking` (pre-tagging sessions) → keep: it is
+*     most plausibly legacy Anthropic output, and the signature-400
+*     recovery converges if it is not.
 *
-* 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.
+* - target `openai`:
+*   - `redacted_thinking` → drop (Anthropic-only block type).
+*   - `thinking` tagged `anthropic` → drop (an Anthropic HMAC is not
+*     valid `encrypted_content`).
+*   - signed but UNTAGGED `thinking` → strip-signature: unlike the
+*     Anthropic direction there is no signature-error recovery on this
+*     path, so forwarding a possibly-foreign signature risks an
+*     unrecoverable 400 — the reasoning text survives, only the opaque
+*     signature is withheld.
+*/
+function reasoningWireAction(block, target) {
+	if (block.type === "redacted_thinking") return target === "anthropic" ? "keep" : "drop";
+	if (target === "anthropic") {
+		if (block.signatureProducer === "openai") return "drop";
+		if (!block.signature) return "drop";
+		return "keep";
+	}
+	if (block.signatureProducer === "anthropic") return "drop";
+	if (block.signature && block.signatureProducer !== "openai") return "strip-signature";
+	return "keep";
+}
+/**
+* Host-facing history sanitizer — applies {@link reasoningWireAction} to a
+* turn set BEFORE it is handed to an agent targeting `target`. The in-loop
+* wire builders already enforce the same policy per call, so this is for
+* hosts that seed history from an external durable store (or hydrate
+* pre-provenance-tagging sessions) and want the poison removed from their
+* source of truth in one call instead of re-deriving block semantics.
 *
-* Pure: returns the input references unchanged when no id collides.
+* Returns new turn objects only where something changed (unchanged turns
+* pass through by reference). A turn whose content empties keeps the same
+* neutral marker the wire repair uses, so role boundaries stay intact.
 */
-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;
+function sanitizeHistoryForProvider(turns, target) {
+	let removed = 0;
+	let stripped = 0;
+	return {
+		turns: turns.map((turn) => {
+			let changed = false;
+			const content = [];
+			for (const block of turn.content) {
+				if (block.type !== "thinking" && block.type !== "redacted_thinking") {
+					content.push(block);
+					continue;
+				}
+				const action = reasoningWireAction(block, target);
+				if (action === "drop") {
+					removed += 1;
+					changed = true;
+					continue;
+				}
+				if (action === "strip-signature" && block.type === "thinking") {
+					const { signature: _sig, signatureProducer: _producer, ...rest } = block;
+					content.push(rest);
+					stripped += 1;
+					changed = true;
+					continue;
+				}
+				content.push(block);
+			}
+			if (!changed) return turn;
+			return {
+				...turn,
+				content: content.length > 0 ? content : [{
+					type: "text",
+					text: "[historical reasoning omitted]"
+				}]
+			};
+		}),
+		removed,
+		stripped
+	};
+}
+function toAnthropic(msg) {
+	const nonEmpty = msg.content.filter((b) => {
+		if (b.type === "provider_reasoning") return false;
+		if (b.type !== "thinking" && b.type !== "redacted_thinking") return true;
+		return reasoningWireAction(b, "anthropic") === "keep";
+	}).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: ""
+			}];
 		}
-		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
+	}).filter((b) => !(b.type === "text" && b.text.length === 0));
+	if (nonEmpty.length === 0) return {
+		role: msg.role,
+		content: ""
+	};
+	const first = nonEmpty[0];
+	if (nonEmpty.length === 1 && first.type === "text") return {
+		role: msg.role,
+		content: first.text
 	};
 	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
+		role: msg.role,
+		content: nonEmpty
 	};
 }
-/**
-* Drop-only normalization of persisted history: delete structurally invalid
-* tool blocks so the transcript never re-triggers wire-time pairing repairs
-* turn after turn.
-*
-* Unlike {@link ensureToolResultPairing} — which SYNTHESIZES placeholder
-* content and must therefore stay wire-only (fabricated results would poison
-* persisted history and training data) — this pass performs pure deletions of
-* blocks that are provably invalid regardless of interpretation:
-*
-* | Corruption | Action |
-* |------------|--------|
-* | duplicate `tool_call` id within one run lane (across or within turns) | drop the later instance |
-* | duplicate `tool_result.callId` within one turn | drop the later instance |
-* | `tool_result` with no matching `tool_call` in the immediately preceding same-lane assistant turn | drop the block |
-* | turn emptied by the drops above (reasoning-only remainders count as empty) | drop the whole turn |
-*
-* Duplicate detection is scoped to the WIRE-VIEW lane: tool_call ids only
-* collide when both instances reach one model request. By default a turn's
-* lane is its raw `runId` — correct for parent/subagent interleaving, where
-* providers minting per-conversation counter ids (`call_0`, `call_1`)
-* legitimately reuse the same id across lanes. Callers that know the run
-* topology (see `createSession`) pass `laneForRun` to widen lanes to true
-* wire views: all depth-0 runs share the main conversation view, and a
-* resumed subagent shares its resume-chain ancestors' view — duplicates
-* across those runIds DO reach a single request (wire-time
-* `ensureToolResultPairing` mode 4 would strip them on every send) and are
-* healed here.
-*
-* Orphan `tool_use` blocks (a call whose result was never persisted —
-* interrupted run) are deliberately KEPT: they are authentic model output,
-* and the wire-time pass patches them with a synthetic result on every send
-* without touching history.
-*
-* Deletions cascade by design: dropping a duplicate `tool_call` orphans its
-* `tool_result`, which is then dropped too; a turn emptied by either is
-* removed entirely.
-*
-* Safe to persist: deterministic, idempotent (re-running on healed output is
-* a no-op returning the same reference), and fabricates nothing.
-*
-* Pure: does not mutate input turns or their content arrays.
-*/
-function dropInvalidToolPairings(turns, options = {}) {
-	if (turns.length === 0) return turns;
-	const onDrop = options.onDrop ?? (() => {});
-	const laneForRun = options.laneForRun ?? ((runId) => runId ?? "");
-	const laneOf = (turn) => laneForRun(turn.runId);
-	const laneKey = (turn, id) => `${laneOf(turn)}\u0000${id}`;
-	const firstSeenAt = /* @__PURE__ */ new Map();
-	for (let i = 0; i < turns.length; i++) {
-		const turn = turns[i];
-		if (turn.role !== "assistant") continue;
-		for (const block of turn.content) if (block.type === "tool_call" && !firstSeenAt.has(laneKey(turn, block.id))) firstSeenAt.set(laneKey(turn, block.id), i);
+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 } : {}
+			}
+		};
 	}
-	let changed = false;
-	const out = [];
-	for (let i = 0; i < turns.length; i++) {
-		const turn = turns[i];
-		if (turn.role === "assistant") {
-			const kept = [];
-			const seenHere = /* @__PURE__ */ new Set();
-			let dropped = false;
-			for (const block of turn.content) {
-				if (block.type === "tool_call") {
-					if (firstSeenAt.get(laneKey(turn, block.id)) !== i || seenHere.has(block.id)) {
-						dropped = true;
-						onDrop({
-							kind: "duplicate-tool-call",
-							callId: block.id,
-							index: i
-						});
-						continue;
+	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)
 					}
-					seenHere.add(block.id);
-				}
-				kept.push(block);
-			}
-			if (!dropped) {
-				out.push(turn);
-				continue;
-			}
-			changed = true;
-			const onlyReasoning = kept.every((b) => b.type === "thinking" || b.type === "redacted_thinking" || b.type === "provider_reasoning");
-			if (kept.length === 0 || onlyReasoning) {
-				onDrop({
-					kind: "empty-turn",
-					index: i
-				});
-				continue;
+				}))
 			}
-			out.push({
-				...turn,
-				content: kept
+		};
+	}
+	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}` }
 			});
-			continue;
-		}
-		if (turn.role !== "user") {
-			out.push(turn);
-			continue;
-		}
-		const lane = laneOf(turn);
-		let prev = null;
-		for (let j = out.length - 1; j >= 0; j--) {
-			const candidate = out[j];
-			if (candidate.role === "system" || candidate.role === "command") continue;
-			if (laneOf(candidate) !== lane) continue;
-			prev = candidate;
-			break;
 		}
-		const validIds = prev && prev.role === "assistant" ? collectIds(prev.content, "tool_call", (b) => b.id) : /* @__PURE__ */ new Set();
-		const kept = [];
-		const seenCallIds = /* @__PURE__ */ new Set();
-		let dropped = false;
-		for (const block of turn.content) {
-			if (block.type !== "tool_result") {
-				kept.push(block);
-				continue;
-			}
-			if (seenCallIds.has(block.callId)) {
-				dropped = true;
-				onDrop({
-					kind: "duplicate-tool-result",
-					callId: block.callId,
-					index: i
-				});
-				continue;
-			}
-			seenCallIds.add(block.callId);
-			if (!validIds.has(block.callId)) {
-				dropped = true;
-				onDrop({
-					kind: "orphan-tool-result",
-					callId: block.callId,
-					index: i
-				});
-				continue;
+		for (const b of audioBlocks) parts.push({
+			type: "input_audio",
+			input_audio: {
+				data: b.data,
+				format: audioFormatFromMediaType(b.mediaType)
 			}
-			kept.push(block);
-		}
-		if (!dropped) {
-			out.push(turn);
-			continue;
-		}
-		changed = true;
-		if (kept.length === 0) {
-			onDrop({
-				kind: "empty-turn",
-				index: i
+		});
+		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)
 			});
-			continue;
 		}
-		out.push({
-			...turn,
-			content: kept
+		for (const b of textBlocks) parts.push({
+			type: "text",
+			text: b.text
 		});
+		return {
+			role: msg.role,
+			content: parts
+		};
 	}
-	return changed ? out : turns;
-}
-function syntheticResultBlock(callId) {
+	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 {
-		type: "tool_result",
-		callId,
-		output: SYNTHETIC_TOOL_RESULT_PLACEHOLDER,
-		isError: true
+		role: msg.role,
+		content: null
 	};
 }
-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).
@@ -1405,6 +1408,6 @@ function autoDetectAndConvert(msg) {
 	return fromAnthropic(msg);
 }
 //#endregion
-export { toOpenAI as _, detectTurnInterruption as a, ensureToolResultPairing as c, fromOpenAI as d, reasoningWireAction as f, toAnthropic as g, sanitizeHistoryForProvider as h, autoDetectAndConvert as i, filterUnresolvedToolUses as l, resolveContentRefsInMessages as m, SYNTHETIC_TOOL_RESULT_PLACEHOLDER as n, dropInvalidToolPairings as o, remintDuplicateToolCallIds as p, TOOL_USE_INTERRUPTED_MARKER as r, ensureEndsWithUserMessage as s, ORPHANED_TOOL_RESULT_MARKER as t, fromAnthropic as u, toWireMessages as v };
+export { ensureToolResultPairing as _, fromAnthropic as a, resolveContentRefsInMessages as c, toOpenAI as d, toWireMessages as f, dropInvalidToolPairings as g, TOOL_USE_INTERRUPTED_MARKER as h, filterUnresolvedToolUses as i, sanitizeHistoryForProvider as l, SYNTHETIC_TOOL_RESULT_PLACEHOLDER as m, detectTurnInterruption as n, fromOpenAI as o, ORPHANED_TOOL_RESULT_MARKER as p, ensureEndsWithUserMessage as r, reasoningWireAction as s, autoDetectAndConvert as t, toAnthropic as u, remintDuplicateToolCallIds as v };
 
-//# sourceMappingURL=messages-2jcOA_5R.js.map
+//# sourceMappingURL=messages-BqiwcD2Q.js.map