indusagi 0.12.32 → 0.12.34

package/local-dist-new/ml/adapters/openai-completions.js

@@ -1,831 +0,0 @@
-import OpenAI from "openai";
-import { getEnvApiKey } from "../env-api-keys.js";
-import { calculateCost, supportsXhigh } from "../models.js";
-import { BaseStreamHandler } from "../kit/base-stream-handler.js";
-import { AssistantMessageEventStream } from "../kit/event-stream.js";
-import { createAssistantMessageOutput } from "../kit/output-factory.js";
-import { mapStopReason as mapProviderStopReason } from "../kit/provider-consolidation.js";
-import { BlockTracker, StreamEventHelper } from "../kit/stream-event-helper.js";
-import { parseStreamingJson } from "../kit/json-parse.js";
-import { sanitizeSurrogates } from "../kit/sanitize-unicode.js";
-import { buildBaseOptions, executeWithRetry, mapThinkingLevel } from "./simple-options.js";
-import { transformMessages } from "./transform-messages.js";
-/**
- * Normalize tool call ID for Mistral.
- * Mistral requires tool IDs to be exactly 9 alphanumeric characters (a-z, A-Z, 0-9).
- */
-function normalizeMistralToolId(id) {
-    // Remove non-alphanumeric characters
-    let normalized = id.replace(/[^a-zA-Z0-9]/g, "");
-    // Mistral requires exactly 9 characters
-    if (normalized.length < 9) {
-        // Pad with deterministic characters based on original ID to ensure matching
-        const padding = "ABCDEFGHI";
-        normalized = normalized + padding.slice(0, 9 - normalized.length);
-    }
-    else if (normalized.length > 9) {
-        normalized = normalized.slice(0, 9);
-    }
-    return normalized;
-}
-/**
- * Check if conversation messages contain tool calls or tool results.
- * This is needed because Anthropic (via proxy) requires the tools param
- * to be present when messages include tool_calls or tool role messages.
- */
-function hasToolHistory(messages) {
-    for (const msg of messages) {
-        if (msg.role === "toolResult") {
-            return true;
-        }
-        if (msg.role === "assistant") {
-            if (msg.content.some((block) => block.type === "toolCall")) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-export class OpenAICompatibilityAdapter {
-    model;
-    constructor(model) {
-        this.model = model;
-    }
-    resolveCompat() {
-        return getCompat(this.model);
-    }
-    normalizeToolCallId(id) {
-        const compat = this.resolveCompat();
-        return compat.requiresMistralToolIds ? normalizeMistralToolId(id) : id;
-    }
-}
-/**
- * OpenAI Completions stream handler.
- *
- * Processes streaming responses from OpenAI-compatible endpoints and emits
- * standardized assistant events.
- */
-class OpenAICompletionsStreamHandler extends BaseStreamHandler {
-    executeFn;
-    constructor(executeFn) {
-        super();
-        this.executeFn = executeFn;
-    }
-    /**
-     * Execute the stream by invoking the provided async function.
-     */
-    async processStream() {
-        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);
-    const events = new StreamEventHelper(stream, output);
-    const tracker = new BlockTracker(output);
-    void tracker;
-    const handler = new OpenAICompletionsStreamHandler(async () => {
-        try {
-            const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
-            const client = createClient(model, context, apiKey, options?.headers);
-            const params = buildParams(model, context, options);
-            options?.onPayload?.(params);
-            const openaiStream = await executeWithRetry(() => client.chat.completions.create(params, { signal: options?.signal }), {
-                maxAttempts: options?.signal ? 1 : (options?.retryPolicy?.maxAttempts ?? 3),
-                baseDelayMs: options?.retryPolicy?.baseDelayMs ?? 250,
-            });
-            events.start();
-            const lifecycle = new CompletionsBlockLifecycle(output, stream);
-            const chunkRouter = new CompletionsChunkRouter(model, output, lifecycle);
-            for await (const chunk of openaiStream) {
-                chunkRouter.applyUsage(chunk);
-                const choice = chunk.choices[0];
-                if (!choice)
-                    continue;
-                chunkRouter.applyFinishReason(choice);
-                chunkRouter.applyChoiceDelta(choice);
-            }
-            lifecycle.finalizeCurrent();
-            if (options?.signal?.aborted) {
-                throw new Error("Request was aborted");
-            }
-            if (output.stopReason === "aborted" || output.stopReason === "error") {
-                throw new Error("An unknown error occurred");
-            }
-            stream.pushDone(output.stopReason, output);
-            stream.end();
-        }
-        catch (error) {
-            for (const block of output.content)
-                delete block.index;
-            output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-            output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
-            // Some providers via OpenRouter give additional information in this field.
-            const rawMetadata = error?.error?.metadata?.raw;
-            if (rawMetadata)
-                output.errorMessage += `\n${rawMetadata}`;
-            stream.pushError(output.stopReason, output);
-            stream.end();
-        }
-    });
-    void handler.run();
-    return stream;
-};
-export const streamSimpleOpenAICompletions = (model, context, options) => {
-    const apiKey = options?.apiKey || getEnvApiKey(model.provider);
-    if (!apiKey) {
-        throw new Error(`No API key for provider: ${model.provider}`);
-    }
-    const base = buildBaseOptions(model, options, apiKey);
-    const reasoningEffort = mapThinkingLevel(options?.reasoning, supportsXhigh(model) ? "supports-xhigh" : "clamp-xhigh");
-    return streamOpenAICompletions(model, context, {
-        ...base,
-        reasoningEffort,
-    });
-};
-function resolveProviderDefaultHeaders(model) {
-    if (model.provider === "sarvam" || model.baseUrl.includes("api.sarvam.ai")) {
-        const subscriptionKey = process.env.SARVAM_SUBSCRIPTION_KEY;
-        return subscriptionKey ? { "api-subscription-key": subscriptionKey } : {};
-    }
-    return {};
-}
-function createClient(model, context, apiKey, optionsHeaders) {
-    if (!apiKey) {
-        if (!process.env.OPENAI_API_KEY) {
-            throw new Error("OpenAI API key is required. Set OPENAI_API_KEY environment variable or pass it as an argument.");
-        }
-        apiKey = process.env.OPENAI_API_KEY;
-    }
-    const headers = {
-        ...model.headers,
-        ...resolveProviderDefaultHeaders(model),
-    };
-    if (model.provider === "github-copilot") {
-        // Copilot expects X-Initiator to indicate whether the request is user-initiated
-        // or agent-initiated (e.g. follow-up after assistant/tool messages). If there is
-        // no prior message, default to user-initiated.
-        const messages = context.messages || [];
-        const lastMessage = messages[messages.length - 1];
-        const isAgentCall = lastMessage ? lastMessage.role !== "user" : false;
-        headers["X-Initiator"] = isAgentCall ? "agent" : "user";
-        headers["Openai-Intent"] = "conversation-edits";
-        // Copilot requires this header when sending images
-        const hasImages = messages.some((msg) => {
-            if (msg.role === "user" && Array.isArray(msg.content)) {
-                return msg.content.some((c) => c.type === "image");
-            }
-            if (msg.role === "toolResult" && Array.isArray(msg.content)) {
-                return msg.content.some((c) => c.type === "image");
-            }
-            return false;
-        });
-        if (hasImages) {
-            headers["Copilot-Vision-Request"] = "true";
-        }
-    }
-    // Merge options headers last so they can override defaults
-    if (optionsHeaders) {
-        Object.assign(headers, optionsHeaders);
-    }
-    return new OpenAI({
-        apiKey,
-        baseURL: model.baseUrl,
-        dangerouslyAllowBrowser: true,
-        defaultHeaders: headers,
-    });
-}
-function buildParams(model, context, options) {
-    const compat = getCompat(model);
-    const messages = convertMessages(model, context, compat);
-    maybeAddOpenRouterAnthropicCacheControl(model, messages);
-    const params = {
-        model: model.id,
-        messages,
-        stream: true,
-    };
-    if (compat.supportsUsageInStreaming !== false) {
-        params.stream_options = { include_usage: true };
-    }
-    if (compat.supportsStore) {
-        params.store = false;
-    }
-    if (options?.maxTokens) {
-        if (compat.maxTokensField === "max_tokens") {
-            params.max_tokens = options.maxTokens;
-        }
-        else {
-            params.max_completion_tokens = options.maxTokens;
-        }
-    }
-    if (options?.temperature !== undefined) {
-        params.temperature = options.temperature;
-    }
-    if (context.tools) {
-        params.tools = convertTools(context.tools);
-    }
-    else if (hasToolHistory(context.messages)) {
-        // Anthropic (via LiteLLM/proxy) requires tools param when conversation has tool_calls/tool_results
-        params.tools = [];
-    }
-    if (options?.toolChoice) {
-        params.tool_choice = options.toolChoice;
-    }
-    if (compat.thinkingFormat === "zai" && model.reasoning) {
-        // Z.ai uses binary thinking: { type: "enabled" | "disabled" }
-        // Must explicitly disable since z.ai defaults to thinking enabled
-        params.thinking = { type: options?.reasoningEffort ? "enabled" : "disabled" };
-    }
-    else if (options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) {
-        // OpenAI-style reasoning_effort
-        params.reasoning_effort = options.reasoningEffort;
-    }
-    // OpenRouter provider routing preferences
-    if (model.baseUrl.includes("openrouter.ai") && model.compat?.openRouterRouting) {
-        params.provider = model.compat.openRouterRouting;
-    }
-    return params;
-}
-function isSarvamLike(model) {
-    return model.provider === "sarvam" || model.baseUrl.includes("api.sarvam.ai");
-}
-function maybeAddOpenRouterAnthropicCacheControl(model, messages) {
-    if (model.provider !== "openrouter" || !model.id.startsWith("anthropic/"))
-        return;
-    // Anthropic-style caching requires cache_control on a text part. Add a breakpoint
-    // on the last user/assistant message (walking backwards until we find text content).
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const msg = messages[i];
-        if (msg.role !== "user" && msg.role !== "assistant")
-            continue;
-        const content = msg.content;
-        if (typeof content === "string") {
-            msg.content = [
-                Object.assign({ type: "text", text: content }, { cache_control: { type: "ephemeral" } }),
-            ];
-            return;
-        }
-        if (!Array.isArray(content))
-            continue;
-        // Find last text part and add cache_control
-        for (let j = content.length - 1; j >= 0; j--) {
-            const part = content[j];
-            if (part?.type === "text") {
-                Object.assign(part, { cache_control: { type: "ephemeral" } });
-                return;
-            }
-        }
-    }
-}
-class UserMessageTransformer {
-    model;
-    constructor(model) {
-        this.model = model;
-    }
-    transform(message) {
-        if (typeof message.content === "string") {
-            return {
-                role: "user",
-                content: sanitizeSurrogates(message.content),
-            };
-        }
-        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 (isSarvamLike(this.model) && filteredParts.every((part) => part.type === "text")) {
-            return {
-                role: "user",
-                content: filteredParts.map((part) => part.text).join("\n"),
-            };
-        }
-        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" || isSarvamLike(this.model)) {
-                assistantMessage.content = nonEmptyTextBlocks.map((block) => sanitizeSurrogates(block.text)).join("");
-            }
-            else {
-                assistantMessage.content = nonEmptyTextBlocks.map((block) => ({
-                    type: "text",
-                    text: sanitizeSurrogates(block.text),
-                }));
-            }
-        }
-        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);
-                }
-                catch {
-                    return null;
-                }
-            })
-                .filter(Boolean);
-            if (reasoningDetails.length > 0) {
-                assistantMessage.reasoning_details = reasoningDetails;
-            }
-        }
-        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 });
-            }
-            else {
-                assistantMessage.content = [{ type: "text", text: thinkingText }];
-            }
-            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(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}`,
-                            },
-                        });
-                    }
-                }
-            }
-        }
-        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";
-                }
-                continue;
-            }
-            if (message.role === "assistant") {
-                const transformed = this.assistantTransformer.transform(message);
-                if (transformed) {
-                    params.push(transformed);
-                    lastRole = "assistant";
-                }
-                continue;
-            }
-            const toolResultBatch = this.toolResultTransformer.transform(transformedMessages, i);
-            params.push(...toolResultBatch.params);
-            i = toolResultBatch.nextIndex;
-            lastRole = toolResultBatch.lastRole;
-        }
-        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) => ({
-        type: "function",
-        function: {
-            name: tool.name,
-            description: tool.description,
-            parameters: tool.parameters, // TypeBox already generates JSON Schema
-            strict: false, // Disable strict mode to allow optional parameters without null unions
-        },
-    }));
-}
-function mapStopReason(reason) {
-    if (reason === null)
-        return "stop";
-    switch (reason) {
-        case "stop":
-            return "stop";
-        case "length":
-            return "length";
-        case "function_call":
-        case "tool_calls":
-            return "toolUse";
-        case "content_filter":
-            return "error";
-        default: {
-            const _exhaustive = reason;
-            throw new Error(`Unhandled stop reason: ${_exhaustive}`);
-        }
-    }
-}
-/**
- * Detect compatibility settings from provider and baseUrl for known providers.
- * Provider takes precedence over URL-based detection since it's explicitly configured.
- */
-function deriveCompatFromProvider(model) {
-    const provider = model.provider;
-    const baseUrl = model.baseUrl;
-    const isZai = provider === "zai" || baseUrl.includes("api.z.ai");
-    const isMistral = provider === "mistral" || baseUrl.includes("mistral.ai");
-    const isGrok = provider === "xai" || baseUrl.includes("api.x.ai");
-    const isSarvam = provider === "sarvam" || baseUrl.includes("api.sarvam.ai");
-    const isKrutrim = provider === "krutrim" || baseUrl.includes("cloud.olakrutrim.com");
-    const isNonStandardProvider = provider === "cerebras" ||
-        baseUrl.includes("cerebras.ai") ||
-        provider === "xai" ||
-        baseUrl.includes("api.x.ai") ||
-        isMistral ||
-        baseUrl.includes("chutes.ai") ||
-        isZai ||
-        provider === "opencode" ||
-        baseUrl.includes("opencode.ai") ||
-        isSarvam ||
-        isKrutrim;
-    const useLegacyMaxTokensField = isMistral || baseUrl.includes("chutes.ai") || isSarvam || isKrutrim;
-    return {
-        supportsStore: !isNonStandardProvider,
-        supportsDeveloperRole: !isNonStandardProvider,
-        supportsReasoningEffort: !isGrok && !isZai,
-        supportsUsageInStreaming: !isSarvam && !isKrutrim,
-        maxTokensField: useLegacyMaxTokensField ? "max_tokens" : "max_completion_tokens",
-        requiresToolResultName: isMistral,
-        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 derived = deriveCompatFromProvider(model);
-    return overlayCompatOverrides(derived, model.compat);
-}
-//# sourceMappingURL=openai-completions.js.map