zidane 5.13.26 → 5.14.0

package/dist/{messages-Iy_vEycX.js → openai-compat-0Y7jcncn.js}

@@ -1,9 +1,8 @@
-import { t as fnv1aBase36 } from "./hash-DJRzmcPI.js";
-import { n as estimateTokens } from "./utils-ngQzYzZD.js";
 import { i as documentBlockMarker, n as assertResolvedMediaBlock } from "./types-CyVGdbia.js";
+import { n as estimateTokens } from "./utils-ngQzYzZD.js";
 import { c as classifyErrorPrelude, d as isRetryableHttpStatus, f as matchesContextExceeded, l as errorMessage, p as matchesToolPairingError } from "./errors-DJUxZg9b.js";
-import { n as reconcileImageMediaType, t as audioFormatFromMediaType } from "./media-sniff-Bn76JxAu.js";
-import { getModel } from "@earendil-works/pi-ai";
+import { renderSystemForWire, splitSystemPrompt } from "./prompt.js";
+import { t as audioFormatFromMediaType } from "./media-sniff-Bn76JxAu.js";
 //#region src/prompt.ts
 /**
 * Coerce the run-level prompt into a `PromptPart[]`.
@@ -123,214 +122,12 @@ function buildPromptMessage(provider, parts) {
 	return defaultPromptMessage(parts);
 }
 //#endregion
-//#region src/system-prompt.ts
-/**
-* System-prompt boundary marker — splits a system prompt into a stable static
-* prefix (cached) and a per-turn dynamic suffix (NOT cached).
-*
-* Why this exists: providers attach `cache_control` markers on the last block
-* of the system prompt, so the cached prefix covers the entire system text.
-* Any byte change anywhere — including a per-turn `<env>` rewrite — busts the
-* cache for the doctrine that sits below. A literal marker in the system
-* string lets providers split it into:
-*
-*   ┌──────────────┐ cache_control: ephemeral
-*   │ STATIC half  │  — doctrine, skills catalog, tool catalog,
-*   │              │    user instructions
-*   ├──────────────┤  ← SYSTEM_PROMPT_BOUNDARY
-*   │ DYNAMIC half │  — env, cwd, mtimes, anything per-turn
-*   └──────────────┘ (no cache_control)
-*
-* The static prefix rides the prompt cache across turns/sessions; the dynamic
-* suffix re-bills per turn. Net effect: a cwd change between turns no longer
-* invalidates 4 KB of doctrine.
-*
-* Wire contract:
-*
-* - `splitSystemPrompt(s)` is pure; missing marker ⇒ entire string is static
-*   (current behavior — no caller is forced to opt in).
-* - `renderSystemForWire(s)` strips the marker so it never reaches the model;
-*   used by every provider before the bytes hit the wire, including the
-*   cache-disabled path on providers that DO support `cache_control`.
-* - The marker uses underscores rather than XML/punctuation so it's
-*   unambiguous when scanning prompts manually and unlikely to collide with
-*   model-written content.
-* - Providers handle the split internally (Anthropic emits a 2-block array;
-*   OpenAI-compat splits the leading `system` message into multi-part text).
-*   Callers always pass a single `string` — no API break.
-*/
-/**
-* Literal marker inserted in a system prompt to separate cacheable doctrine
-* from per-turn dynamic content. Providers split on this token.
-*
-* Underscored on both sides for visual distinctiveness — a stray instance in
-* model-written prose is implausible. Don't change the value without shipping
-* a migration; existing sessions carry the old marker in their cached
-* prompts.
-*/
-const SYSTEM_PROMPT_BOUNDARY = "__ZIDANE_SYSTEM_PROMPT_BOUNDARY__";
-/**
-* Split a system prompt around the first {@link SYSTEM_PROMPT_BOUNDARY}.
-*
-* Splits on the FIRST occurrence — subsequent markers are folded into the
-* dynamic half. This way callers can append additional `<env>` style blocks
-* with extra markers without each one creating a new cache layer (Anthropic
-* caps breakpoints; we use the budget elsewhere). The marker itself is
-* stripped from both sides — providers attach `cache_control` directly to
-* the static half's text content.
-*
-* A single blank line (`\n\n`) immediately adjacent to the marker on each
-* side is trimmed — callers conventionally write
-* `<doctrine>\n\n<MARKER>\n\n<env>` and expect the rendered wire bytes to
-* read as one logical paragraph. Blank lines beyond that immediate pair
-* (e.g. `\n\n\n<env>`) are preserved verbatim so callers composing their
-* own spacing don't lose intentional gaps.
-*
-* Pure / no I/O / no allocation when the marker is absent (returns the input
-* verbatim on the static side and the empty string on the dynamic side).
-*/
-function splitSystemPrompt(system) {
-	if (system.length === 0) return {
-		static: "",
-		dynamic: ""
-	};
-	const idx = system.indexOf(SYSTEM_PROMPT_BOUNDARY);
-	if (idx < 0) return {
-		static: system,
-		dynamic: ""
-	};
-	const staticPart = system.slice(0, idx);
-	const dynamicPart = system.slice(idx + 33);
-	return {
-		static: trimTrailingBlankLine(staticPart),
-		dynamic: trimLeadingBlankLine(dynamicPart)
-	};
-}
-/**
-* Compose a system prompt from a static prefix and an optional dynamic
-* suffix. Inserts {@link SYSTEM_PROMPT_BOUNDARY} between them only when the
-* dynamic side is non-empty — single-block prompts stay marker-free, so
-* callers that never opt in pay zero overhead and providers fall back to the
-* existing whole-string caching path.
-*
-* Spacing is `\n\n` on both sides of the marker so doctrine fragments,
-* which conventionally separate sections with a blank line, read cleanly
-* around the boundary.
-*/
-function joinSystemPrompt(staticPart, dynamicPart) {
-	if (dynamicPart.length === 0) return staticPart;
-	if (staticPart.length === 0) return `${SYSTEM_PROMPT_BOUNDARY}\n\n${dynamicPart}`;
-	return `${staticPart}\n\n${SYSTEM_PROMPT_BOUNDARY}\n\n${dynamicPart}`;
-}
-/**
-* Append `extra` to the STATIC half of a system prompt, preserving any
-* existing dynamic suffix.
-*
-* Used by the agent to fold in run-stable content (skills catalog, lazy tool
-* catalog) without bumping it into the dynamic half — both catalogs are
-* built once per run and remain byte-stable for the duration, so they
-* belong in the cached prefix.
-*
-* Returns a new string; the input is not mutated. When `extra` is empty,
-* returns the input verbatim.
-*/
-function appendStaticSection(system, extra) {
-	if (extra.length === 0) return system;
-	const { static: staticPart, dynamic } = splitSystemPrompt(system);
-	return joinSystemPrompt(staticPart.length === 0 ? extra : `${staticPart}\n\n${extra}`, dynamic);
-}
-/**
-* Append `extra` to the DYNAMIC half of a system prompt. Inserts the boundary
-* marker if the input didn't already carry one.
-*
-* Used by hosts (typically the TUI) to inject per-turn state — current cwd,
-* IDE selection, project root — without forcing every caller to know the
-* marker format. The host's `system:transform` hook rewrites the dynamic
-* half each turn; the static doctrine above stays byte-stable and rides the
-* cache.
-*
-* Returns a new string; the input is not mutated. When `extra` is empty,
-* returns the input verbatim.
-*/
-function appendDynamicSection(system, extra) {
-	if (extra.length === 0) return system;
-	const { static: staticPart, dynamic } = splitSystemPrompt(system);
-	return joinSystemPrompt(staticPart, dynamic.length === 0 ? extra : `${dynamic}\n\n${extra}`);
-}
-/**
-* Replace the entire dynamic half of a system prompt with `next`. Used by
-* the TUI's `<env>` rewriter where the entire dynamic section is regenerated
-* each turn rather than appended to.
-*
-* When `next` is empty, drops the dynamic half (and the marker) entirely.
-*/
-function replaceDynamicSection(system, next) {
-	const { static: staticPart } = splitSystemPrompt(system);
-	return joinSystemPrompt(staticPart, next);
-}
-/**
-* Strip the boundary marker so it never reaches the wire — collapses
-* `<static>${BOUNDARY}<dynamic>` into `<static>\n\n<dynamic>` for providers
-* that can't honor `cache_control` (vanilla OpenAI Chat Completions, Codex,
-* Cerebras, ...) or for the cache-disabled path on any provider.
-*
-* Cache-aware providers re-derive the split from the original (un-rendered)
-* system string via `splitSystemPrompt` — `renderSystemForWire` is the
-* marker-free counterpart used to build the actual wire bytes.
-*
-* No-op when the input has no marker. Pure / no I/O.
-*/
-function renderSystemForWire(system) {
-	if (system.length === 0) return system;
-	const parts = splitSystemPrompt(system);
-	if (parts.dynamic.length === 0) return parts.static;
-	if (parts.static.length === 0) return parts.dynamic;
-	return `${parts.static}\n\n${parts.dynamic}`;
-}
-/** True when `system` contains the boundary marker. */
-function hasSystemPromptBoundary(system) {
-	return system.includes(SYSTEM_PROMPT_BOUNDARY);
-}
-/** Strip a single trailing `\n\n` (and any leftover trailing whitespace within that pair). */
-function trimTrailingBlankLine(s) {
-	let end = s.length;
-	let newlines = 0;
-	while (end > 0 && newlines < 2) {
-		const ch = s.charCodeAt(end - 1);
-		if (ch === 10) {
-			newlines += 1;
-			end -= 1;
-			continue;
-		}
-		if (ch === 32 || ch === 9) {
-			end -= 1;
-			continue;
-		}
-		break;
-	}
-	return newlines > 0 ? s.slice(0, end) : s;
-}
-/** Strip a single leading `\n\n` (and any leftover leading whitespace within that pair). */
-function trimLeadingBlankLine(s) {
-	let start = 0;
-	let newlines = 0;
-	while (start < s.length && newlines < 2) {
-		const ch = s.charCodeAt(start);
-		if (ch === 10) {
-			newlines += 1;
-			start += 1;
-			continue;
-		}
-		if (ch === 32 || ch === 9) {
-			start += 1;
-			continue;
-		}
-		break;
-	}
-	return newlines > 0 ? s.slice(start) : s;
-}
-//#endregion
 //#region src/providers/cost.ts
+let getModelPromise;
+function loadGetModel() {
+	getModelPromise ??= import("@earendil-works/pi-ai").then((mod) => mod.getModel).catch(() => null);
+	return getModelPromise;
+}
 /**
 * Per-MTok rates for models not yet in pi-ai's bundled registry. Keyed by
 * `provider:modelId`. Consulted only when pi-ai's `getModel` misses, so a
@@ -412,13 +209,13 @@ const EXTRA_COST_RATES = {
 * will drift until the dep updates. An optional `multiplier` scales the
 * base rates for premium modes (e.g. fast mode) before totaling.
 */
-function fillEstimatedCost(usage, provider, multiplier) {
+async function fillEstimatedCost(usage, provider, multiplier) {
 	if (usage.cost !== void 0) return usage;
 	if (!usage.modelId) return usage;
-	const lookup = getModel;
+	const getModel = await loadGetModel();
 	let model;
-	try {
-		model = lookup(provider, usage.modelId);
+	if (getModel) try {
+		model = getModel(provider, usage.modelId);
 	} catch {
 		model = void 0;
 	}
@@ -995,7 +792,7 @@ function toVideoUrlPart(video) {
 		video_url: { url: `data:${video.mediaType};base64,${video.data}` }
 	};
 }
-function documentMarker$1(doc) {
+function documentMarker(doc) {
 	return documentBlockMarker(doc, "document omitted");
 }
 /**
@@ -1072,7 +869,7 @@ function summarizeToolResultOutput(output, documentsEnabled = false) {
 		});
 	} else if (block.type === "document") {
 		assertResolvedMediaBlock(block, "OpenAI-compatible wire messages");
-		texts.push(documentMarker$1(block));
+		texts.push(documentMarker(block));
 	}
 	return {
 		text: texts.join("\n"),
@@ -1245,7 +1042,7 @@ function toOAIMessages(system, messages, options = {}) {
 				if (documentsEnabled && isForwardableDocument(b)) parts.push(toFilePart(b));
 				else parts.push({
 					type: "text",
-					text: documentMarker$1(b)
+					text: documentMarker(b)
 				});
 			}
 			for (const b of textBlocks) parts.push({
@@ -1791,1175 +1588,26 @@ function openaiCompat(params) {
 					model: modelId
 				};
 			}
+			const filledUsage = await fillEstimatedCost({
+				input: usage.input,
+				output: usage.output,
+				...usage.cacheRead !== void 0 ? { cacheRead: usage.cacheRead } : {},
+				...usage.cacheCreation !== void 0 ? { cacheCreation: usage.cacheCreation } : {},
+				...usage.cost !== void 0 ? { cost: usage.cost } : {},
+				...finishReason ? { finishReason } : {},
+				modelId
+			}, name);
 			return {
 				assistantMessage: buildAssistantContent(result.text, result.toolCalls, thinkingForBlock, reasoningArg),
 				text: result.text,
 				toolCalls: result.toolCalls,
 				done: result.toolCalls.length === 0,
-				usage: fillEstimatedCost({
-					input: usage.input,
-					output: usage.output,
-					...usage.cacheRead !== void 0 ? { cacheRead: usage.cacheRead } : {},
-					...usage.cacheCreation !== void 0 ? { cacheCreation: usage.cacheCreation } : {},
-					...usage.cost !== void 0 ? { cost: usage.cost } : {},
-					...finishReason ? { finishReason } : {},
-					modelId
-				}, name)
+				usage: filledUsage
 			};
 		}
 	};
 }
 //#endregion
-//#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 { joinSystemPrompt as A, sanitizeToolSchema as C, appendDynamicSection as D, SYSTEM_PROMPT_BOUNDARY as E, canonicalizePrompt as F, defaultPromptMessage as I, unsupportedMediaError as L, replaceDynamicSection as M, splitSystemPrompt as N, appendStaticSection as O, buildPromptMessage as P, userMessage as S, fillEstimatedCost as T, assistantMessage as _, detectTurnInterruption as a, openaiCompat as b, filterUnresolvedToolUses as c, remintDuplicateToolCallIds as d, resolveContentRefsInMessages as f, OpenAICompatHttpError as g, toWireMessages as h, autoDetectAndConvert as i, renderSystemForWire as j, hasSystemPromptBoundary as k, 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, classifyOpenAICompatError as v, sanitizeToolSpecs as w, toolResultsMessage as x, mapOAIFinishReason as y };
+export { defaultPromptMessage as C, canonicalizePrompt as S, userMessage as _, applyOAICacheBreakpoints as a, fillEstimatedCost as b, buildAssistantContent as c, formatTools as d, mapOAIFinishReason as f, toolResultsMessage as g, toOAIMessages as h, TOOL_RESULTS_TAG as i, classifyOpenAICompatError as l, openaiCompat as m, OpenAICompatHttpError as n, applyOAIToolCacheBreakpoint as o, openAICompatPromptMessage as p, OpenAICompatStreamError as r, assistantMessage as s, ASSISTANT_TOOL_CALLS_TAG as t, consumeSSE as u, sanitizeToolSchema as v, unsupportedMediaError as w, buildPromptMessage as x, sanitizeToolSpecs as y };
 
-//# sourceMappingURL=messages-Iy_vEycX.js.map
+//# sourceMappingURL=openai-compat-0Y7jcncn.js.map