indusagi 0.12.18 → 0.12.20

package/dist/ai/providers/openai-completions.js

@@ -47,6 +47,7 @@ function hasToolHistory(messages) {
     return false;
 }
 export class OpenAICompatibilityAdapter {
+    model;
     constructor(model) {
         this.model = model;
     }
@@ -65,6 +66,7 @@ export class OpenAICompatibilityAdapter {
  * standardized assistant events.
  */
 class OpenAICompletionsStreamHandler extends BaseStreamHandler {
+    executeFn;
     constructor(executeFn) {
         super();
         this.executeFn = executeFn;
@@ -76,6 +78,209 @@ class OpenAICompletionsStreamHandler extends BaseStreamHandler {
         await this.executeFn();
     }
 }
+class CompletionsBlockLifecycle {
+    output;
+    stream;
+    activeBlock = null;
+    constructor(output, stream) {
+        this.output = output;
+        this.stream = stream;
+    }
+    finalizeCurrent() {
+        if (!this.activeBlock)
+            return;
+        const currentIndex = this.output.content.length - 1;
+        if (this.activeBlock.type === "text") {
+            this.stream.push({
+                type: "text_end",
+                contentIndex: currentIndex,
+                content: this.activeBlock.text,
+                partial: this.output,
+            });
+        }
+        else if (this.activeBlock.type === "thinking") {
+            this.stream.push({
+                type: "thinking_end",
+                contentIndex: currentIndex,
+                content: this.activeBlock.thinking,
+                partial: this.output,
+            });
+        }
+        else {
+            this.activeBlock.arguments = JSON.parse(this.activeBlock.partialArgs || "{}");
+            delete this.activeBlock.partialArgs;
+            this.stream.push({
+                type: "toolcall_end",
+                contentIndex: currentIndex,
+                toolCall: this.activeBlock,
+                partial: this.output,
+            });
+        }
+    }
+    applyTextDelta(deltaText) {
+        if (!deltaText)
+            return;
+        if (!this.activeBlock || this.activeBlock.type !== "text") {
+            this.finalizeCurrent();
+            this.activeBlock = { type: "text", text: "" };
+            this.output.content.push(this.activeBlock);
+            this.stream.push({ type: "text_start", contentIndex: this.output.content.length - 1, partial: this.output });
+        }
+        if (this.activeBlock.type === "text") {
+            this.activeBlock.text += deltaText;
+            this.stream.push({
+                type: "text_delta",
+                contentIndex: this.output.content.length - 1,
+                delta: deltaText,
+                partial: this.output,
+            });
+        }
+    }
+    applyThinkingDelta(reasoningField, deltaText) {
+        if (!deltaText)
+            return;
+        if (!this.activeBlock || this.activeBlock.type !== "thinking") {
+            this.finalizeCurrent();
+            this.activeBlock = {
+                type: "thinking",
+                thinking: "",
+                thinkingSignature: reasoningField,
+            };
+            this.output.content.push(this.activeBlock);
+            this.stream.push({
+                type: "thinking_start",
+                contentIndex: this.output.content.length - 1,
+                partial: this.output,
+            });
+        }
+        if (this.activeBlock.type === "thinking") {
+            this.activeBlock.thinking += deltaText;
+            this.stream.push({
+                type: "thinking_delta",
+                contentIndex: this.output.content.length - 1,
+                delta: deltaText,
+                partial: this.output,
+            });
+        }
+    }
+    applyToolCallDelta(toolCall) {
+        if (!this.activeBlock ||
+            this.activeBlock.type !== "toolCall" ||
+            (toolCall.id && this.activeBlock.id !== toolCall.id)) {
+            this.finalizeCurrent();
+            this.activeBlock = {
+                type: "toolCall",
+                id: toolCall.id || "",
+                name: toolCall.function?.name || "",
+                arguments: {},
+                partialArgs: "",
+            };
+            this.output.content.push(this.activeBlock);
+            this.stream.push({
+                type: "toolcall_start",
+                contentIndex: this.output.content.length - 1,
+                partial: this.output,
+            });
+        }
+        if (this.activeBlock.type === "toolCall") {
+            if (toolCall.id)
+                this.activeBlock.id = toolCall.id;
+            if (toolCall.function?.name)
+                this.activeBlock.name = toolCall.function.name;
+            let argumentDelta = "";
+            if (toolCall.function?.arguments) {
+                argumentDelta = toolCall.function.arguments;
+                this.activeBlock.partialArgs += toolCall.function.arguments;
+                this.activeBlock.arguments = parseStreamingJson(this.activeBlock.partialArgs);
+            }
+            this.stream.push({
+                type: "toolcall_delta",
+                contentIndex: this.output.content.length - 1,
+                delta: argumentDelta,
+                partial: this.output,
+            });
+        }
+    }
+    attachReasoningDetails(reasoningDetails) {
+        if (!Array.isArray(reasoningDetails))
+            return;
+        for (const detail of reasoningDetails) {
+            if (detail?.type === "reasoning.encrypted" && detail?.id && detail?.data) {
+                const matchingToolCall = this.output.content.find((b) => b.type === "toolCall" && b.id === detail.id);
+                if (matchingToolCall) {
+                    matchingToolCall.thoughtSignature = JSON.stringify(detail);
+                }
+            }
+        }
+    }
+}
+class CompletionsChunkRouter {
+    model;
+    output;
+    lifecycle;
+    static REASONING_FIELDS = ["reasoning_content", "reasoning", "reasoning_text"];
+    constructor(model, output, lifecycle) {
+        this.model = model;
+        this.output = output;
+        this.lifecycle = lifecycle;
+    }
+    applyUsage(chunk) {
+        if (!chunk.usage)
+            return;
+        const cachedTokens = chunk.usage.prompt_tokens_details?.cached_tokens || 0;
+        const reasoningTokens = chunk.usage.completion_tokens_details?.reasoning_tokens || 0;
+        const input = (chunk.usage.prompt_tokens || 0) - cachedTokens;
+        const outputTokens = (chunk.usage.completion_tokens || 0) + reasoningTokens;
+        this.output.usage = {
+            input,
+            output: outputTokens,
+            cacheRead: cachedTokens,
+            cacheWrite: 0,
+            totalTokens: input + outputTokens + cachedTokens,
+            cost: {
+                input: 0,
+                output: 0,
+                cacheRead: 0,
+                cacheWrite: 0,
+                total: 0,
+            },
+        };
+        calculateCost(this.model, this.output.usage);
+    }
+    applyFinishReason(choice) {
+        if (choice.finish_reason) {
+            this.output.stopReason = mapProviderStopReason(choice.finish_reason, "openai-completions");
+        }
+    }
+    applyChoiceDelta(choice) {
+        const delta = choice.delta;
+        if (!delta)
+            return;
+        if (delta.content) {
+            this.lifecycle.applyTextDelta(delta.content);
+        }
+        const reasoningField = this.resolveReasoningField(delta);
+        if (reasoningField) {
+            const reasoningDelta = delta[reasoningField];
+            this.lifecycle.applyThinkingDelta(reasoningField, reasoningDelta);
+        }
+        if (delta.tool_calls) {
+            for (const toolCall of delta.tool_calls) {
+                this.lifecycle.applyToolCallDelta(toolCall);
+            }
+        }
+        this.lifecycle.attachReasoningDetails(delta.reasoning_details);
+    }
+    resolveReasoningField(delta) {
+        for (const field of CompletionsChunkRouter.REASONING_FIELDS) {
+            const value = delta[field];
+            if (value !== null && value !== undefined && value.length > 0) {
+                return field;
+            }
+        }
+        return null;
+    }
+}
 export const streamOpenAICompletions = (model, context, options) => {
     const stream = new AssistantMessageEventStream();
     const output = createAssistantMessageOutput(model);
@@ -93,178 +298,17 @@ export const streamOpenAICompletions = (model, context, options) => {
                 baseDelayMs: options?.retryPolicy?.baseDelayMs ?? 250,
             });
             events.start();
-            let currentBlock = null;
-            const blocks = output.content;
-            const blockIndex = () => blocks.length - 1;
-            const finishCurrentBlock = (block) => {
-                if (block) {
-                    if (block.type === "text") {
-                        stream.push({
-                            type: "text_end",
-                            contentIndex: blockIndex(),
-                            content: block.text,
-                            partial: output,
-                        });
-                    }
-                    else if (block.type === "thinking") {
-                        stream.push({
-                            type: "thinking_end",
-                            contentIndex: blockIndex(),
-                            content: block.thinking,
-                            partial: output,
-                        });
-                    }
-                    else if (block.type === "toolCall") {
-                        block.arguments = JSON.parse(block.partialArgs || "{}");
-                        delete block.partialArgs;
-                        stream.push({
-                            type: "toolcall_end",
-                            contentIndex: blockIndex(),
-                            toolCall: block,
-                            partial: output,
-                        });
-                    }
-                }
-            };
+            const lifecycle = new CompletionsBlockLifecycle(output, stream);
+            const chunkRouter = new CompletionsChunkRouter(model, output, lifecycle);
             for await (const chunk of openaiStream) {
-                if (chunk.usage) {
-                    const cachedTokens = chunk.usage.prompt_tokens_details?.cached_tokens || 0;
-                    const reasoningTokens = chunk.usage.completion_tokens_details?.reasoning_tokens || 0;
-                    const input = (chunk.usage.prompt_tokens || 0) - cachedTokens;
-                    const outputTokens = (chunk.usage.completion_tokens || 0) + reasoningTokens;
-                    output.usage = {
-                        // OpenAI includes cached tokens in prompt_tokens, so subtract to get non-cached input
-                        input,
-                        output: outputTokens,
-                        cacheRead: cachedTokens,
-                        cacheWrite: 0,
-                        // Compute totalTokens ourselves since we add reasoning_tokens to output
-                        // and some providers (e.g., Groq) don't include them in total_tokens
-                        totalTokens: input + outputTokens + cachedTokens,
-                        cost: {
-                            input: 0,
-                            output: 0,
-                            cacheRead: 0,
-                            cacheWrite: 0,
-                            total: 0,
-                        },
-                    };
-                    calculateCost(model, output.usage);
-                }
+                chunkRouter.applyUsage(chunk);
                 const choice = chunk.choices[0];
                 if (!choice)
                     continue;
-                if (choice.finish_reason) {
-                    output.stopReason = mapProviderStopReason(choice.finish_reason, "openai-completions");
-                }
-                if (choice.delta) {
-                    if (choice.delta.content !== null &&
-                        choice.delta.content !== undefined &&
-                        choice.delta.content.length > 0) {
-                        if (!currentBlock || currentBlock.type !== "text") {
-                            finishCurrentBlock(currentBlock);
-                            currentBlock = { type: "text", text: "" };
-                            output.content.push(currentBlock);
-                            stream.push({ type: "text_start", contentIndex: blockIndex(), partial: output });
-                        }
-                        if (currentBlock.type === "text") {
-                            currentBlock.text += choice.delta.content;
-                            stream.push({
-                                type: "text_delta",
-                                contentIndex: blockIndex(),
-                                delta: choice.delta.content,
-                                partial: output,
-                            });
-                        }
-                    }
-                    // Some endpoints return reasoning in reasoning_content (llama.cpp),
-                    // or reasoning (other openai compatible endpoints)
-                    // Use the first non-empty reasoning field to avoid duplication
-                    // (e.g., chutes.ai returns both reasoning_content and reasoning with same content)
-                    const reasoningFields = ["reasoning_content", "reasoning", "reasoning_text"];
-                    let foundReasoningField = null;
-                    for (const field of reasoningFields) {
-                        if (choice.delta[field] !== null &&
-                            choice.delta[field] !== undefined &&
-                            choice.delta[field].length > 0) {
-                            if (!foundReasoningField) {
-                                foundReasoningField = field;
-                                break;
-                            }
-                        }
-                    }
-                    if (foundReasoningField) {
-                        if (!currentBlock || currentBlock.type !== "thinking") {
-                            finishCurrentBlock(currentBlock);
-                            currentBlock = {
-                                type: "thinking",
-                                thinking: "",
-                                thinkingSignature: foundReasoningField,
-                            };
-                            output.content.push(currentBlock);
-                            stream.push({ type: "thinking_start", contentIndex: blockIndex(), partial: output });
-                        }
-                        if (currentBlock.type === "thinking") {
-                            const delta = choice.delta[foundReasoningField];
-                            currentBlock.thinking += delta;
-                            stream.push({
-                                type: "thinking_delta",
-                                contentIndex: blockIndex(),
-                                delta,
-                                partial: output,
-                            });
-                        }
-                    }
-                    if (choice?.delta?.tool_calls) {
-                        for (const toolCall of choice.delta.tool_calls) {
-                            if (!currentBlock ||
-                                currentBlock.type !== "toolCall" ||
-                                (toolCall.id && currentBlock.id !== toolCall.id)) {
-                                finishCurrentBlock(currentBlock);
-                                currentBlock = {
-                                    type: "toolCall",
-                                    id: toolCall.id || "",
-                                    name: toolCall.function?.name || "",
-                                    arguments: {},
-                                    partialArgs: "",
-                                };
-                                output.content.push(currentBlock);
-                                stream.push({ type: "toolcall_start", contentIndex: blockIndex(), partial: output });
-                            }
-                            if (currentBlock.type === "toolCall") {
-                                if (toolCall.id)
-                                    currentBlock.id = toolCall.id;
-                                if (toolCall.function?.name)
-                                    currentBlock.name = toolCall.function.name;
-                                let delta = "";
-                                if (toolCall.function?.arguments) {
-                                    delta = toolCall.function.arguments;
-                                    currentBlock.partialArgs += toolCall.function.arguments;
-                                    currentBlock.arguments = parseStreamingJson(currentBlock.partialArgs);
-                                }
-                                stream.push({
-                                    type: "toolcall_delta",
-                                    contentIndex: blockIndex(),
-                                    delta,
-                                    partial: output,
-                                });
-                            }
-                        }
-                    }
-                    const reasoningDetails = choice.delta.reasoning_details;
-                    if (reasoningDetails && Array.isArray(reasoningDetails)) {
-                        for (const detail of reasoningDetails) {
-                            if (detail.type === "reasoning.encrypted" && detail.id && detail.data) {
-                                const matchingToolCall = output.content.find((b) => b.type === "toolCall" && b.id === detail.id);
-                                if (matchingToolCall) {
-                                    matchingToolCall.thoughtSignature = JSON.stringify(detail);
-                                }
-                            }
-                        }
-                    }
-                }
+                chunkRouter.applyFinishReason(choice);
+                chunkRouter.applyChoiceDelta(choice);
             }
-            finishCurrentBlock(currentBlock);
+            lifecycle.finalizeCurrent();
             if (options?.signal?.aborted) {
                 throw new Error("Request was aborted");
             }
@@ -423,218 +467,253 @@ function maybeAddOpenRouterAnthropicCacheControl(model, messages) {
         }
     }
 }
-export function convertMessages(model, context, compat) {
-    const params = [];
-    const normalizeToolCallId = (id) => {
-        if (compat.requiresMistralToolIds)
-            return normalizeMistralToolId(id);
-        if (model.provider === "openai")
-            return id.length > 40 ? id.slice(0, 40) : id;
-        // Copilot Claude models route to Claude backend which requires Anthropic ID format
-        if (model.provider === "github-copilot" && model.id.toLowerCase().includes("claude")) {
-            return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+class UserMessageTransformer {
+    model;
+    constructor(model) {
+        this.model = model;
+    }
+    transform(message) {
+        if (typeof message.content === "string") {
+            return {
+                role: "user",
+                content: sanitizeSurrogates(message.content),
+            };
         }
-        return id;
-    };
-    const transformedMessages = transformMessages(context.messages, model, (id) => normalizeToolCallId(id));
-    if (context.systemPrompt) {
-        const useDeveloperRole = model.reasoning && compat.supportsDeveloperRole;
-        const role = useDeveloperRole ? "developer" : "system";
-        params.push({ role: role, content: sanitizeSurrogates(context.systemPrompt) });
-    }
-    let lastRole = null;
-    for (let i = 0; i < transformedMessages.length; i++) {
-        const msg = transformedMessages[i];
-        // Some providers (e.g. Mistral/Devstral) don't allow user messages directly after tool results
-        // Insert a synthetic assistant message to bridge the gap
-        if (compat.requiresAssistantAfterToolResult && lastRole === "toolResult" && msg.role === "user") {
-            params.push({
-                role: "assistant",
-                content: "I have processed the tool results.",
-            });
+        const contentParts = message.content.map((item) => {
+            if (item.type === "text") {
+                return {
+                    type: "text",
+                    text: sanitizeSurrogates(item.text),
+                };
+            }
+            return {
+                type: "image_url",
+                image_url: {
+                    url: `data:${item.mimeType};base64,${item.data}`,
+                },
+            };
+        });
+        const filteredParts = !this.model.input.includes("image")
+            ? contentParts.filter((part) => part.type !== "image_url")
+            : contentParts;
+        if (filteredParts.length === 0) {
+            return undefined;
         }
-        if (msg.role === "user") {
-            if (typeof msg.content === "string") {
-                params.push({
-                    role: "user",
-                    content: sanitizeSurrogates(msg.content),
-                });
+        return {
+            role: "user",
+            content: filteredParts,
+        };
+    }
+}
+class AssistantMessageTransformer {
+    model;
+    compat;
+    constructor(model, compat) {
+        this.model = model;
+        this.compat = compat;
+    }
+    transform(message) {
+        const assistantMessage = {
+            role: "assistant",
+            content: this.compat.requiresAssistantAfterToolResult ? "" : null,
+        };
+        const textBlocks = message.content.filter((block) => block.type === "text");
+        const nonEmptyTextBlocks = textBlocks.filter((block) => block.text && block.text.trim().length > 0);
+        if (nonEmptyTextBlocks.length > 0) {
+            if (this.model.provider === "github-copilot") {
+                assistantMessage.content = nonEmptyTextBlocks.map((block) => sanitizeSurrogates(block.text)).join("");
             }
             else {
-                const content = msg.content.map((item) => {
-                    if (item.type === "text") {
-                        return {
-                            type: "text",
-                            text: sanitizeSurrogates(item.text),
-                        };
-                    }
-                    else {
-                        return {
-                            type: "image_url",
-                            image_url: {
-                                url: `data:${item.mimeType};base64,${item.data}`,
-                            },
-                        };
-                    }
-                });
-                const filteredContent = !model.input.includes("image")
-                    ? content.filter((c) => c.type !== "image_url")
-                    : content;
-                if (filteredContent.length === 0)
-                    continue;
-                params.push({
-                    role: "user",
-                    content: filteredContent,
-                });
+                assistantMessage.content = nonEmptyTextBlocks.map((block) => ({
+                    type: "text",
+                    text: sanitizeSurrogates(block.text),
+                }));
             }
         }
-        else if (msg.role === "assistant") {
-            // Some providers (e.g. Mistral) don't accept null content, use empty string instead
-            const assistantMsg = {
-                role: "assistant",
-                content: compat.requiresAssistantAfterToolResult ? "" : null,
-            };
-            const textBlocks = msg.content.filter((b) => b.type === "text");
-            // Filter out empty text blocks to avoid API validation errors
-            const nonEmptyTextBlocks = textBlocks.filter((b) => b.text && b.text.trim().length > 0);
-            if (nonEmptyTextBlocks.length > 0) {
-                // GitHub Copilot requires assistant content as a string, not an array.
-                // Sending as array causes Claude models to re-answer all previous prompts.
-                if (model.provider === "github-copilot") {
-                    assistantMsg.content = nonEmptyTextBlocks.map((b) => sanitizeSurrogates(b.text)).join("");
+        const thinkingBlocks = message.content.filter((block) => block.type === "thinking");
+        const nonEmptyThinkingBlocks = thinkingBlocks.filter((block) => block.thinking && block.thinking.trim().length > 0);
+        if (nonEmptyThinkingBlocks.length > 0) {
+            this.applyThinkingBlocks(assistantMessage, nonEmptyThinkingBlocks);
+        }
+        const toolCalls = message.content.filter((block) => block.type === "toolCall");
+        if (toolCalls.length > 0) {
+            assistantMessage.tool_calls = toolCalls.map((toolCall) => ({
+                id: toolCall.id,
+                type: "function",
+                function: {
+                    name: toolCall.name,
+                    arguments: JSON.stringify(toolCall.arguments),
+                },
+            }));
+            const reasoningDetails = toolCalls
+                .filter((toolCall) => toolCall.thoughtSignature)
+                .map((toolCall) => {
+                try {
+                    return JSON.parse(toolCall.thoughtSignature);
                 }
-                else {
-                    assistantMsg.content = nonEmptyTextBlocks.map((b) => {
-                        return { type: "text", text: sanitizeSurrogates(b.text) };
-                    });
+                catch {
+                    return null;
                 }
+            })
+                .filter(Boolean);
+            if (reasoningDetails.length > 0) {
+                assistantMessage.reasoning_details = reasoningDetails;
             }
-            // Handle thinking blocks
-            const thinkingBlocks = msg.content.filter((b) => b.type === "thinking");
-            // Filter out empty thinking blocks to avoid API validation errors
-            const nonEmptyThinkingBlocks = thinkingBlocks.filter((b) => b.thinking && b.thinking.trim().length > 0);
-            if (nonEmptyThinkingBlocks.length > 0) {
-                if (compat.requiresThinkingAsText) {
-                    // Convert thinking blocks to plain text (no tags to avoid model mimicking them)
-                    const thinkingText = nonEmptyThinkingBlocks.map((b) => b.thinking).join("\n\n");
-                    const textContent = assistantMsg.content;
-                    if (textContent) {
-                        textContent.unshift({ type: "text", text: thinkingText });
-                    }
-                    else {
-                        assistantMsg.content = [{ type: "text", text: thinkingText }];
-                    }
-                }
-                else {
-                    // Use the signature from the first thinking block if available (for llama.cpp server + gpt-oss)
-                    const signature = nonEmptyThinkingBlocks[0].thinkingSignature;
-                    if (signature && signature.length > 0) {
-                        assistantMsg[signature] = nonEmptyThinkingBlocks.map((b) => b.thinking).join("\n");
-                    }
-                }
+        }
+        const content = assistantMessage.content;
+        const hasContent = content !== null &&
+            content !== undefined &&
+            (typeof content === "string" ? content.length > 0 : content.length > 0);
+        if (!hasContent && !assistantMessage.tool_calls) {
+            return undefined;
+        }
+        return assistantMessage;
+    }
+    applyThinkingBlocks(assistantMessage, nonEmptyThinkingBlocks) {
+        if (this.compat.requiresThinkingAsText) {
+            const thinkingText = nonEmptyThinkingBlocks.map((block) => block.thinking).join("\n\n");
+            const textContent = assistantMessage.content;
+            if (textContent) {
+                textContent.unshift({ type: "text", text: thinkingText });
             }
-            const toolCalls = msg.content.filter((b) => b.type === "toolCall");
-            if (toolCalls.length > 0) {
-                assistantMsg.tool_calls = toolCalls.map((tc) => ({
-                    id: tc.id,
-                    type: "function",
-                    function: {
-                        name: tc.name,
-                        arguments: JSON.stringify(tc.arguments),
-                    },
-                }));
-                const reasoningDetails = toolCalls
-                    .filter((tc) => tc.thoughtSignature)
-                    .map((tc) => {
-                    try {
-                        return JSON.parse(tc.thoughtSignature);
-                    }
-                    catch {
-                        return null;
-                    }
-                })
-                    .filter(Boolean);
-                if (reasoningDetails.length > 0) {
-                    assistantMsg.reasoning_details = reasoningDetails;
-                }
+            else {
+                assistantMessage.content = [{ type: "text", text: thinkingText }];
             }
-            // Skip assistant messages that have no content and no tool calls.
-            // Mistral explicitly requires "either content or tool_calls, but not none".
-            // Other providers also don't accept empty assistant messages.
-            // This handles aborted assistant responses that got no content.
-            const content = assistantMsg.content;
-            const hasContent = content !== null &&
-                content !== undefined &&
-                (typeof content === "string" ? content.length > 0 : content.length > 0);
-            if (!hasContent && !assistantMsg.tool_calls) {
-                continue;
+            return;
+        }
+        const signature = nonEmptyThinkingBlocks[0].thinkingSignature;
+        if (signature && signature.length > 0) {
+            assistantMessage[signature] = nonEmptyThinkingBlocks.map((block) => block.thinking).join("\n");
+        }
+    }
+}
+class ToolResultTransformer {
+    model;
+    compat;
+    constructor(model, compat) {
+        this.model = model;
+        this.compat = compat;
+    }
+    transform(messages, startIndex) {
+        const params = [];
+        const imageBlocks = [];
+        let cursor = startIndex;
+        for (; cursor < messages.length && messages[cursor].role === "toolResult"; cursor++) {
+            const toolMessage = messages[cursor];
+            const textResult = toolMessage.content
+                .filter((entry) => entry.type === "text")
+                .map((entry) => entry.text)
+                .join("\n");
+            const hasImages = toolMessage.content.some((entry) => entry.type === "image");
+            const hasText = textResult.length > 0;
+            const toolResultMessage = {
+                role: "tool",
+                content: sanitizeSurrogates(hasText ? textResult : "(see attached image)"),
+                tool_call_id: toolMessage.toolCallId,
+            };
+            if (this.compat.requiresToolResultName && toolMessage.toolName) {
+                toolResultMessage.name = toolMessage.toolName;
             }
-            params.push(assistantMsg);
-        }
-        else if (msg.role === "toolResult") {
-            const imageBlocks = [];
-            let j = i;
-            for (; j < transformedMessages.length && transformedMessages[j].role === "toolResult"; j++) {
-                const toolMsg = transformedMessages[j];
-                // Extract text and image content
-                const textResult = toolMsg.content
-                    .filter((c) => c.type === "text")
-                    .map((c) => c.text)
-                    .join("\n");
-                const hasImages = toolMsg.content.some((c) => c.type === "image");
-                // Always send tool result with text (or placeholder if only images)
-                const hasText = textResult.length > 0;
-                // Some providers (e.g. Mistral) require the 'name' field in tool results
-                const toolResultMsg = {
-                    role: "tool",
-                    content: sanitizeSurrogates(hasText ? textResult : "(see attached image)"),
-                    tool_call_id: toolMsg.toolCallId,
-                };
-                if (compat.requiresToolResultName && toolMsg.toolName) {
-                    toolResultMsg.name = toolMsg.toolName;
-                }
-                params.push(toolResultMsg);
-                if (hasImages && model.input.includes("image")) {
-                    for (const block of toolMsg.content) {
-                        if (block.type === "image") {
-                            imageBlocks.push({
-                                type: "image_url",
-                                image_url: {
-                                    url: `data:${block.mimeType};base64,${block.data}`,
-                                },
-                            });
-                        }
+            params.push(toolResultMessage);
+            if (hasImages && this.model.input.includes("image")) {
+                for (const block of toolMessage.content) {
+                    if (block.type === "image") {
+                        imageBlocks.push({
+                            type: "image_url",
+                            image_url: {
+                                url: `data:${block.mimeType};base64,${block.data}`,
+                            },
+                        });
                     }
                 }
             }
-            i = j - 1;
-            if (imageBlocks.length > 0) {
-                if (compat.requiresAssistantAfterToolResult) {
-                    params.push({
-                        role: "assistant",
-                        content: "I have processed the tool results.",
-                    });
+        }
+        if (imageBlocks.length === 0) {
+            return { params, nextIndex: cursor - 1, lastRole: "toolResult" };
+        }
+        if (this.compat.requiresAssistantAfterToolResult) {
+            params.push({
+                role: "assistant",
+                content: "I have processed the tool results.",
+            });
+        }
+        params.push({
+            role: "user",
+            content: [
+                {
+                    type: "text",
+                    text: "Attached image(s) from tool result:",
+                },
+                ...imageBlocks,
+            ],
+        });
+        return { params, nextIndex: cursor - 1, lastRole: "user" };
+    }
+}
+class OpenAIMessageTransformer {
+    model;
+    context;
+    compat;
+    userTransformer;
+    assistantTransformer;
+    toolResultTransformer;
+    constructor(model, context, compat) {
+        this.model = model;
+        this.context = context;
+        this.compat = compat;
+        this.userTransformer = new UserMessageTransformer(model);
+        this.assistantTransformer = new AssistantMessageTransformer(model, compat);
+        this.toolResultTransformer = new ToolResultTransformer(model, compat);
+    }
+    transform() {
+        const params = [];
+        const transformedMessages = transformMessages(this.context.messages, this.model, (id) => this.normalizeToolCallId(id));
+        if (this.context.systemPrompt) {
+            const role = this.model.reasoning && this.compat.supportsDeveloperRole ? "developer" : "system";
+            params.push({ role, content: sanitizeSurrogates(this.context.systemPrompt) });
+        }
+        let lastRole = null;
+        for (let i = 0; i < transformedMessages.length; i++) {
+            const message = transformedMessages[i];
+            if (this.compat.requiresAssistantAfterToolResult && lastRole === "toolResult" && message.role === "user") {
+                params.push({ role: "assistant", content: "I have processed the tool results." });
+            }
+            if (message.role === "user") {
+                const transformed = this.userTransformer.transform(message);
+                if (transformed) {
+                    params.push(transformed);
+                    lastRole = "user";
                 }
-                params.push({
-                    role: "user",
-                    content: [
-                        {
-                            type: "text",
-                            text: "Attached image(s) from tool result:",
-                        },
-                        ...imageBlocks,
-                    ],
-                });
-                lastRole = "user";
+                continue;
             }
-            else {
-                lastRole = "toolResult";
+            if (message.role === "assistant") {
+                const transformed = this.assistantTransformer.transform(message);
+                if (transformed) {
+                    params.push(transformed);
+                    lastRole = "assistant";
+                }
+                continue;
             }
-            continue;
+            const toolResultBatch = this.toolResultTransformer.transform(transformedMessages, i);
+            params.push(...toolResultBatch.params);
+            i = toolResultBatch.nextIndex;
+            lastRole = toolResultBatch.lastRole;
         }
-        lastRole = msg.role;
+        return params;
     }
-    return params;
+    normalizeToolCallId(id) {
+        if (this.compat.requiresMistralToolIds)
+            return normalizeMistralToolId(id);
+        if (this.model.provider === "openai")
+            return id.length > 40 ? id.slice(0, 40) : id;
+        if (this.model.provider === "github-copilot" && this.model.id.toLowerCase().includes("claude")) {
+            return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+        }
+        return id;
+    }
+}
+export function convertMessages(model, context, compat) {
+    return new OpenAIMessageTransformer(model, context, compat).transform();
 }
 function convertTools(tools) {
     return tools.map((tool) => ({
@@ -669,59 +748,61 @@ function mapStopReason(reason) {
 /**
  * Detect compatibility settings from provider and baseUrl for known providers.
  * Provider takes precedence over URL-based detection since it's explicitly configured.
- * Returns a fully resolved OpenAICompletionsCompat object with all fields set.
  */
-function detectCompat(model) {
+function deriveCompatFromProvider(model) {
     const provider = model.provider;
     const baseUrl = model.baseUrl;
     const isZai = provider === "zai" || baseUrl.includes("api.z.ai");
-    const isNonStandard = provider === "cerebras" ||
+    const isMistral = provider === "mistral" || baseUrl.includes("mistral.ai");
+    const isGrok = provider === "xai" || baseUrl.includes("api.x.ai");
+    const isNonStandardProvider = provider === "cerebras" ||
         baseUrl.includes("cerebras.ai") ||
         provider === "xai" ||
         baseUrl.includes("api.x.ai") ||
-        provider === "mistral" ||
-        baseUrl.includes("mistral.ai") ||
+        isMistral ||
         baseUrl.includes("chutes.ai") ||
         isZai ||
         provider === "opencode" ||
         baseUrl.includes("opencode.ai");
-    const useMaxTokens = provider === "mistral" || baseUrl.includes("mistral.ai") || baseUrl.includes("chutes.ai");
-    const isGrok = provider === "xai" || baseUrl.includes("api.x.ai");
-    const isMistral = provider === "mistral" || baseUrl.includes("mistral.ai");
+    const useLegacyMaxTokensField = isMistral || baseUrl.includes("chutes.ai");
     return {
-        supportsStore: !isNonStandard,
-        supportsDeveloperRole: !isNonStandard,
+        supportsStore: !isNonStandardProvider,
+        supportsDeveloperRole: !isNonStandardProvider,
         supportsReasoningEffort: !isGrok && !isZai,
         supportsUsageInStreaming: true,
-        maxTokensField: useMaxTokens ? "max_tokens" : "max_completion_tokens",
+        maxTokensField: useLegacyMaxTokensField ? "max_tokens" : "max_completion_tokens",
         requiresToolResultName: isMistral,
-        requiresAssistantAfterToolResult: false, // Mistral no longer requires this as of Dec 2024
+        requiresAssistantAfterToolResult: false,
         requiresThinkingAsText: isMistral,
         requiresMistralToolIds: isMistral,
         thinkingFormat: isZai ? "zai" : "openai",
         openRouterRouting: {},
     };
 }
+function overlayCompatOverrides(base, overrides) {
+    if (!overrides) {
+        return base;
+    }
+    return {
+        supportsStore: overrides.supportsStore ?? base.supportsStore,
+        supportsDeveloperRole: overrides.supportsDeveloperRole ?? base.supportsDeveloperRole,
+        supportsReasoningEffort: overrides.supportsReasoningEffort ?? base.supportsReasoningEffort,
+        supportsUsageInStreaming: overrides.supportsUsageInStreaming ?? base.supportsUsageInStreaming,
+        maxTokensField: overrides.maxTokensField ?? base.maxTokensField,
+        requiresToolResultName: overrides.requiresToolResultName ?? base.requiresToolResultName,
+        requiresAssistantAfterToolResult: overrides.requiresAssistantAfterToolResult ?? base.requiresAssistantAfterToolResult,
+        requiresThinkingAsText: overrides.requiresThinkingAsText ?? base.requiresThinkingAsText,
+        requiresMistralToolIds: overrides.requiresMistralToolIds ?? base.requiresMistralToolIds,
+        thinkingFormat: overrides.thinkingFormat ?? base.thinkingFormat,
+        openRouterRouting: overrides.openRouterRouting ?? {},
+    };
+}
 /**
  * Get resolved compatibility settings for a model.
  * Uses explicit model.compat if provided, otherwise auto-detects from provider/URL.
  */
 function getCompat(model) {
-    const detected = detectCompat(model);
-    if (!model.compat)
-        return detected;
-    return {
-        supportsStore: model.compat.supportsStore ?? detected.supportsStore,
-        supportsDeveloperRole: model.compat.supportsDeveloperRole ?? detected.supportsDeveloperRole,
-        supportsReasoningEffort: model.compat.supportsReasoningEffort ?? detected.supportsReasoningEffort,
-        supportsUsageInStreaming: model.compat.supportsUsageInStreaming ?? detected.supportsUsageInStreaming,
-        maxTokensField: model.compat.maxTokensField ?? detected.maxTokensField,
-        requiresToolResultName: model.compat.requiresToolResultName ?? detected.requiresToolResultName,
-        requiresAssistantAfterToolResult: model.compat.requiresAssistantAfterToolResult ?? detected.requiresAssistantAfterToolResult,
-        requiresThinkingAsText: model.compat.requiresThinkingAsText ?? detected.requiresThinkingAsText,
-        requiresMistralToolIds: model.compat.requiresMistralToolIds ?? detected.requiresMistralToolIds,
-        thinkingFormat: model.compat.thinkingFormat ?? detected.thinkingFormat,
-        openRouterRouting: model.compat.openRouterRouting ?? {},
-    };
+    const derived = deriveCompatFromProvider(model);
+    return overlayCompatOverrides(derived, model.compat);
 }
 //# sourceMappingURL=openai-completions.js.map