@andorra-labs/code 0.0.0-stage → 0.1.5

package/dist/vendor/engine/runtime/ai/api/mistral-conversations.js

@@ -0,0 +1,747 @@
+import { andorraCalculateCost, andorraClampThinkingLevel } from "../models.js";
+import { AndorraAssistantMessageEventStream } from "../utils/event-stream.js";
+import { andorraShortHash } from "../utils/hash.js";
+import { andorraHeadersToRecord } from "../utils/headers.js";
+import { andorraParseStreamingJson } from "../utils/json-parse.js";
+import { andorraGetAndorraUserAgent } from "../utils/pi-user-agent.js";
+import { andorraSanitizeSurrogates } from "../utils/sanitize-unicode.js";
+import { andorraGetSystemMessageText, andorraRenderSystemMessageUpdate } from "../utils/text.js";
+import { andorraGetCurrentTools, andorraResolveTranscript } from "../utils/transcript.js";
+import { andorraGetJsonSchemaToolParameters, andorraResolveJsonSchemaStrictSampling } from "./constrained-sampling.js";
+import { andorraBuildBaseOptions } from "./simple-options.js";
+import { andorraTransformMessages } from "./transform-messages.js";
+const MISTRAL_TOOL_CALL_ID_LENGTH = 9;
+const MAX_MISTRAL_ERROR_BODY_CHARS = 4000;
+/**
+ * Stream responses from the native Mistral Chat Completions endpoint.
+ */
+export const andorraStream = (model, context, options) => {
+    const stream = new AndorraAssistantMessageEventStream();
+    const normalizedContext = andorraResolveTranscript(context, model.compat?.supportsMidConvoSystemMessages);
+    (async () => {
+        const output = andorraCreateOutput(model);
+        try {
+            const apiKey = options?.apiKey;
+            if (!apiKey) {
+                throw new Error(`No API key for provider: ${model.provider}`);
+            }
+            const normalizeMistralToolCallId = andorraCreateMistralToolCallIdNormalizer();
+            const transformedMessages = andorraTransformMessages(normalizedContext.messages, model, (id) => normalizeMistralToolCallId(id));
+            let payload = andorraBuildChatPayload(model, normalizedContext, transformedMessages, options);
+            const nextPayload = await options?.onPayload?.(payload, model);
+            if (nextPayload !== undefined) {
+                payload = nextPayload;
+            }
+            const mistralStream = await andorraRequestMistralStream(model, payload, apiKey, options);
+            stream.push({ type: "start", partial: output });
+            await andorraConsumeChatStream(model, output, stream, mistralStream);
+            if (options?.signal?.aborted) {
+                throw new Error("Request was aborted");
+            }
+            if (output.stopReason === "pending") {
+                throw new Error("Mistral stream ended without a finish reason");
+            }
+            if (output.stopReason === "aborted" || output.stopReason === "error") {
+                throw new Error(output.errorMessage || "An unknown error occurred");
+            }
+            stream.push({ type: "done", reason: output.stopReason, message: output });
+            stream.end();
+        }
+        catch (error) {
+            for (const block of output.content) {
+                // partialArgs is only a streaming scratch buffer; never persist it.
+                delete block.partialArgs;
+            }
+            output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+            output.errorMessage = andorraFormatMistralError(error);
+            stream.push({ type: "error", reason: output.stopReason, error: output });
+            stream.end();
+        }
+    })();
+    return stream;
+};
+/**
+ * Maps provider-agnostic `SimpleStreamOptions` to Mistral options.
+ */
+export const andorraStreamSimple = (model, context, options) => {
+    const apiKey = options?.apiKey;
+    if (!apiKey) {
+        throw new Error(`No API key for provider: ${model.provider}`);
+    }
+    const base = {
+        ...andorraBuildBaseOptions(model, context, options, apiKey),
+        toolChoice: options?.toolChoice,
+    };
+    const clampedReasoning = options?.reasoning ? andorraClampThinkingLevel(model, options.reasoning) : undefined;
+    const reasoning = clampedReasoning === "off" ? undefined : clampedReasoning;
+    const shouldUseReasoning = model.reasoning && reasoning !== undefined;
+    return andorraStream(model, context, {
+        ...base,
+        promptMode: shouldUseReasoning && andorraUsesPromptModeReasoning(model) ? "reasoning" : undefined,
+        reasoningEffort: shouldUseReasoning && andorraUsesReasoningEffort(model) ? andorraMapReasoningEffort(model, reasoning) : undefined,
+    });
+};
+function andorraCreateOutput(model) {
+    return {
+        role: "assistant",
+        content: [],
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        usage: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            totalTokens: 0,
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+        },
+        stopReason: "pending",
+        timestamp: Date.now(),
+    };
+}
+function andorraCreateMistralToolCallIdNormalizer() {
+    const idMap = new Map();
+    const reverseMap = new Map();
+    return (id) => {
+        const existing = idMap.get(id);
+        if (existing)
+            return existing;
+        let attempt = 0;
+        while (true) {
+            const candidate = andorraDeriveMistralToolCallId(id, attempt);
+            const owner = reverseMap.get(candidate);
+            if (!owner || owner === id) {
+                idMap.set(id, candidate);
+                reverseMap.set(candidate, id);
+                return candidate;
+            }
+            attempt++;
+        }
+    };
+}
+function andorraDeriveMistralToolCallId(id, attempt) {
+    const normalized = id.replace(/[^a-zA-Z0-9]/g, "");
+    if (attempt === 0 && normalized.length === MISTRAL_TOOL_CALL_ID_LENGTH)
+        return normalized;
+    const seedBase = normalized || id;
+    const seed = attempt === 0 ? seedBase : `${seedBase}:${attempt}`;
+    return andorraShortHash(seed)
+        .replace(/[^a-zA-Z0-9]/g, "")
+        .slice(0, MISTRAL_TOOL_CALL_ID_LENGTH);
+}
+function andorraFormatMistralError(error) {
+    if (error instanceof Error) {
+        const httpError = error;
+        const statusCode = typeof httpError.statusCode === "number" ? httpError.statusCode : undefined;
+        const bodyText = typeof httpError.body === "string" ? httpError.body.trim() : undefined;
+        if (statusCode !== undefined && bodyText) {
+            return `Mistral API error (${statusCode}): ${andorraTruncateErrorText(bodyText, MAX_MISTRAL_ERROR_BODY_CHARS)}`;
+        }
+        if (statusCode !== undefined)
+            return `Mistral API error (${statusCode}): ${error.message}`;
+        return error.message;
+    }
+    return andorraSafeJsonStringify(error);
+}
+function andorraTruncateErrorText(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    return `${text.slice(0, maxChars)}... [truncated ${text.length - maxChars} chars]`;
+}
+function andorraSafeJsonStringify(value) {
+    try {
+        const serialized = JSON.stringify(value);
+        return serialized === undefined ? String(value) : serialized;
+    }
+    catch {
+        return String(value);
+    }
+}
+async function andorraRequestMistralStream(model, payload, apiKey, options) {
+    const baseUrl = new URL(model.baseUrl);
+    baseUrl.pathname = `${baseUrl.pathname.replace(/\/+$/u, "")}/`;
+    const url = new URL("v1/chat/completions", baseUrl);
+    const headers = andorraBuildMistralHeaders(model, apiKey, options);
+    const timeoutSignal = AbortSignal.timeout(options?.timeoutMs ?? 60_000);
+    const signal = options?.signal ? AbortSignal.any([options.signal, timeoutSignal]) : timeoutSignal;
+    const response = await (options?.fetch ?? globalThis.fetch)(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(andorraToMistralWirePayload(payload)),
+        signal,
+    });
+    await options?.onResponse?.({ status: response.status, headers: andorraHeadersToRecord(response.headers) }, model);
+    if (!response.ok) {
+        const body = await response.text();
+        throw new AndorraMistralHttpError(response.status, body, response.statusText);
+    }
+    if (!response.body) {
+        throw new Error("Mistral response has no body");
+    }
+    return andorraReadMistralEvents(response.body, signal);
+}
+class AndorraMistralHttpError extends Error {
+    statusCode;
+    body;
+    constructor(statusCode, body, statusText) {
+        super(statusText || `Request failed with status ${statusCode}`);
+        this.name = "MistralHttpError";
+        this.statusCode = statusCode;
+        this.body = body;
+    }
+}
+function andorraBuildMistralHeaders(model, apiKey, options) {
+    const headers = new Headers({
+        "User-Agent": andorraGetAndorraUserAgent(),
+        accept: "text/event-stream",
+        authorization: `Bearer ${apiKey}`,
+        "content-type": "application/json",
+    });
+    andorraApplyMistralHeaderOverrides(headers, model.headers);
+    andorraApplyMistralHeaderOverrides(headers, options?.headers);
+    const hasExplicitAffinity = andorraHasMistralHeaderOverride(model.headers, "x-affinity") || andorraHasMistralHeaderOverride(options?.headers, "x-affinity");
+    if (andorraShouldUsePromptCaching(options) && !hasExplicitAffinity) {
+        headers.set("x-affinity", options.sessionId);
+    }
+    return headers;
+}
+function andorraApplyMistralHeaderOverrides(headers, overrides) {
+    if (!overrides)
+        return;
+    for (const [name, value] of Object.entries(overrides)) {
+        if (value === null)
+            headers.delete(name);
+        else
+            headers.set(name, value);
+    }
+}
+function andorraHasMistralHeaderOverride(overrides, target) {
+    return !!overrides && Object.keys(overrides).some((name) => name.toLowerCase() === target);
+}
+function andorraToMistralWirePayload(payload) {
+    const wirePayload = { ...payload };
+    for (const [source, target] of [
+        ["topP", "top_p"],
+        ["maxTokens", "max_tokens"],
+        ["randomSeed", "random_seed"],
+        ["responseFormat", "response_format"],
+        ["toolChoice", "tool_choice"],
+        ["presencePenalty", "presence_penalty"],
+        ["frequencyPenalty", "frequency_penalty"],
+        ["parallelToolCalls", "parallel_tool_calls"],
+        ["reasoningEffort", "reasoning_effort"],
+        ["promptMode", "prompt_mode"],
+        ["promptCacheKey", "prompt_cache_key"],
+        ["safePrompt", "safe_prompt"],
+    ]) {
+        andorraRemapMistralProperty(wirePayload, source, target);
+    }
+    wirePayload.messages = payload.messages.map((message) => andorraToMistralWireMessage(message));
+    const responseFormat = wirePayload.response_format;
+    if (andorraIsMistralRecord(responseFormat)) {
+        const wireResponseFormat = { ...responseFormat };
+        andorraRemapMistralProperty(wireResponseFormat, "jsonSchema", "json_schema");
+        const jsonSchema = wireResponseFormat.json_schema;
+        if (andorraIsMistralRecord(jsonSchema)) {
+            const wireJsonSchema = { ...jsonSchema };
+            andorraRemapMistralProperty(wireJsonSchema, "schemaDefinition", "schema");
+            wireResponseFormat.json_schema = wireJsonSchema;
+        }
+        wirePayload.response_format = wireResponseFormat;
+    }
+    return wirePayload;
+}
+function andorraToMistralWireMessage(message) {
+    const wireMessage = { ...message };
+    andorraRemapMistralProperty(wireMessage, "toolCalls", "tool_calls");
+    andorraRemapMistralProperty(wireMessage, "toolCallId", "tool_call_id");
+    if (Array.isArray(message.content)) {
+        wireMessage.content = message.content.map((chunk) => andorraToMistralWireContentChunk(chunk));
+    }
+    return wireMessage;
+}
+function andorraToMistralWireContentChunk(chunk) {
+    const wireChunk = { ...chunk };
+    for (const [source, target] of [
+        ["imageUrl", "image_url"],
+        ["documentUrl", "document_url"],
+        ["documentName", "document_name"],
+        ["fileId", "file_id"],
+        ["referenceIds", "reference_ids"],
+        ["inputAudio", "input_audio"],
+    ]) {
+        andorraRemapMistralProperty(wireChunk, source, target);
+    }
+    return wireChunk;
+}
+function andorraRemapMistralProperty(record, source, target) {
+    if (!(source in record))
+        return;
+    record[target] = record[source];
+    delete record[source];
+}
+function andorraIsMistralRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const MISTRAL_STREAM_DONE = Symbol("mistral-stream-done");
+async function* andorraReadMistralEvents(body, signal) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const andorraOnAbort = () => {
+        void reader.cancel().catch(() => { });
+    };
+    signal.addEventListener("abort", andorraOnAbort, { once: true });
+    try {
+        while (true) {
+            if (signal.aborted)
+                throw signal.reason;
+            const { done, value } = await reader.read();
+            if (signal.aborted)
+                throw signal.reason;
+            buffer += done ? decoder.decode() : decoder.decode(value, { stream: true });
+            let boundary = andorraFindMistralEventBoundary(buffer);
+            while (boundary) {
+                const event = andorraParseMistralEvent(buffer.slice(0, boundary.index));
+                buffer = buffer.slice(boundary.index + boundary.length);
+                if (event === MISTRAL_STREAM_DONE)
+                    return;
+                if (event)
+                    yield event;
+                boundary = andorraFindMistralEventBoundary(buffer);
+            }
+            if (done)
+                break;
+        }
+        if (buffer.trim()) {
+            const event = andorraParseMistralEvent(buffer);
+            if (event !== MISTRAL_STREAM_DONE && event)
+                yield event;
+        }
+    }
+    finally {
+        signal.removeEventListener("abort", andorraOnAbort);
+        try {
+            await reader.cancel();
+        }
+        catch { }
+        try {
+            reader.releaseLock();
+        }
+        catch { }
+    }
+}
+function andorraFindMistralEventBoundary(buffer) {
+    const match = /\r\n\r\n|\r\n\r|\r\n\n|\r\r\n|\n\r\n|\r\r|\n\r|\n\n/u.exec(buffer);
+    return match?.index === undefined ? undefined : { index: match.index, length: match[0].length };
+}
+function andorraParseMistralEvent(raw) {
+    const data = raw
+        .split(/\r\n|\r|\n/u)
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice(5).trimStart())
+        .join("\n")
+        .trim();
+    if (!data)
+        return undefined;
+    if (data === "[DONE]")
+        return MISTRAL_STREAM_DONE;
+    const parsed = JSON.parse(data);
+    if (!andorraIsMistralRecord(parsed) || !Array.isArray(parsed.choices)) {
+        throw new Error("Invalid Mistral streaming event");
+    }
+    return { data: parsed };
+}
+function andorraBuildChatPayload(model, context, messages, options) {
+    const payload = {
+        model: model.id,
+        stream: true,
+        messages: andorraToChatMessages(messages, model.input.includes("image")),
+    };
+    const currentTools = andorraGetCurrentTools(context.messages);
+    if (currentTools.length > 0)
+        payload.tools = andorraToFunctionTools(currentTools);
+    if (options?.temperature !== undefined)
+        payload.temperature = options.temperature;
+    if (options?.maxTokens !== undefined)
+        payload.maxTokens = options.maxTokens;
+    if (options?.toolChoice)
+        payload.toolChoice = andorraMapToolChoice(options.toolChoice);
+    if (options?.promptMode)
+        payload.promptMode = options.promptMode;
+    if (options?.reasoningEffort)
+        payload.reasoningEffort = options.reasoningEffort;
+    if (andorraShouldUsePromptCaching(options))
+        payload.promptCacheKey = options.sessionId;
+    return payload;
+}
+function andorraShouldUsePromptCaching(options) {
+    return options?.cacheRetention !== "none" && !!options?.sessionId;
+}
+function andorraGetMistralCachedPromptTokens(usage, promptTokens) {
+    const rawUsage = usage;
+    const rawCachedTokens = rawUsage.promptTokensDetails?.cachedTokens ??
+        rawUsage.prompt_tokens_details?.cached_tokens ??
+        rawUsage.promptTokenDetails?.cachedTokens ??
+        rawUsage.prompt_token_details?.cached_tokens ??
+        rawUsage.numCachedTokens ??
+        rawUsage.num_cached_tokens ??
+        0;
+    const cachedTokens = typeof rawCachedTokens === "number" && Number.isFinite(rawCachedTokens) ? rawCachedTokens : 0;
+    return Math.min(promptTokens, Math.max(0, cachedTokens));
+}
+async function andorraConsumeChatStream(model, output, stream, mistralStream) {
+    let currentBlock = null;
+    const blocks = output.content;
+    const andorraBlockIndex = () => blocks.length - 1;
+    const toolBlocksByKey = new Map();
+    const andorraFinishCurrentBlock = (block) => {
+        if (!block)
+            return;
+        if (block.type === "text") {
+            stream.push({
+                type: "text_end",
+                contentIndex: andorraBlockIndex(),
+                content: block.text,
+                partial: output,
+            });
+            return;
+        }
+        if (block.type === "thinking") {
+            stream.push({
+                type: "thinking_end",
+                contentIndex: andorraBlockIndex(),
+                content: block.thinking,
+                partial: output,
+            });
+        }
+    };
+    for await (const event of mistralStream) {
+        const chunk = event.data;
+        // Mistral's streamed CompletionChunk carries an id field. Keep the first non-empty one,
+        // mirroring how OpenAI-style streaming exposes a stable response identifier per stream.
+        output.responseId ||= chunk.id;
+        if (chunk.usage) {
+            const promptTokens = chunk.usage.prompt_tokens || 0;
+            const cachedPromptTokens = andorraGetMistralCachedPromptTokens(chunk.usage, promptTokens);
+            output.usage.input = Math.max(0, promptTokens - cachedPromptTokens);
+            output.usage.output = chunk.usage.completion_tokens || 0;
+            output.usage.cacheRead = cachedPromptTokens;
+            output.usage.cacheWrite = 0;
+            output.usage.totalTokens =
+                chunk.usage.total_tokens ||
+                    output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
+            andorraCalculateCost(model, output.usage);
+        }
+        const choice = chunk.choices[0];
+        if (!choice)
+            continue;
+        if (choice.finish_reason) {
+            output.rawStopReason = choice.finish_reason;
+            const stopReasonResult = andorraMapChatStopReason(choice.finish_reason);
+            output.stopReason = stopReasonResult.stopReason;
+            if (stopReasonResult.errorMessage) {
+                output.errorMessage = stopReasonResult.errorMessage;
+            }
+        }
+        const delta = choice.delta;
+        if (delta.content !== null && delta.content !== undefined) {
+            const contentItems = typeof delta.content === "string" ? [delta.content] : delta.content;
+            for (const item of contentItems) {
+                if (typeof item === "string") {
+                    const textDelta = andorraSanitizeSurrogates(item);
+                    if (!currentBlock || currentBlock.type !== "text") {
+                        andorraFinishCurrentBlock(currentBlock);
+                        currentBlock = { type: "text", text: "" };
+                        output.content.push(currentBlock);
+                        stream.push({ type: "text_start", contentIndex: andorraBlockIndex(), partial: output });
+                    }
+                    currentBlock.text += textDelta;
+                    stream.push({
+                        type: "text_delta",
+                        contentIndex: andorraBlockIndex(),
+                        delta: textDelta,
+                        partial: output,
+                    });
+                    continue;
+                }
+                if (item.type === "thinking") {
+                    const deltaText = (item.thinking ?? [])
+                        .map((part) => part.text ?? "")
+                        .filter((text) => text.length > 0)
+                        .join("");
+                    const thinkingDelta = andorraSanitizeSurrogates(deltaText);
+                    if (!thinkingDelta)
+                        continue;
+                    if (!currentBlock || currentBlock.type !== "thinking") {
+                        andorraFinishCurrentBlock(currentBlock);
+                        currentBlock = { type: "thinking", thinking: "" };
+                        output.content.push(currentBlock);
+                        stream.push({ type: "thinking_start", contentIndex: andorraBlockIndex(), partial: output });
+                    }
+                    currentBlock.thinking += thinkingDelta;
+                    stream.push({
+                        type: "thinking_delta",
+                        contentIndex: andorraBlockIndex(),
+                        delta: thinkingDelta,
+                        partial: output,
+                    });
+                    continue;
+                }
+                if (item.type === "text") {
+                    const textDelta = andorraSanitizeSurrogates(item.text ?? "");
+                    if (!currentBlock || currentBlock.type !== "text") {
+                        andorraFinishCurrentBlock(currentBlock);
+                        currentBlock = { type: "text", text: "" };
+                        output.content.push(currentBlock);
+                        stream.push({ type: "text_start", contentIndex: andorraBlockIndex(), partial: output });
+                    }
+                    currentBlock.text += textDelta;
+                    stream.push({
+                        type: "text_delta",
+                        contentIndex: andorraBlockIndex(),
+                        delta: textDelta,
+                        partial: output,
+                    });
+                }
+            }
+        }
+        const toolCalls = delta.tool_calls || [];
+        for (const toolCall of toolCalls) {
+            if (currentBlock) {
+                andorraFinishCurrentBlock(currentBlock);
+                currentBlock = null;
+            }
+            const callId = toolCall.id && toolCall.id !== "null"
+                ? toolCall.id
+                : andorraDeriveMistralToolCallId(`toolcall:${toolCall.index ?? 0}`, 0);
+            const key = toolCall.index ?? callId;
+            const existingIndex = toolBlocksByKey.get(key);
+            let block;
+            if (existingIndex !== undefined) {
+                const existing = output.content[existingIndex];
+                if (existing?.type === "toolCall") {
+                    block = existing;
+                }
+            }
+            if (!block) {
+                block = {
+                    type: "toolCall",
+                    id: callId,
+                    name: toolCall.function.name,
+                    arguments: {},
+                    partialArgs: "",
+                };
+                output.content.push(block);
+                toolBlocksByKey.set(key, output.content.length - 1);
+                stream.push({ type: "toolcall_start", contentIndex: output.content.length - 1, partial: output });
+            }
+            const argsDelta = typeof toolCall.function.arguments === "string"
+                ? toolCall.function.arguments
+                : JSON.stringify(toolCall.function.arguments || {});
+            block.partialArgs = (block.partialArgs || "") + argsDelta;
+            block.arguments = andorraParseStreamingJson(block.partialArgs);
+            stream.push({
+                type: "toolcall_delta",
+                contentIndex: toolBlocksByKey.get(key),
+                delta: argsDelta,
+                partial: output,
+            });
+        }
+    }
+    andorraFinishCurrentBlock(currentBlock);
+    for (const index of toolBlocksByKey.values()) {
+        const block = output.content[index];
+        if (block.type !== "toolCall")
+            continue;
+        const toolBlock = block;
+        toolBlock.arguments = andorraParseStreamingJson(toolBlock.partialArgs);
+        // Finalize in-place and strip the scratch buffer so replay only
+        // carries parsed arguments.
+        delete toolBlock.partialArgs;
+        stream.push({
+            type: "toolcall_end",
+            contentIndex: index,
+            toolCall: toolBlock,
+            partial: output,
+        });
+    }
+}
+function andorraToFunctionTools(tools) {
+    return tools.map((tool) => {
+        const strict = andorraResolveJsonSchemaStrictSampling(tool, true);
+        return {
+            type: "function",
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: andorraStripSymbolKeys(andorraGetJsonSchemaToolParameters(tool, strict)),
+                strict: strict ?? false,
+            },
+        };
+    });
+}
+function andorraStripSymbolKeys(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => andorraStripSymbolKeys(item));
+    }
+    if (value && typeof value === "object") {
+        const result = {};
+        for (const [key, entry] of Object.entries(value)) {
+            result[key] = andorraStripSymbolKeys(entry);
+        }
+        return result;
+    }
+    return value;
+}
+function andorraToChatMessages(messages, supportsImages) {
+    const result = [];
+    for (const [index, msg] of messages.entries()) {
+        if (msg.role === "system") {
+            const text = index === 0 ? andorraGetSystemMessageText(msg) : andorraRenderSystemMessageUpdate(msg);
+            if (text.length > 0)
+                result.push({ role: "system", content: andorraSanitizeSurrogates(text) });
+            continue;
+        }
+        if (msg.role === "user") {
+            if (typeof msg.content === "string") {
+                result.push({ role: "user", content: andorraSanitizeSurrogates(msg.content) });
+                continue;
+            }
+            const hadImages = msg.content.some((item) => item.type === "image");
+            const content = msg.content
+                .filter((item) => item.type === "text" || supportsImages)
+                .map((item) => {
+                if (item.type === "text")
+                    return { type: "text", text: andorraSanitizeSurrogates(item.text) };
+                return { type: "image_url", imageUrl: `data:${item.mimeType};base64,${item.data}` };
+            });
+            if (content.length > 0) {
+                result.push({ role: "user", content });
+                continue;
+            }
+            if (hadImages && !supportsImages) {
+                result.push({ role: "user", content: "(image omitted: model does not support images)" });
+            }
+            continue;
+        }
+        if (msg.role === "assistant") {
+            const contentParts = [];
+            const toolCalls = [];
+            for (const block of msg.content) {
+                if (block.type === "text") {
+                    if (block.text.trim().length > 0) {
+                        contentParts.push({ type: "text", text: andorraSanitizeSurrogates(block.text) });
+                    }
+                    continue;
+                }
+                if (block.type === "thinking") {
+                    if (block.thinking.trim().length > 0) {
+                        contentParts.push({
+                            type: "thinking",
+                            thinking: [{ type: "text", text: andorraSanitizeSurrogates(block.thinking) }],
+                        });
+                    }
+                    continue;
+                }
+                toolCalls.push({
+                    id: block.id,
+                    type: "function",
+                    function: { name: block.name, arguments: JSON.stringify(block.arguments || {}) },
+                    index: 0,
+                });
+            }
+            const assistantMessage = { role: "assistant", prefix: false };
+            if (contentParts.length > 0)
+                assistantMessage.content = contentParts;
+            if (toolCalls.length > 0)
+                assistantMessage.toolCalls = toolCalls;
+            if (contentParts.length > 0 || toolCalls.length > 0)
+                result.push(assistantMessage);
+            continue;
+        }
+        const toolContent = [];
+        const textResult = msg.content
+            .filter((part) => part.type === "text")
+            .map((part) => (part.type === "text" ? andorraSanitizeSurrogates(part.text) : ""))
+            .join("\n");
+        const hasImages = msg.content.some((part) => part.type === "image");
+        const toolText = andorraBuildToolResultText(textResult, hasImages, supportsImages, msg.isError);
+        toolContent.push({ type: "text", text: toolText });
+        for (const part of msg.content) {
+            if (!supportsImages)
+                continue;
+            if (part.type !== "image")
+                continue;
+            toolContent.push({
+                type: "image_url",
+                imageUrl: `data:${part.mimeType};base64,${part.data}`,
+            });
+        }
+        result.push({
+            role: "tool",
+            toolCallId: msg.toolCallId,
+            name: msg.toolName,
+            content: toolContent,
+        });
+    }
+    return result;
+}
+function andorraBuildToolResultText(text, hasImages, supportsImages, isError) {
+    const trimmed = text.trim();
+    const errorPrefix = isError ? "[tool error] " : "";
+    if (trimmed.length > 0) {
+        const imageSuffix = hasImages && !supportsImages ? "\n[tool image omitted: model does not support images]" : "";
+        return `${errorPrefix}${trimmed}${imageSuffix}`;
+    }
+    if (hasImages) {
+        if (supportsImages) {
+            return isError ? "[tool error] (see attached image)" : "(see attached image)";
+        }
+        return isError
+            ? "[tool error] (image omitted: model does not support images)"
+            : "(image omitted: model does not support images)";
+    }
+    return isError ? "[tool error] (no tool output)" : "(no tool output)";
+}
+function andorraUsesReasoningEffort(model) {
+    return (model.id === "mistral-small-2603" ||
+        model.id === "mistral-small-latest" ||
+        model.id.startsWith("mistral-medium-") ||
+        model.id === "zai-glm-5-2");
+}
+function andorraUsesPromptModeReasoning(model) {
+    return model.reasoning && !andorraUsesReasoningEffort(model);
+}
+function andorraMapReasoningEffort(model, level) {
+    return (model.thinkingLevelMap?.[level] ?? "high");
+}
+function andorraMapToolChoice(choice) {
+    if (!choice)
+        return undefined;
+    if (choice === "auto" || choice === "none" || choice === "any" || choice === "required") {
+        return choice;
+    }
+    return {
+        type: "function",
+        function: { name: choice.function.name },
+    };
+}
+function andorraMapChatStopReason(reason) {
+    if (reason === null)
+        return { stopReason: "stop" };
+    switch (reason) {
+        case "stop":
+            return { stopReason: "stop" };
+        case "length":
+        case "model_length":
+            return { stopReason: "length" };
+        case "tool_calls":
+            return { stopReason: "toolUse" };
+        case "error":
+            return { stopReason: "error", errorMessage: "Provider stopped with: error" };
+        default:
+            return { stopReason: "error", errorMessage: `Provider stopped with: ${reason}` };
+    }
+}