zidane 4.0.2 → 4.1.4

package/dist/messages-z5Pq20p7.js

@@ -0,0 +1,1020 @@
+import { o as matchesContextExceeded } from "./errors-D1lhd6mX.js";
+//#region src/providers/openai-compat.ts
+const TOOL_RESULTS_TAG = "__zidane_tool_results__";
+const ASSISTANT_TOOL_CALLS_TAG = "__zidane_assistant_tc__";
+/**
+* Ceiling on how many bytes may accumulate between two newline boundaries when
+* parsing an SSE stream. A broken or malicious server that emits an unbounded
+* stream of non-newline bytes would otherwise grow `buffer` without end and
+* eventually OOM the host. 8 MB is safely above the largest tool-call arg
+* JSON we reasonably expect and still catches a pathological stream in ~1 s on
+* a 10 MB/s connection.
+*/
+const SSE_MAX_BUFFER_BYTES = 8 * 1024 * 1024;
+var OpenAICompatStreamError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "OpenAICompatStreamError";
+	}
+};
+async function consumeSSE(response, callbacks, signal) {
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let text = "";
+	let thinking = "";
+	let finishReason = "stop";
+	let usage = {
+		input: 0,
+		output: 0
+	};
+	const tcMap = /* @__PURE__ */ new Map();
+	const reasoningMap = /* @__PURE__ */ new Map();
+	let sawReasoningDetails = false;
+	try {
+		while (true) {
+			if (signal?.aborted) break;
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			if (buffer.length > SSE_MAX_BUFFER_BYTES) throw new OpenAICompatStreamError(`SSE buffer exceeded ${SSE_MAX_BUFFER_BYTES} bytes without a line boundary — upstream may be streaming non-SSE data.`);
+			const lines = buffer.split("\n");
+			buffer = lines.pop() || "";
+			for (const line of lines) {
+				if (!line.startsWith("data: ")) continue;
+				const data = line.slice(6).trim();
+				if (data === "[DONE]") continue;
+				let chunk;
+				try {
+					chunk = JSON.parse(data);
+				} catch {
+					continue;
+				}
+				const choice = chunk.choices?.[0];
+				if (!choice) continue;
+				const fr = choice.finish_reason;
+				if (fr) finishReason = fr;
+				const delta = choice.delta;
+				const reasoningDeltaArr = delta?.reasoning_details;
+				if (reasoningDeltaArr && reasoningDeltaArr.length > 0) {
+					sawReasoningDetails = true;
+					for (const item of reasoningDeltaArr) {
+						const idx = typeof item.index === "number" ? item.index : 0;
+						const existing = reasoningMap.get(idx) ?? {};
+						if (typeof item.text === "string") {
+							existing.text = (existing.text ?? "") + item.text;
+							thinking += item.text;
+							callbacks.onThinking?.(item.text);
+						}
+						if (typeof item.summary === "string") {
+							existing.summary = (existing.summary ?? "") + item.summary;
+							thinking += item.summary;
+							callbacks.onThinking?.(item.summary);
+						}
+						for (const key of [
+							"type",
+							"signature",
+							"data",
+							"format",
+							"id"
+						]) {
+							const v = item[key];
+							if (typeof v === "string") existing[key] = v;
+						}
+						reasoningMap.set(idx, existing);
+					}
+				}
+				if (!sawReasoningDetails) {
+					const thinkingDelta = delta?.reasoning_content ?? delta?.reasoning;
+					if (thinkingDelta) {
+						thinking += thinkingDelta;
+						callbacks.onThinking?.(thinkingDelta);
+					}
+				}
+				const contentDelta = delta?.content;
+				if (contentDelta) {
+					text += contentDelta;
+					callbacks.onText(contentDelta);
+				}
+				const toolCallsDelta = delta?.tool_calls;
+				if (toolCallsDelta) for (const tc of toolCallsDelta) {
+					const existing = tcMap.get(tc.index);
+					if (existing) {
+						if (tc.function?.arguments) existing.args += tc.function.arguments;
+					} else tcMap.set(tc.index, {
+						id: tc.id || `call_${tc.index}`,
+						name: tc.function?.name || "",
+						args: tc.function?.arguments || ""
+					});
+				}
+				const chunkUsage = chunk.usage;
+				if (chunkUsage) {
+					const cachedRead = chunkUsage.prompt_tokens_details?.cached_tokens;
+					const cachedWrite = chunkUsage.prompt_tokens_details?.cache_creation_input_tokens ?? chunkUsage.prompt_tokens_details?.cache_write_tokens ?? chunkUsage.cache_creation_input_tokens;
+					usage = {
+						input: chunkUsage.prompt_tokens ?? 0,
+						output: chunkUsage.completion_tokens ?? 0,
+						cost: chunkUsage.total_cost ?? void 0,
+						...typeof cachedRead === "number" && cachedRead > 0 ? { cacheRead: cachedRead } : {},
+						...typeof cachedWrite === "number" && cachedWrite > 0 ? { cacheCreation: cachedWrite } : {}
+					};
+				}
+			}
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	const toolCalls = [];
+	for (const tc of tcMap.values()) {
+		if (!tc.args) {
+			toolCalls.push({
+				id: tc.id,
+				name: tc.name,
+				input: {}
+			});
+			continue;
+		}
+		try {
+			toolCalls.push({
+				id: tc.id,
+				name: tc.name,
+				input: JSON.parse(tc.args)
+			});
+		} catch (err) {
+			throw new OpenAICompatStreamError(`Tool call "${tc.name}" (${tc.id}) arguments were truncated or malformed: ${err.message}`);
+		}
+	}
+	const reasoningDetails = Array.from(reasoningMap.entries()).sort(([a], [b]) => a - b).map(([, item]) => item);
+	return {
+		text,
+		thinking,
+		toolCalls,
+		finishReason,
+		usage,
+		reasoningDetails
+	};
+}
+/**
+* Encode a single image block as an OpenAI `image_url` multi-part entry.
+*/
+function toImageUrlPart(img) {
+	return {
+		type: "image_url",
+		image_url: { url: `data:${img.mediaType};base64,${img.data}` }
+	};
+}
+/**
+* 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.
+*
+* Used only on the fallback path; the native path walks `output` in-order to preserve
+* text↔image interleaving.
+*/
+function summarizeToolResultOutput(output) {
+	if (typeof output === "string") return {
+		text: output,
+		images: []
+	};
+	const texts = [];
+	const images = [];
+	for (const block of output) if (block.type === "text") texts.push(block.text);
+	else if (block.type === "image") images.push({
+		mediaType: block.mediaType,
+		data: block.data
+	});
+	return {
+		text: texts.join("\n"),
+		images
+	};
+}
+function toOAIMessages(system, messages, options = {}) {
+	const out = [{
+		role: "system",
+		content: system
+	}];
+	const nativeImageInTool = options.imageInToolResult === true;
+	const reasoningEnabled = options.supportsReasoning === true;
+	const activeModel = options.model;
+	for (const msg of messages) {
+		const toolResults = msg.content.filter((b) => b.type === "tool_result");
+		const toolCalls = msg.content.filter((b) => b.type === "tool_call");
+		const textBlocks = msg.content.filter((b) => b.type === "text");
+		const imageBlocks = msg.content.filter((b) => b.type === "image");
+		const reasoningDetails = (reasoningEnabled ? msg.content.filter((b) => {
+			if (b.type !== "provider_reasoning") return false;
+			if (b.producer !== "openrouter") return false;
+			if (b.model && activeModel && b.model !== activeModel) return false;
+			return true;
+		}) : []).flatMap((b) => b.details);
+		if (toolResults.length > 0) {
+			for (const tr of toolResults) {
+				if (typeof tr.output === "string") {
+					out.push({
+						role: "tool",
+						tool_call_id: tr.callId,
+						content: tr.output
+					});
+					continue;
+				}
+				if (nativeImageInTool) {
+					const parts = tr.output.map((block) => block.type === "image" ? toImageUrlPart({
+						mediaType: block.mediaType,
+						data: block.data
+					}) : {
+						type: "text",
+						text: block.text
+					});
+					out.push({
+						role: "tool",
+						tool_call_id: tr.callId,
+						content: parts
+					});
+					continue;
+				}
+				const { text, images } = summarizeToolResultOutput(tr.output);
+				if (images.length === 0) {
+					out.push({
+						role: "tool",
+						tool_call_id: tr.callId,
+						content: text
+					});
+					continue;
+				}
+				const noun = images.length === 1 ? "image" : "images";
+				const attachedMarker = `[${images.length} ${noun} attached — see next user message]`;
+				const toolMarker = text.length > 0 ? `${text}\n\n${attachedMarker}` : attachedMarker;
+				out.push({
+					role: "tool",
+					tool_call_id: tr.callId,
+					content: toolMarker
+				});
+				out.push({
+					role: "user",
+					content: [...images.map(toImageUrlPart), {
+						type: "text",
+						text: `(${noun} returned by tool call ${tr.callId})`
+					}]
+				});
+			}
+			continue;
+		}
+		if (toolCalls.length > 0) {
+			const m = {
+				role: "assistant",
+				content: textBlocks.length > 0 ? textBlocks[0].text : null,
+				tool_calls: toolCalls.map((tc) => ({
+					id: tc.id,
+					type: "function",
+					function: {
+						name: tc.name,
+						arguments: JSON.stringify(tc.input)
+					}
+				}))
+			};
+			if (reasoningDetails.length > 0) m.reasoning_details = reasoningDetails;
+			out.push(m);
+			continue;
+		}
+		if (imageBlocks.length > 0) {
+			const parts = imageBlocks.map((img) => ({
+				type: "image_url",
+				image_url: { url: `data:${img.mediaType};base64,${img.data}` }
+			}));
+			for (const b of textBlocks) parts.push({
+				type: "text",
+				text: b.text
+			});
+			const m = {
+				role: msg.role,
+				content: parts
+			};
+			if (msg.role === "assistant" && reasoningDetails.length > 0) m.reasoning_details = reasoningDetails;
+			out.push(m);
+			continue;
+		}
+		let pushed;
+		if (textBlocks.length === 1) pushed = {
+			role: msg.role,
+			content: textBlocks[0].text
+		};
+		else if (textBlocks.length > 1) pushed = {
+			role: msg.role,
+			content: textBlocks.map((b) => ({
+				type: "text",
+				text: b.text
+			}))
+		};
+		else pushed = {
+			role: msg.role,
+			content: null
+		};
+		if (msg.role === "assistant" && reasoningDetails.length > 0) pushed.reasoning_details = reasoningDetails;
+		out.push(pushed);
+	}
+	return out;
+}
+const EPHEMERAL = { type: "ephemeral" };
+/**
+* Add `cache_control: { type: 'ephemeral' }` breakpoints to the system message's
+* last text part and the last message's final content part.
+*
+* Mutates `messages` in place. Converts plain-string content into a single-element
+* content array so the cache marker can attach — this shape is accepted verbatim by
+* OpenRouter's Anthropic and Gemini routes and ignored by routes with automatic
+* caching (OpenAI, DeepSeek, Grok, Groq, Moonshot).
+*
+* Skip conditions (safe no-ops):
+* - Empty messages array.
+* - Assistant messages with no text (tool-call-only) — attaching a cache marker to a
+*   `tool_calls` block has no defined semantics, so we skip and let the prior
+*   system/tools breakpoints carry caching.
+*/
+function applyOAICacheBreakpoints(messages) {
+	if (messages.length === 0) return;
+	const first = messages[0];
+	if (first.role === "system") markLastContentPart(first);
+	const lastIdx = messages.length - 1;
+	if (lastIdx > 0) markLastContentPart(messages[lastIdx]);
+}
+/**
+* Mark the last content part of an OAI message with `cache_control`. Normalizes
+* string content into a `[{ type: 'text', text, cache_control }]` array so the
+* marker has a block to attach to.
+*
+* No-op for messages without string or array content (tool-call-only assistant
+* messages fall through; the system/tools breakpoints carry the cache prefix).
+*/
+function markLastContentPart(msg) {
+	if (typeof msg.content === "string") {
+		if (msg.content.length === 0) return;
+		msg.content = [{
+			type: "text",
+			text: msg.content,
+			cache_control: EPHEMERAL
+		}];
+		return;
+	}
+	if (!Array.isArray(msg.content) || msg.content.length === 0) return;
+	const parts = msg.content;
+	const lastBlockIdx = parts.length - 1;
+	parts[lastBlockIdx] = {
+		...parts[lastBlockIdx],
+		cache_control: EPHEMERAL
+	};
+}
+/**
+* Return a copy of `tools` with `cache_control` on the last entry.
+*
+* OpenRouter accepts the marker alongside the standard `type` + `function` fields
+* and forwards it when routing to Anthropic/Gemini. Leaves the non-cached tools
+* unchanged so the caller's reference is not mutated.
+*/
+function applyOAIToolCacheBreakpoint(tools) {
+	if (tools.length === 0) return tools;
+	const lastIdx = tools.length - 1;
+	return tools.map((tool, i) => i === lastIdx ? {
+		...tool,
+		cache_control: EPHEMERAL
+	} : tool);
+}
+function formatTools(tools) {
+	return tools.map((t) => ({
+		type: "function",
+		function: {
+			name: t.name,
+			description: t.description,
+			parameters: t.inputSchema
+		}
+	}));
+}
+function userMessage(content) {
+	return {
+		role: "user",
+		content: [{
+			type: "text",
+			text: content
+		}]
+	};
+}
+function assistantMessage(content) {
+	return {
+		role: "assistant",
+		content: [{
+			type: "text",
+			text: content
+		}]
+	};
+}
+function toolResultsMessage(results) {
+	return {
+		role: "user",
+		content: results.map((r) => ({
+			type: "tool_result",
+			callId: r.id,
+			output: r.content
+		}))
+	};
+}
+function buildAssistantContent(text, toolCalls, thinking, reasoning) {
+	const content = [];
+	if (reasoning && reasoning.details.length > 0) {
+		const block = {
+			type: "provider_reasoning",
+			producer: reasoning.producer,
+			details: reasoning.details
+		};
+		if (reasoning.model) block.model = reasoning.model;
+		content.push(block);
+	}
+	if (thinking) content.push({
+		type: "thinking",
+		text: thinking
+	});
+	if (text) content.push({
+		type: "text",
+		text
+	});
+	for (const tc of toolCalls) content.push({
+		type: "tool_call",
+		id: tc.id,
+		name: tc.name,
+		input: tc.input
+	});
+	return {
+		role: "assistant",
+		content
+	};
+}
+/**
+* HTTP error thrown when an OpenAI-compatible endpoint returns a non-OK response.
+*
+* The body is best-effort JSON-parsed; `error.message` / `error.code` / `error.type`
+* are extracted for clean downstream classification.
+*/
+var OpenAICompatHttpError = class extends Error {
+	status;
+	providerCode;
+	bodyText;
+	constructor(status, bodyText) {
+		let message = bodyText;
+		let code;
+		try {
+			const parsed = JSON.parse(bodyText);
+			message = parsed?.error?.message ?? bodyText;
+			code = parsed?.error?.code ?? parsed?.error?.type;
+		} catch {}
+		super(`HTTP ${status}: ${message}`);
+		this.name = "OpenAICompatHttpError";
+		this.status = status;
+		this.providerCode = code;
+		this.bodyText = bodyText;
+	}
+};
+const TRAILING_SLASH_RE = /\/$/;
+/**
+* Classify an OpenAI-compatible error into `ClassifiedError`.
+*
+* Recognizes:
+* - `AbortError` (from fetch) → `aborted`.
+* - `OpenAICompatHttpError` with a context-exceeded code or message → `context_exceeded`.
+* - Any other `OpenAICompatHttpError` → `provider_error`.
+*
+* Returns `null` for unrecognized error shapes (the loop falls back to `AgentProviderError`).
+*/
+function classifyOpenAICompatError(err) {
+	if (!err || typeof err !== "object") return null;
+	if (err.name === "AbortError") return { kind: "aborted" };
+	if (err instanceof OpenAICompatStreamError) return {
+		kind: "provider_error",
+		providerCode: "stream_error",
+		message: err.message,
+		retryable: true
+	};
+	if (!(err instanceof OpenAICompatHttpError)) return null;
+	const code = err.providerCode;
+	const msg = err.message;
+	if (code === "context_length_exceeded" || matchesContextExceeded(msg)) return {
+		kind: "context_exceeded",
+		providerCode: code ?? "context_length_exceeded",
+		message: msg
+	};
+	return {
+		kind: "provider_error",
+		providerCode: code ?? String(err.status),
+		message: msg,
+		retryable: isRetryableHttpStatus(err.status)
+	};
+}
+/**
+* 429 + 5xx (except 501 Not Implemented) are safe to retry with backoff;
+* 4xx other than 429 are terminal (bad request, auth, not found, etc.).
+*/
+function isRetryableHttpStatus(status) {
+	if (status === 429) return true;
+	if (status >= 500 && status !== 501) return true;
+	return false;
+}
+/**
+* Map an OpenAI-compatible `finish_reason` string to the zidane `TurnFinishReason` union.
+*/
+function mapOAIFinishReason(reason) {
+	if (!reason) return void 0;
+	switch (reason) {
+		case "stop": return "stop";
+		case "tool_calls":
+		case "function_call": return "tool-calls";
+		case "length": return "length";
+		case "content_filter": return "content-filter";
+		default: return "other";
+	}
+}
+/**
+* Map zidane's `ThinkingLevel` + optional explicit budget to the OpenRouter
+* `reasoning` request field. Returns `undefined` when reasoning should not be
+* sent (off, or no level + no budget).
+*
+* - `'low' | 'medium' | 'high'` → `{ effort }`.
+* - `'minimal'` → `{ effort: 'low' }` (closest match in OpenRouter's vocabulary).
+* - `'adaptive'` → `{}` (let upstream decide; OpenRouter passes through).
+* - explicit `thinkingBudget` → `{ max_tokens }` overlaid on the level.
+*/
+function planOpenRouterReasoning(thinking, thinkingBudget) {
+	if ((!thinking || thinking === "off") && typeof thinkingBudget !== "number") return void 0;
+	const out = {};
+	if (thinking && thinking !== "off" && thinking !== "adaptive") out.effort = thinking === "minimal" ? "low" : thinking;
+	if (typeof thinkingBudget === "number" && thinkingBudget > 0) out.max_tokens = thinkingBudget;
+	return out;
+}
+/**
+* Factory for any OpenAI-compatible HTTP endpoint.
+*
+* Speaks the standard `POST /chat/completions` + `stream: true` + SSE dialect.
+* Thin wrappers (`openrouter`, `cerebras`) call this with pinned defaults.
+*
+* @example Baseten (non-standard auth scheme)
+* ```ts
+* openaiCompat({
+*   name: 'baseten',
+*   apiKey: process.env.BASETEN_API_KEY!,
+*   baseURL: process.env.BASETEN_PROXY_URL!,
+*   authHeader: { name: 'Authorization', scheme: 'Api-Key' },
+* })
+* ```
+*/
+function openaiCompat(params) {
+	const name = params.name ?? "openai-compat";
+	const defaultModel = params.defaultModel ?? "gpt-4o-mini";
+	const authHeaderName = params.authHeader?.name ?? "Authorization";
+	const authHeaderValue = params.authHeader?.scheme ? `${params.authHeader.scheme} ${params.apiKey}` : params.authHeader ? params.apiKey : `Bearer ${params.apiKey}`;
+	const extraHeaders = params.extraHeaders ?? {};
+	const endpoint = `${params.baseURL.replace(TRAILING_SLASH_RE, "")}/chat/completions`;
+	const capabilities = {
+		vision: params.capabilities?.vision ?? false,
+		imageInToolResult: params.capabilities?.imageInToolResult ?? false
+	};
+	const cacheBreakpointsEnabled = params.cacheBreakpoints === true;
+	const reasoningEnabled = params.supportsReasoning === true;
+	return {
+		name,
+		meta: {
+			defaultModel,
+			capabilities
+		},
+		formatTools,
+		userMessage,
+		assistantMessage,
+		toolResultsMessage,
+		classifyError: classifyOpenAICompatError,
+		async stream(options, callbacks) {
+			const modelId = options.model || defaultModel;
+			const messages = toOAIMessages(options.system, options.messages, {
+				imageInToolResult: capabilities.imageInToolResult === true,
+				supportsReasoning: reasoningEnabled,
+				model: modelId
+			});
+			const shouldCache = cacheBreakpointsEnabled && options.cache !== false;
+			if (shouldCache) applyOAICacheBreakpoints(messages);
+			const maxTokens = options.thinkingBudget ? options.thinkingBudget + options.maxTokens : options.maxTokens;
+			const body = {
+				...params.extraBodyParams ?? {},
+				model: modelId,
+				messages,
+				max_tokens: maxTokens,
+				stream: true
+			};
+			if (reasoningEnabled) {
+				const reasoning = planOpenRouterReasoning(options.thinking, options.thinkingBudget);
+				if (reasoning) body.reasoning = reasoning;
+			}
+			if (options.tools && options.tools.length > 0) body.tools = shouldCache ? applyOAIToolCacheBreakpoint(options.tools) : options.tools;
+			if (options.toolChoice) if (options.toolChoice.type === "tool" && options.toolChoice.name) body.tool_choice = {
+				type: "function",
+				function: { name: options.toolChoice.name }
+			};
+			else if (options.toolChoice.type === "required") body.tool_choice = "required";
+			else body.tool_choice = "auto";
+			const response = await fetch(endpoint, {
+				method: "POST",
+				headers: {
+					[authHeaderName]: authHeaderValue,
+					"Content-Type": "application/json",
+					...extraHeaders
+				},
+				body: JSON.stringify(body),
+				signal: options.signal
+			});
+			if (!response.ok) {
+				const errorText = await response.text();
+				throw new OpenAICompatHttpError(response.status, errorText);
+			}
+			const result = await consumeSSE(response, callbacks, options.signal);
+			const finishReason = mapOAIFinishReason(result.finishReason);
+			return {
+				assistantMessage: buildAssistantContent(result.text, result.toolCalls, result.thinking, reasoningEnabled && result.reasoningDetails.length > 0 ? {
+					details: result.reasoningDetails,
+					producer: "openrouter",
+					model: modelId
+				} : void 0),
+				text: result.text,
+				toolCalls: result.toolCalls,
+				done: result.finishReason === "stop" || result.toolCalls.length === 0,
+				usage: {
+					input: result.usage.input,
+					output: result.usage.output,
+					...result.usage.cacheRead !== void 0 ? { cacheRead: result.usage.cacheRead } : {},
+					...result.usage.cacheCreation !== void 0 ? { cacheCreation: result.usage.cacheCreation } : {},
+					...result.usage.cost !== void 0 ? { cost: result.usage.cost } : {},
+					...finishReason ? { finishReason } : {},
+					modelId
+				}
+			};
+		}
+	};
+}
+//#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;
+}
+/**
+* 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
+		};
+		return {
+			type: "image",
+			source: {
+				type: "base64",
+				media_type: b.mediaType,
+				data: 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 === "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 ?? ""
+		});
+	}
+	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;
+			const input = rawArgs ? typeof rawArgs === "string" ? JSON.parse(rawArgs) : 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 ?? ""
+			});
+		}
+		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) => !(b.type === "thinking" && b.signatureProducer === "openai")).filter((b) => b.type !== "provider_reasoning").map((block) => {
+		switch (block.type) {
+			case "text": return {
+				type: "text",
+				text: block.text
+			};
+			case "image": return {
+				type: "image",
+				source: {
+					type: "base64",
+					media_type: block.mediaType,
+					data: block.data
+				}
+			};
+			case "tool_call": return {
+				type: "tool_use",
+				id: block.id,
+				name: block.name,
+				input: block.input
+			};
+			case "tool_result": {
+				const out = {
+					type: "tool_result",
+					tool_use_id: block.callId,
+					content: encodeAnthropicToolResultContent(block.output)
+				};
+				if (block.isError) out.is_error = true;
+				return out;
+			}
+			case "thinking": {
+				const out = {
+					type: "thinking",
+					thinking: block.text
+				};
+				if (block.signature) out.signature = block.signature;
+				return out;
+			}
+			case "redacted_thinking": return {
+				type: "redacted_thinking",
+				data: block.data
+			};
+			default: return {
+				type: "text",
+				text: ""
+			};
+		}
+	});
+	if (blocks.length === 1 && blocks[0].type === "text") return {
+		role: msg.role,
+		content: blocks[0].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");
+	if (toolResults.length > 0) return {
+		role: msg.role,
+		content: {
+			_tag: TOOL_RESULTS_TAG,
+			results: toolResults.map((b) => {
+				const tr = b;
+				return {
+					tool_call_id: tr.callId,
+					content: tr.output
+				};
+			})
+		}
+	};
+	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((b) => {
+					const tc = b;
+					return {
+						id: tc.id,
+						type: "function",
+						function: {
+							name: tc.name,
+							arguments: JSON.stringify(tc.input)
+						}
+					};
+				})
+			}
+		};
+	}
+	if (imageBlocks.length > 0) {
+		const parts = imageBlocks.map((b) => {
+			const img = b;
+			return {
+				type: "image_url",
+				image_url: { url: `data:${img.mediaType};base64,${img.data}` }
+			};
+		});
+		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
+	};
+}
+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 { toOpenAI as a, classifyOpenAICompatError as c, toolResultsMessage as d, userMessage as f, toAnthropic as i, mapOAIFinishReason as l, fromAnthropic as n, OpenAICompatHttpError as o, fromOpenAI as r, assistantMessage as s, autoDetectAndConvert as t, openaiCompat as u };
+
+//# sourceMappingURL=messages-z5Pq20p7.js.map