zidane 5.11.2 → 5.12.1

package/dist/{messages-RPKrEPvH.js → messages-9wyCuvLF.js}

@@ -1,8 +1,127 @@
 import { n as estimateTokens } from "./utils-ngQzYzZD.js";
-import { c as classifyErrorPrelude, d as matchesContextExceeded, f as matchesToolPairingError, l as errorMessage, u as isRetryableHttpStatus } from "./errors-DkR6GPJw.js";
-import { n as documentBlockMarker } from "./types-BiobHM1D.js";
-import { t as reconcileImageMediaType } from "./image-sniff-B7uFSNO1.js";
+import { c as classifyErrorPrelude, d as isRetryableHttpStatus, f as matchesContextExceeded, l as errorMessage, p as matchesToolPairingError } from "./errors-BpPfMo_4.js";
+import { n as reconcileImageMediaType, t as audioFormatFromMediaType } from "./media-sniff-Bn76JxAu.js";
+import { n as assertResolvedMediaBlock, r as documentBlockMarker } from "./types-DxHDaqN7.js";
 import { getModel } from "@earendil-works/pi-ai";
+//#region src/prompt.ts
+/**
+* Coerce the run-level prompt into a `PromptPart[]`.
+*
+* - `string` prompt → a single `text` part. Empty string returns `undefined`
+*   so callers skip pushing an empty user turn.
+* - `PromptPart[]` prompt → validated and returned as-is. An empty array, or
+*   an array whose text parts are all empty with no image/document parts,
+*   returns `undefined`.
+* - `undefined` → `undefined` (promptless resume path).
+*/
+function canonicalizePrompt(prompt) {
+	if (prompt === void 0) return void 0;
+	if (typeof prompt === "string") {
+		if (prompt.length === 0) return void 0;
+		return [{
+			type: "text",
+			text: prompt
+		}];
+	}
+	if (prompt.length === 0) return void 0;
+	for (const part of prompt) {
+		if (!part || typeof part !== "object" || typeof part.type !== "string") throw new Error("Invalid PromptPart: each part must be an object with a `type` field.");
+		const type = part.type;
+		if (type !== "text" && type !== "image" && type !== "audio" && type !== "video" && type !== "document") throw new Error(`Invalid PromptPart type "${type}". Expected "text" | "image" | "audio" | "video" | "document".`);
+	}
+	if (!prompt.some((part) => part.type === "text" && part.text.length > 0 || part.type === "image" || part.type === "audio" || part.type === "video" || part.type === "document")) return void 0;
+	return prompt;
+}
+/**
+* Standard error for a media kind the active provider/model can't accept.
+*
+* Per the audio/video design, unsupported media is a hard error (not a silent
+* marker) so the caller switches to a capable model rather than paying for a
+* request the provider would 400 — or worse, one that succeeds with the bytes
+* stripped and the model confabulating over what it can't see.
+*/
+function unsupportedMediaError(kind, provider) {
+	return /* @__PURE__ */ new Error(`Provider "${provider}" does not support ${kind} input. Route to a ${kind}-capable model (e.g. an OpenAI-compat / OpenRouter model with capabilities.${kind} = true) to send ${kind} attachments.`);
+}
+/**
+* Build a user `SessionMessage` from prompt parts without provider-specific handling.
+*
+* - `text` parts map to `{ type: 'text', text }` blocks.
+* - `image` parts map to `{ type: 'image', mediaType, data }` blocks.
+* - `audio` / `video` parts map to their canonical blocks verbatim. Providers
+*   that cannot accept them throw later (in `promptMessage` / loop gating); the
+*   default builder stays lossless so capable providers receive the bytes.
+* - `document` parts with `encoding: 'text'` are inlined as an attachment-tagged
+*   text block so every provider can read them.
+* - `document` parts with `encoding: 'base64'` throw — the caller should switch
+*   to a provider that implements `promptMessage` (e.g. Anthropic for PDFs).
+*/
+function defaultPromptMessage(parts) {
+	const content = [];
+	for (const part of parts) {
+		if (part.type === "text") {
+			if (part.text.length > 0) content.push({
+				type: "text",
+				text: part.text
+			});
+			continue;
+		}
+		if (part.type === "image") {
+			content.push({
+				type: "image",
+				mediaType: part.mediaType,
+				data: part.data,
+				...part.name ? { name: part.name } : {}
+			});
+			continue;
+		}
+		if (part.type === "audio") {
+			content.push({
+				type: "audio",
+				mediaType: part.mediaType,
+				data: part.data,
+				...part.name ? { name: part.name } : {}
+			});
+			continue;
+		}
+		if (part.type === "video") {
+			content.push({
+				type: "video",
+				mediaType: part.mediaType,
+				data: part.data,
+				...part.name ? { name: part.name } : {}
+			});
+			continue;
+		}
+		if (part.encoding === "text") {
+			const header = part.name ? `<attachment name="${part.name}" media_type="${part.mediaType}">` : `<attachment media_type="${part.mediaType}">`;
+			content.push({
+				type: "text",
+				text: `${header}\n${part.data}\n</attachment>`
+			});
+			continue;
+		}
+		throw new Error(`Provider does not support base64 document parts (mediaType: ${part.mediaType}). Use a text-encoded document or a provider that implements promptMessage (e.g. Anthropic).`);
+	}
+	return {
+		role: "user",
+		content
+	};
+}
+/**
+* Build the prompt `SessionMessage` for a given provider.
+*
+* Prefers `provider.promptMessage` when defined, falling back to `defaultPromptMessage`.
+*/
+function buildPromptMessage(provider, parts) {
+	for (const part of parts) {
+		if (part.type === "audio" && provider.meta.capabilities?.audio !== true) throw unsupportedMediaError("audio", provider.name);
+		if (part.type === "video" && provider.meta.capabilities?.video !== true) throw unsupportedMediaError("video", provider.name);
+	}
+	if (provider.promptMessage) return provider.promptMessage(parts);
+	return defaultPromptMessage(parts);
+}
+//#endregion
 //#region src/system-prompt.ts
 /**
 * System-prompt boundary marker — splits a system prompt into a stable static
@@ -814,10 +933,63 @@ function toImageUrlPart(img) {
 		image_url: { url: `data:${img.mediaType};base64,${img.data}` }
 	};
 }
+/**
+* Encode an audio block as an OpenAI-compat `input_audio` part. The `data` is
+* RAW base64 with NO data-URI prefix (unlike images), per the spec.
+*/
+function toInputAudioPart(audio) {
+	return {
+		type: "input_audio",
+		input_audio: {
+			data: audio.data,
+			format: audioFormatFromMediaType(audio.mediaType)
+		}
+	};
+}
+/**
+* Encode a video block as an OpenAI-compat `video_url` part. Uses the same
+* base64 data-URL shape as images. Only emitted on video-capable routes
+* (currently Gemini via OpenRouter).
+*/
+function toVideoUrlPart(video) {
+	return {
+		type: "video_url",
+		video_url: { url: `data:${video.mediaType};base64,${video.data}` }
+	};
+}
 function documentMarker$1(doc) {
 	return documentBlockMarker(doc, "document omitted");
 }
 /**
+* Whether a document block can be forwarded natively to OpenAI's `file` content
+* part. Only base64-encoded files qualify (the `file_data` data-URL shape);
+* text-encoded documents are already inlined as attachment text upstream and
+* have no portable binary representation.
+*/
+function isForwardableDocument(doc) {
+	return doc.encoding === "base64";
+}
+/**
+* Encode a base64 document as an OpenAI-compat `file` content part:
+* `{ type: 'file', file: { filename, file_data: 'data:<mime>;base64,<data>' } }`.
+*
+* Supported by OpenAI (Chat Completions + Responses) and routes that proxy it
+* (e.g. OpenRouter → OpenAI/Gemini/Anthropic). Gated behind `capabilities.documents`.
+*/
+function toFilePart(doc) {
+	return {
+		type: "file",
+		file: {
+			filename: doc.name ?? `file.${doc.mediaType.split("/")[1] ?? "bin"}`,
+			file_data: `data:${doc.mediaType};base64,${doc.data}`
+		}
+	};
+}
+/** True when any built OAI message carries a `{ type: 'file' }` content part. */
+function messagesContainFilePart(messages) {
+	return messages.some((m) => Array.isArray(m.content) && m.content.some((p) => typeof p === "object" && p !== null && p.type === "file"));
+}
+/**
 * Summarize a `tool_result` output for the companion-user-message path — text blocks
 * are joined (separated by `\n`) so the tool message carries all textual context; image
 * blocks are collected in a flat list for the companion user message.
@@ -825,22 +997,51 @@ function documentMarker$1(doc) {
 * Used only on the fallback path; the native path walks `output` in-order to preserve
 * text↔image interleaving.
 */
-function summarizeToolResultOutput(output) {
+function summarizeToolResultOutput(output, documentsEnabled = false) {
 	if (typeof output === "string") return {
 		text: output,
-		images: []
+		images: [],
+		audios: [],
+		videos: [],
+		documents: []
 	};
 	const texts = [];
 	const images = [];
+	const audios = [];
+	const videos = [];
+	const documents = [];
 	for (const block of output) if (block.type === "text") texts.push(block.text);
-	else if (block.type === "image") images.push({
+	else if (block.type === "image") {
+		assertResolvedMediaBlock(block, "OpenAI-compatible wire messages");
+		images.push({
+			mediaType: block.mediaType,
+			data: block.data
+		});
+	} else if (block.type === "audio") audios.push({
+		mediaType: block.mediaType,
+		data: block.data
+	});
+	else if (block.type === "video") videos.push({
 		mediaType: block.mediaType,
 		data: block.data
 	});
-	else if (block.type === "document") texts.push(documentMarker$1(block));
+	else if (block.type === "document" && documentsEnabled && isForwardableDocument(block)) {
+		assertResolvedMediaBlock(block, "OpenAI-compatible wire messages");
+		documents.push({
+			mediaType: block.mediaType,
+			data: block.data,
+			...block.name ? { name: block.name } : {}
+		});
+	} else if (block.type === "document") {
+		assertResolvedMediaBlock(block, "OpenAI-compatible wire messages");
+		texts.push(documentMarker$1(block));
+	}
 	return {
 		text: texts.join("\n"),
-		images
+		images,
+		audios,
+		videos,
+		documents
 	};
 }
 function toOAIMessages(system, messages, options = {}) {
@@ -849,6 +1050,9 @@ function toOAIMessages(system, messages, options = {}) {
 		content: renderSystemForWire(system)
 	}];
 	const nativeImageInTool = options.imageInToolResult === true;
+	const audioEnabled = options.audio === true;
+	const videoEnabled = options.video === true;
+	const documentsEnabled = options.documents === true;
 	const reasoningEnabled = options.supportsReasoning === true;
 	const reasoningMode = options.reasoningMode ?? "openrouter";
 	const reasoningContentField = options.reasoningContentField ?? "reasoning";
@@ -860,6 +1064,8 @@ function toOAIMessages(system, messages, options = {}) {
 		const toolCalls = [];
 		const textBlocks = [];
 		const imageBlocks = [];
+		const audioBlocks = [];
+		const videoBlocks = [];
 		const documentBlocks = [];
 		const reasoningBlocks = [];
 		for (const b of msg.content) switch (b.type) {
@@ -875,6 +1081,12 @@ function toOAIMessages(system, messages, options = {}) {
 			case "image":
 				imageBlocks.push(b);
 				break;
+			case "audio":
+				audioBlocks.push(b);
+				break;
+			case "video":
+				videoBlocks.push(b);
+				break;
 			case "document":
 				documentBlocks.push(b);
 				break;
@@ -884,6 +1096,8 @@ function toOAIMessages(system, messages, options = {}) {
 		}
 		const reasoningDetails = reasoningBlocks.flatMap((b) => b.producer === "openrouter" ? b.details : []);
 		const reasoningText = reasoningMode === "reasoning_content" ? reasoningBlocks.map((b) => b.producer === "vllm" ? b.reasoningText : "").filter(Boolean).join("") : "";
+		if (audioBlocks.length > 0 && !audioEnabled) throw unsupportedMediaError("audio", "openai-compat");
+		if (videoBlocks.length > 0 && !videoEnabled) throw unsupportedMediaError("video", "openai-compat");
 		if (toolResults.length > 0) {
 			for (const tr of toolResults) {
 				if (typeof tr.output === "string") {
@@ -894,13 +1108,21 @@ function toOAIMessages(system, messages, options = {}) {
 					});
 					continue;
 				}
-				if (nativeImageInTool) {
-					const parts = tr.output.map((block) => block.type === "image" ? toImageUrlPart({
-						mediaType: block.mediaType,
-						data: block.data
-					}) : {
-						type: "text",
-						text: block.type === "document" ? documentMarker$1(block) : block.text
+				const imageToolParts = tr.output;
+				const hasNonImageMedia = tr.output.some((block) => block.type === "audio" || block.type === "video" || block.type === "document");
+				if (nativeImageInTool && !hasNonImageMedia) {
+					const parts = imageToolParts.map((block) => {
+						if (block.type === "image") {
+							assertResolvedMediaBlock(block, "OpenAI-compatible wire messages");
+							return toImageUrlPart({
+								mediaType: block.mediaType,
+								data: block.data
+							});
+						}
+						return {
+							type: "text",
+							text: block.text
+						};
 					});
 					out.push({
 						role: "tool",
@@ -909,8 +1131,11 @@ function toOAIMessages(system, messages, options = {}) {
 					});
 					continue;
 				}
-				const { text, images } = summarizeToolResultOutput(tr.output);
-				if (images.length === 0) {
+				const { text, images, audios, videos, documents } = summarizeToolResultOutput(tr.output, documentsEnabled);
+				if (audios.length > 0 && !audioEnabled) throw unsupportedMediaError("audio", "openai-compat");
+				if (videos.length > 0 && !videoEnabled) throw unsupportedMediaError("video", "openai-compat");
+				const mediaCount = images.length + audios.length + videos.length + documents.length;
+				if (mediaCount === 0) {
 					out.push({
 						role: "tool",
 						tool_call_id: tr.callId,
@@ -918,8 +1143,8 @@ function toOAIMessages(system, messages, options = {}) {
 					});
 					continue;
 				}
-				const noun = images.length === 1 ? "image" : "images";
-				const attachedMarker = `[${images.length} ${noun} attached — see next user message]`;
+				const noun = audios.length === 0 && videos.length === 0 && documents.length === 0 ? mediaCount === 1 ? "image" : "images" : mediaCount === 1 ? "attachment" : "attachments";
+				const attachedMarker = `[${mediaCount} ${noun} attached — see next user message]`;
 				const toolMarker = text.length > 0 ? `${text}\n\n${attachedMarker}` : attachedMarker;
 				out.push({
 					role: "tool",
@@ -928,13 +1153,19 @@ function toOAIMessages(system, messages, options = {}) {
 				});
 				out.push({
 					role: "user",
-					content: [...images.map(toImageUrlPart), {
-						type: "text",
-						text: `(${noun} returned by tool call ${tr.callId})`
-					}]
+					content: [
+						...images.map(toImageUrlPart),
+						...audios.map(toInputAudioPart),
+						...videos.map(toVideoUrlPart),
+						...documents.map(toFilePart),
+						{
+							type: "text",
+							text: `(${noun} returned by tool call ${tr.callId})`
+						}
+					]
 				});
 			}
-			if (textBlocks.length === 0 && imageBlocks.length === 0 && documentBlocks.length === 0) continue;
+			if (textBlocks.length === 0 && imageBlocks.length === 0 && audioBlocks.length === 0 && videoBlocks.length === 0 && documentBlocks.length === 0) continue;
 		}
 		if (toolCalls.length > 0) {
 			const m = {
@@ -954,15 +1185,31 @@ function toOAIMessages(system, messages, options = {}) {
 			out.push(m);
 			continue;
 		}
-		if (imageBlocks.length > 0 || documentBlocks.length > 0) {
-			const parts = imageBlocks.map((img) => ({
-				type: "image_url",
-				image_url: { url: `data:${img.mediaType};base64,${img.data}` }
+		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(toInputAudioPart({
+				mediaType: b.mediaType,
+				data: b.data
 			}));
-			for (const b of documentBlocks) parts.push({
-				type: "text",
-				text: documentMarker$1(b)
-			});
+			for (const b of videoBlocks) parts.push(toVideoUrlPart({
+				mediaType: b.mediaType,
+				data: b.data
+			}));
+			for (const b of documentBlocks) {
+				assertResolvedMediaBlock(b, "OpenAI-compatible wire messages");
+				if (documentsEnabled && isForwardableDocument(b)) parts.push(toFilePart(b));
+				else parts.push({
+					type: "text",
+					text: documentMarker$1(b)
+				});
+			}
 			for (const b of textBlocks) parts.push({
 				type: "text",
 				text: b.text
@@ -1128,6 +1375,48 @@ function userMessage(content) {
 		}]
 	};
 }
+/**
+* Build a user `SessionMessage` from multimodal prompt parts.
+*
+* Passes every kind (text/image/audio/video/document) through as a canonical
+* block; the actual wire emission, capability gating, and unsupported-media
+* throwing all happen later in {@link toOAIMessages}. Implementing this (rather
+* than letting the agent fall back to `defaultPromptMessage`) is what lets
+* openai-compat routes accept base64 documents/PDFs at all — the default
+* builder throws on base64 documents.
+*/
+function openAICompatPromptMessage(parts) {
+	const content = [];
+	for (const part of parts) {
+		if (part.type === "text") {
+			if (part.text.length > 0) content.push({
+				type: "text",
+				text: part.text
+			});
+			continue;
+		}
+		if (part.type === "image" || part.type === "audio" || part.type === "video") {
+			content.push({
+				type: part.type,
+				mediaType: part.mediaType,
+				data: part.data,
+				...part.name ? { name: part.name } : {}
+			});
+			continue;
+		}
+		content.push({
+			type: "document",
+			mediaType: part.mediaType,
+			data: part.data,
+			encoding: part.encoding,
+			...part.name ? { name: part.name } : {}
+		});
+	}
+	return {
+		role: "user",
+		content
+	};
+}
 function assistantMessage(content) {
 	return {
 		role: "assistant",
@@ -1332,6 +1621,23 @@ function estimateMissingUsage(body, result) {
 *   authHeader: { name: 'Authorization', scheme: 'Api-Key' },
 * })
 * ```
+*
+* @example OpenAI directly — including native PDF input
+* The bundled `openai` provider routes through pi-ai (Codex Responses), whose
+* content union is text+image only, so it degrades documents to a marker. To
+* send PDFs to OpenAI, point this factory at OpenAI's Chat Completions endpoint
+* and enable `documents` — base64 PDFs are forwarded as the `{type:'file'}`
+* content part. NOTE: OpenAI's Chat Completions `file` part accepts
+* `application/pdf` ONLY; spreadsheets/`.docx` are Responses-API-only and will
+* 400 here.
+* ```ts
+* openaiCompat({
+*   name: 'openai',
+*   apiKey: process.env.OPENAI_API_KEY!,
+*   baseURL: 'https://api.openai.com/v1',
+*   capabilities: { vision: true, documents: true },
+* })
+* ```
 */
 function openaiCompat(params) {
 	const name = params.name ?? "openai-compat";
@@ -1342,7 +1648,10 @@ function openaiCompat(params) {
 	const endpoint = `${params.baseURL.replace(TRAILING_SLASH_RE, "")}/chat/completions`;
 	const capabilities = {
 		vision: params.capabilities?.vision ?? false,
-		imageInToolResult: params.capabilities?.imageInToolResult ?? false
+		imageInToolResult: params.capabilities?.imageInToolResult ?? false,
+		audio: params.capabilities?.audio ?? false,
+		video: params.capabilities?.video ?? false,
+		documents: params.capabilities?.documents ?? false
 	};
 	const cacheBreakpointsEnabled = params.cacheBreakpoints === true;
 	const reasoningEnabled = params.supportsReasoning === true;
@@ -1359,11 +1668,15 @@ function openaiCompat(params) {
 		userMessage,
 		assistantMessage,
 		toolResultsMessage,
+		promptMessage: openAICompatPromptMessage,
 		classifyError: classifyOpenAICompatError,
 		async stream(options, callbacks) {
 			const modelId = options.model || defaultModel;
 			const messages = toOAIMessages(options.system, options.messages, {
 				imageInToolResult: capabilities.imageInToolResult === true,
+				audio: capabilities.audio === true,
+				video: capabilities.video === true,
+				documents: capabilities.documents === true,
 				supportsReasoning: reasoningEnabled,
 				reasoningMode,
 				reasoningContentField,
@@ -1386,6 +1699,13 @@ function openaiCompat(params) {
 				max_tokens: maxTokens,
 				stream: true
 			};
+			if (params.pdfEngine && messagesContainFilePart(messages)) {
+				const existing = Array.isArray(body.plugins) ? body.plugins : [];
+				if (!existing.some((p) => typeof p === "object" && p !== null && p.id === "file-parser")) body.plugins = [...existing, {
+					id: "file-parser",
+					pdf: { engine: params.pdfEngine }
+				}];
+			}
 			if (reasoningEnabled && reasoningMode === "openrouter") {
 				const reasoning = planOpenRouterReasoning(options.thinking, options.thinkingBudget);
 				if (reasoning) body.reasoning = reasoning;
@@ -1536,6 +1856,12 @@ function anthropicDocumentBlocks(doc) {
 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_-]+$`.
 *
@@ -1584,10 +1910,22 @@ function encodeAnthropicToolResultContent(output) {
 			type: "text",
 			text: b.text
 		};
-		if (b.type === "document") return {
+		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: documentMarker(b)
+			text: `[video omitted: ${b.mediaType}]`
 		};
+		assertResolvedMediaBlock(b, "Anthropic wire messages");
 		return {
 			type: "image",
 			source: anthropicImageSource(b.mediaType, b.data)
@@ -1797,11 +2135,23 @@ function toAnthropic(msg) {
 				type: "text",
 				text: block.text
 			}];
-			case "image": return [{
-				type: "image",
-				source: anthropicImageSource(block.mediaType, block.data)
+			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": return anthropicDocumentBlocks(block);
+			case "document":
+				assertResolvedMediaBlock(block, "Anthropic wire messages");
+				return anthropicDocumentBlocks(block);
 			case "tool_call": return [{
 				type: "tool_use",
 				id: sanitizeAnthropicToolId(block.id),
@@ -1815,7 +2165,7 @@ function toAnthropic(msg) {
 					content: encodeAnthropicToolResultContent(block.output)
 				};
 				if (block.isError) out.is_error = true;
-				return [out, ...(typeof block.output === "string" ? [] : block.output.filter((part) => part.type === "document")).flatMap(anthropicDocumentBlocks)];
+				return [out, ...(typeof block.output === "string" ? [] : block.output.filter((part) => part.type === "document" && typeof part.data === "string")).flatMap(anthropicDocumentBlocks)];
 			}
 			case "thinking": return [{
 				type: "thinking",
@@ -1858,6 +2208,8 @@ function toOpenAI(msg) {
 	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");
@@ -1891,15 +2243,33 @@ function toOpenAI(msg) {
 			}
 		};
 	}
-	if (imageBlocks.length > 0 || documentBlocks.length > 0) {
-		const parts = imageBlocks.map((img) => ({
-			type: "image_url",
-			image_url: { url: `data:${img.mediaType};base64,${img.data}` }
-		}));
-		for (const b of documentBlocks) parts.push({
-			type: "text",
-			text: documentMarker(b)
+	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
@@ -2390,6 +2760,123 @@ function ensureEndsWithUserMessage(messages, provider, directive = DEFAULT_USER_
 	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[]`.
 *
@@ -2418,7 +2905,7 @@ function ensureEndsWithUserMessage(messages, provider, directive = DEFAULT_USER_
 * "don't rewrite the past" invariant the wire-only repair was designed
 * around.
 */
-function toWireMessages(turns, options = {}) {
+async function toWireMessages(turns, options = {}) {
 	const messages = [];
 	for (const t of turns) {
 		if (t.role === "system") continue;
@@ -2427,9 +2914,7 @@ function toWireMessages(turns, options = {}) {
 			content: t.content
 		});
 	}
-	const paired = ensureToolResultPairing(messages, options.onRepair ? { onRepair: options.onRepair } : {});
-	if (!options.provider) return paired;
-	return ensureEndsWithUserMessage(paired, options.provider, options.userTailDirective);
+	return finalizeWireMessages(await resolveContentRefsInMessages(messages, { resolveContentRef: options.resolveContentRef }), options);
 }
 function autoDetectAndConvert(msg) {
 	const c = msg.content;
@@ -2450,6 +2935,6 @@ function autoDetectAndConvert(msg) {
 	return fromAnthropic(msg);
 }
 //#endregion
-export { renderSystemForWire as A, sanitizeToolSpecs as C, appendStaticSection as D, appendDynamicSection as E, splitSystemPrompt as M, hasSystemPromptBoundary as O, sanitizeToolSchema as S, SYSTEM_PROMPT_BOUNDARY as T, classifyOpenAICompatError as _, detectTurnInterruption as a, toolResultsMessage as b, filterUnresolvedToolUses as c, remintDuplicateToolCallIds as d, toAnthropic as f, assistantMessage as g, OpenAICompatHttpError as h, autoDetectAndConvert as i, replaceDynamicSection as j, joinSystemPrompt as k, fromAnthropic as l, toWireMessages as m, SYNTHETIC_TOOL_RESULT_PLACEHOLDER as n, ensureEndsWithUserMessage as o, toOpenAI as p, TOOL_USE_INTERRUPTED_MARKER as r, ensureToolResultPairing as s, ORPHANED_TOOL_RESULT_MARKER as t, fromOpenAI as u, mapOAIFinishReason as v, fillEstimatedCost as w, userMessage as x, openaiCompat as y };
+export { joinSystemPrompt as A, sanitizeToolSchema as C, appendDynamicSection as D, SYSTEM_PROMPT_BOUNDARY as E, canonicalizePrompt as F, unsupportedMediaError as I, 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 };
 
-//# sourceMappingURL=messages-RPKrEPvH.js.map
+//# sourceMappingURL=messages-9wyCuvLF.js.map