@llmgateway/models 1.1.0 → 1.1.1

package/dist/prepare-request-body.js

@@ -0,0 +1,1081 @@
+import { models, } from "./models.js";
+import { transformAnthropicMessages } from "./transform-anthropic-messages.js";
+import { transformGoogleMessages } from "./transform-google-messages.js";
+function isFunctionTool(tool) {
+    return tool.type === "function";
+}
+function convertOpenAISchemaToGoogle(schema) {
+    if (!schema || typeof schema !== "object") {
+        return schema;
+    }
+    const converted = {};
+    if (schema.type) {
+        converted.type = schema.type.toUpperCase();
+    }
+    if (schema.description) {
+        converted.description = schema.description;
+    }
+    if (schema.properties) {
+        converted.properties = {};
+        for (const [key, value] of Object.entries(schema.properties)) {
+            converted.properties[key] = convertOpenAISchemaToGoogle(value);
+        }
+    }
+    if (schema.items) {
+        converted.items = convertOpenAISchemaToGoogle(schema.items);
+    }
+    if (schema.required) {
+        converted.required = schema.required;
+    }
+    if (schema.enum) {
+        converted.enum = schema.enum;
+    }
+    if (schema.format) {
+        converted.format = schema.format;
+    }
+    return converted;
+}
+function sanitizeCerebrasSchema(schema) {
+    if (!schema || typeof schema !== "object") {
+        return schema;
+    }
+    if (Array.isArray(schema)) {
+        return schema.map((item) => sanitizeCerebrasSchema(item));
+    }
+    const result = { ...schema };
+    if (result.type === "object") {
+        result.additionalProperties = false;
+    }
+    if (result.type === "string") {
+        delete result.format;
+        delete result.minLength;
+        delete result.maxLength;
+        delete result.pattern;
+    }
+    if (result.properties) {
+        result.properties = Object.fromEntries(Object.entries(result.properties).map(([key, value]) => [
+            key,
+            sanitizeCerebrasSchema(value),
+        ]));
+    }
+    if (result.items) {
+        result.items = sanitizeCerebrasSchema(result.items);
+    }
+    for (const key of ["anyOf", "oneOf", "allOf"]) {
+        if (result[key] && Array.isArray(result[key])) {
+            result[key] = result[key].map((item) => sanitizeCerebrasSchema(item));
+        }
+    }
+    if (result.$defs) {
+        result.$defs = Object.fromEntries(Object.entries(result.$defs).map(([key, value]) => [
+            key,
+            sanitizeCerebrasSchema(value),
+        ]));
+    }
+    if (result.definitions) {
+        result.definitions = Object.fromEntries(Object.entries(result.definitions).map(([key, value]) => [
+            key,
+            sanitizeCerebrasSchema(value),
+        ]));
+    }
+    return result;
+}
+function resolveRef(ref, rootDefs) {
+    const match = ref.match(/^#\/(\$defs|definitions)\/(.+)$/);
+    if (match) {
+        const defName = match[2];
+        return rootDefs[defName];
+    }
+    return null;
+}
+function stripUnsupportedSchemaProperties(schema, rootDefs) {
+    if (!schema || typeof schema !== "object") {
+        return schema;
+    }
+    if (Array.isArray(schema)) {
+        return schema.map((item) => stripUnsupportedSchemaProperties(item, rootDefs));
+    }
+    const defs = rootDefs ?? schema.$defs ?? schema.definitions ?? {};
+    if (schema.$ref) {
+        const resolved = resolveRef(schema.$ref, defs);
+        if (resolved) {
+            const expanded = stripUnsupportedSchemaProperties({ ...resolved }, defs);
+            if (schema.description && !expanded.description) {
+                expanded.description = schema.description;
+            }
+            if (schema.default !== undefined && expanded.default === undefined) {
+                expanded.default = schema.default;
+            }
+            return expanded;
+        }
+    }
+    const cleaned = {};
+    for (const [key, value] of Object.entries(schema)) {
+        if (key === "additionalProperties" ||
+            key === "$schema" ||
+            key === "$defs" ||
+            key === "definitions" ||
+            key === "$ref" ||
+            key === "ref" ||
+            key === "maxLength" ||
+            key === "minLength" ||
+            key === "minimum" ||
+            key === "maximum" ||
+            key === "pattern") {
+            continue;
+        }
+        if (value && typeof value === "object") {
+            cleaned[key] = stripUnsupportedSchemaProperties(value, defs);
+        }
+        else {
+            cleaned[key] = value;
+        }
+    }
+    if (cleaned.required &&
+        Array.isArray(cleaned.required) &&
+        cleaned.properties) {
+        const existingProps = Object.keys(cleaned.properties);
+        cleaned.required = cleaned.required.filter((prop) => existingProps.includes(prop));
+        if (cleaned.required.length === 0) {
+            delete cleaned.required;
+        }
+    }
+    return cleaned;
+}
+function transformMessagesForNoSystemRole(messages) {
+    return messages.map((message) => {
+        if (message.role === "system") {
+            return {
+                ...message,
+                role: "user",
+            };
+        }
+        return message;
+    });
+}
+function transformContentForResponsesApi(content, role) {
+    if (typeof content === "string") {
+        if (role === "assistant") {
+            return [{ type: "output_text", text: content }];
+        }
+        return [{ type: "input_text", text: content }];
+    }
+    if (Array.isArray(content)) {
+        return content.map((part) => {
+            if (part.type === "text") {
+                if (role === "assistant") {
+                    return { type: "output_text", text: part.text };
+                }
+                return { type: "input_text", text: part.text };
+            }
+            if (part.type === "image_url") {
+                const imageUrl = part.image_url?.url || part.image_url;
+                if (typeof imageUrl === "string" && imageUrl.startsWith("data:")) {
+                    const matches = imageUrl.match(/^data:([^;]+);base64,(.+)$/);
+                    if (matches) {
+                        return {
+                            type: "input_image",
+                            image_url: imageUrl,
+                        };
+                    }
+                }
+                return {
+                    type: "input_image",
+                    image_url: imageUrl,
+                };
+            }
+            return part;
+        });
+    }
+    return content;
+}
+function transformMessagesForResponsesApi(messages) {
+    return messages.map((msg) => {
+        const transformed = {
+            role: msg.role,
+        };
+        if (transformed.role === "tool") {
+            transformed.role = "user";
+        }
+        transformed.content = transformContentForResponsesApi(msg.content, transformed.role);
+        if (msg.name) {
+            transformed.name = msg.name;
+        }
+        return transformed;
+    });
+}
+export async function prepareRequestBody(usedProvider, usedModel, messages, stream, temperature, max_tokens, top_p, frequency_penalty, presence_penalty, response_format, tools, tool_choice, reasoning_effort, supportsReasoning, isProd = false, maxImageSizeMB = 20, userPlan = null, sensitive_word_check, image_config, effort, imageGenerations, webSearchTool) {
+    if (imageGenerations && usedProvider === "zai") {
+        const lastUserMessage = [...messages]
+            .reverse()
+            .find((m) => m.role === "user");
+        let prompt = "";
+        if (lastUserMessage) {
+            if (typeof lastUserMessage.content === "string") {
+                prompt = lastUserMessage.content;
+            }
+            else if (Array.isArray(lastUserMessage.content)) {
+                prompt = lastUserMessage.content
+                    .filter((p) => p.type === "text")
+                    .map((p) => p.text)
+                    .join("\n");
+            }
+        }
+        const zaiImageRequest = {
+            model: usedModel,
+            prompt,
+            ...(image_config?.image_size && { size: image_config.image_size }),
+            ...(image_config?.n && { n: image_config.n }),
+        };
+        return zaiImageRequest;
+    }
+    if (imageGenerations && usedProvider === "alibaba") {
+        const lastUserMessage = [...messages]
+            .reverse()
+            .find((m) => m.role === "user");
+        let prompt = "";
+        if (lastUserMessage) {
+            if (typeof lastUserMessage.content === "string") {
+                prompt = lastUserMessage.content;
+            }
+            else if (Array.isArray(lastUserMessage.content)) {
+                prompt = lastUserMessage.content
+                    .filter((p) => p.type === "text")
+                    .map((p) => p.text)
+                    .join("\n");
+            }
+        }
+        const alibabaImageRequest = {
+            model: usedModel,
+            input: {
+                messages: [
+                    {
+                        role: "user",
+                        content: [{ text: prompt }],
+                    },
+                ],
+            },
+            parameters: {
+                watermark: false,
+                ...(image_config?.n && { n: image_config.n }),
+                ...(image_config?.seed !== undefined && { seed: image_config.seed }),
+            },
+        };
+        if (image_config?.image_size) {
+            alibabaImageRequest.parameters.size = image_config.image_size.replace("x", "*");
+        }
+        return alibabaImageRequest;
+    }
+    if (imageGenerations && usedProvider === "bytedance") {
+        const lastUserMessage = [...messages]
+            .reverse()
+            .find((m) => m.role === "user");
+        let prompt = "";
+        if (lastUserMessage) {
+            if (typeof lastUserMessage.content === "string") {
+                prompt = lastUserMessage.content;
+            }
+            else if (Array.isArray(lastUserMessage.content)) {
+                prompt = lastUserMessage.content
+                    .filter((p) => p.type === "text")
+                    .map((p) => p.text)
+                    .join("\n");
+            }
+        }
+        const bytedanceImageRequest = {
+            model: usedModel,
+            prompt,
+            ...(image_config?.image_size && { size: image_config.image_size }),
+        };
+        return bytedanceImageRequest;
+    }
+    const modelDef = models.find((m) => m.id === usedModel ||
+        m.providers.some((p) => p.modelName === usedModel && p.providerId === usedProvider));
+    const supportsSystemRole = modelDef?.supportsSystemRole !== false;
+    let processedMessages = messages;
+    if (!supportsSystemRole) {
+        processedMessages = transformMessagesForNoSystemRole(messages);
+    }
+    const requestBody = {
+        model: usedModel,
+        messages: processedMessages,
+        stream: stream,
+    };
+    if (tools && tools.length > 0) {
+        const functionTools = tools.filter(isFunctionTool);
+        if (functionTools.length > 0) {
+            requestBody.tools = functionTools;
+        }
+    }
+    if (tool_choice) {
+        requestBody.tool_choice = tool_choice;
+    }
+    if (usedModel.startsWith("gpt-5")) {
+        temperature = 1;
+    }
+    if (modelDef?.family === "openai" &&
+        max_tokens !== undefined &&
+        max_tokens < 16) {
+        max_tokens = 16;
+    }
+    switch (usedProvider) {
+        case "openai": {
+            const providerMapping = modelDef?.providers.find((p) => p.providerId === "openai");
+            const supportsResponsesApi = providerMapping?.supportsResponsesApi ===
+                true;
+            if (supportsResponsesApi) {
+                const defaultEffort = usedModel === "gpt-5-pro" ? "high" : "medium";
+                const transformedMessages = transformMessagesForResponsesApi(processedMessages);
+                const responsesBody = {
+                    model: usedModel,
+                    input: transformedMessages,
+                    reasoning: {
+                        effort: reasoning_effort || defaultEffort,
+                        summary: "detailed",
+                    },
+                };
+                if (stream) {
+                    responsesBody.stream = true;
+                }
+                if (tools && tools.length > 0) {
+                    const functionTools = tools.filter(isFunctionTool);
+                    if (functionTools.length > 0) {
+                        responsesBody.tools = functionTools.map((tool) => ({
+                            type: "function",
+                            name: tool.function.name,
+                            description: tool.function.description,
+                            parameters: tool.function.parameters,
+                        }));
+                    }
+                }
+                if (webSearchTool) {
+                    if (!responsesBody.tools) {
+                        responsesBody.tools = [];
+                    }
+                    const webSearch = { type: "web_search" };
+                    if (webSearchTool.user_location) {
+                        webSearch.user_location = webSearchTool.user_location;
+                    }
+                    if (webSearchTool.search_context_size) {
+                        webSearch.search_context_size = webSearchTool.search_context_size;
+                    }
+                    responsesBody.tools.push(webSearch);
+                }
+                if (tool_choice) {
+                    responsesBody.tool_choice = tool_choice;
+                }
+                if (temperature !== undefined) {
+                    responsesBody.temperature = temperature;
+                }
+                if (max_tokens !== undefined) {
+                    responsesBody.max_output_tokens = max_tokens;
+                }
+                if (response_format) {
+                    if (response_format.type === "json_schema" &&
+                        response_format.json_schema) {
+                        responsesBody.text = {
+                            format: {
+                                type: "json_schema",
+                                name: response_format.json_schema.name,
+                                schema: response_format.json_schema.schema,
+                                strict: response_format.json_schema.strict,
+                            },
+                        };
+                    }
+                    else if (response_format.type === "json_object") {
+                        responsesBody.text = {
+                            format: { type: "json_object" },
+                        };
+                    }
+                }
+                return responsesBody;
+            }
+            else {
+                if (stream) {
+                    requestBody.stream_options = {
+                        include_usage: true,
+                    };
+                }
+                if (response_format) {
+                    requestBody.response_format = response_format;
+                }
+                if (webSearchTool) {
+                    if (usedModel.includes("-search-")) {
+                        const webSearchOptions = {};
+                        if (webSearchTool.user_location) {
+                            webSearchOptions.user_location = {
+                                type: "approximate",
+                                approximate: {
+                                    city: webSearchTool.user_location.city,
+                                    region: webSearchTool.user_location.region,
+                                    country: webSearchTool.user_location.country,
+                                },
+                            };
+                        }
+                        if (webSearchTool.search_context_size) {
+                            webSearchOptions.search_context_size =
+                                webSearchTool.search_context_size;
+                        }
+                        requestBody.web_search_options =
+                            Object.keys(webSearchOptions).length > 0 ? webSearchOptions : {};
+                    }
+                    else {
+                        if (!requestBody.tools) {
+                            requestBody.tools = [];
+                        }
+                        const webSearch = { type: "web_search" };
+                        if (webSearchTool.user_location) {
+                            webSearch.user_location = webSearchTool.user_location;
+                        }
+                        if (webSearchTool.search_context_size) {
+                            webSearch.search_context_size = webSearchTool.search_context_size;
+                        }
+                        requestBody.tools.push(webSearch);
+                    }
+                }
+                if (temperature !== undefined) {
+                    requestBody.temperature = temperature;
+                }
+                if (max_tokens !== undefined) {
+                    if (usedModel.startsWith("gpt-5")) {
+                        requestBody.max_completion_tokens = max_tokens;
+                    }
+                    else {
+                        requestBody.max_tokens = max_tokens;
+                    }
+                }
+                if (top_p !== undefined) {
+                    requestBody.top_p = top_p;
+                }
+                if (frequency_penalty !== undefined) {
+                    requestBody.frequency_penalty = frequency_penalty;
+                }
+                if (presence_penalty !== undefined) {
+                    requestBody.presence_penalty = presence_penalty;
+                }
+                if (reasoning_effort !== undefined) {
+                    requestBody.reasoning_effort = reasoning_effort;
+                }
+            }
+            break;
+        }
+        case "zai": {
+            if (stream) {
+                requestBody.stream_options = {
+                    include_usage: true,
+                };
+            }
+            if (response_format) {
+                requestBody.response_format = response_format;
+            }
+            if (webSearchTool) {
+                if (!requestBody.tools) {
+                    requestBody.tools = [];
+                }
+                requestBody.tools.push({
+                    type: "web_search",
+                    web_search: {
+                        enable: true,
+                        search_engine: "search-prime",
+                    },
+                });
+            }
+            if (temperature !== undefined) {
+                requestBody.temperature = temperature;
+            }
+            if (max_tokens !== undefined) {
+                requestBody.max_tokens = max_tokens;
+            }
+            if (top_p !== undefined) {
+                requestBody.top_p = top_p;
+            }
+            if (frequency_penalty !== undefined) {
+                requestBody.frequency_penalty = frequency_penalty;
+            }
+            if (presence_penalty !== undefined) {
+                requestBody.presence_penalty = presence_penalty;
+            }
+            if (supportsReasoning) {
+                requestBody.thinking = {
+                    type: "enabled",
+                };
+            }
+            if (sensitive_word_check) {
+                requestBody.sensitive_word_check = sensitive_word_check;
+            }
+            break;
+        }
+        case "anthropic": {
+            delete requestBody.tool_choice;
+            const getThinkingBudget = (effort) => {
+                if (!supportsReasoning) {
+                    return 0;
+                }
+                if (!reasoning_effort) {
+                    return 0;
+                }
+                switch (effort) {
+                    case "low":
+                        return 1024;
+                    case "high":
+                        return 4000;
+                    default:
+                        return 2000;
+                }
+            };
+            const thinkingBudget = getThinkingBudget(reasoning_effort);
+            const minMaxTokens = Math.max(1024, thinkingBudget + 1000);
+            requestBody.max_tokens = max_tokens ?? minMaxTokens;
+            const systemMessages = processedMessages.filter((m) => m.role === "system");
+            const nonSystemMessages = processedMessages.filter((m) => m.role !== "system");
+            let systemCacheControlCount = 0;
+            const maxCacheControlBlocks = 4;
+            const providerMapping = modelDef?.providers.find((p) => p.providerId === usedProvider);
+            const minCacheableTokens = providerMapping?.minCacheableTokens ?? 1024;
+            const minCacheableChars = minCacheableTokens * 4;
+            if (systemMessages.length > 0) {
+                const systemContent = [];
+                for (const sysMsg of systemMessages) {
+                    let text;
+                    if (typeof sysMsg.content === "string") {
+                        text = sysMsg.content;
+                    }
+                    else if (Array.isArray(sysMsg.content)) {
+                        text = sysMsg.content
+                            .filter((c) => c.type === "text" && "text" in c)
+                            .map((c) => c.text)
+                            .join("");
+                    }
+                    else {
+                        continue;
+                    }
+                    if (!text || text.trim() === "") {
+                        continue;
+                    }
+                    const shouldCache = text.length >= minCacheableChars &&
+                        systemCacheControlCount < maxCacheControlBlocks;
+                    if (shouldCache) {
+                        systemCacheControlCount++;
+                        systemContent.push({
+                            type: "text",
+                            text,
+                            cache_control: { type: "ephemeral" },
+                        });
+                    }
+                    else {
+                        systemContent.push({
+                            type: "text",
+                            text,
+                        });
+                    }
+                }
+                if (systemContent.length > 0) {
+                    requestBody.system = systemContent;
+                }
+            }
+            requestBody.messages = await transformAnthropicMessages(nonSystemMessages.map((m) => ({
+                ...m,
+                role: m.role === "assistant"
+                    ? "assistant"
+                    : m.role === "tool"
+                        ? "user"
+                        : "user",
+                content: m.content,
+                tool_calls: m.tool_calls,
+            })), isProd, usedProvider, usedModel, maxImageSizeMB, userPlan, systemCacheControlCount, minCacheableChars);
+            if (tools && tools.length > 0) {
+                const functionTools = tools.filter(isFunctionTool);
+                if (functionTools.length > 0) {
+                    requestBody.tools = functionTools.map((tool) => ({
+                        name: tool.function.name,
+                        description: tool.function.description,
+                        input_schema: tool.function.parameters,
+                    }));
+                }
+            }
+            if (webSearchTool) {
+                if (!requestBody.tools) {
+                    requestBody.tools = [];
+                }
+                const webSearch = {
+                    type: "web_search_20250305",
+                    name: "web_search",
+                };
+                if (webSearchTool.max_uses) {
+                    webSearch.max_uses = webSearchTool.max_uses;
+                }
+                requestBody.tools.push(webSearch);
+            }
+            if (tool_choice) {
+                if (typeof tool_choice === "object" &&
+                    tool_choice.type === "function") {
+                    requestBody.tool_choice = {
+                        type: "tool",
+                        name: tool_choice.function.name,
+                    };
+                }
+                else if (tool_choice === "auto") {
+                }
+                else if (tool_choice === "none") {
+                    requestBody.tool_choice = tool_choice;
+                }
+                else {
+                    requestBody.tool_choice = tool_choice;
+                }
+            }
+            if (supportsReasoning && reasoning_effort) {
+                requestBody.thinking = {
+                    type: "enabled",
+                    budget_tokens: thinkingBudget,
+                };
+            }
+            if (temperature !== undefined) {
+                requestBody.temperature = temperature;
+            }
+            if (top_p !== undefined) {
+                requestBody.top_p = top_p;
+            }
+            if (frequency_penalty !== undefined) {
+                requestBody.frequency_penalty = frequency_penalty;
+            }
+            if (presence_penalty !== undefined) {
+                requestBody.presence_penalty = presence_penalty;
+            }
+            if (effort !== undefined) {
+                if (!requestBody.output_config) {
+                    requestBody.output_config = {};
+                }
+                requestBody.output_config.effort = effort;
+            }
+            if (response_format) {
+                if (response_format.type === "json_schema" &&
+                    response_format.json_schema) {
+                    const schema = {
+                        ...response_format.json_schema.schema,
+                        additionalProperties: false,
+                    };
+                    requestBody.output_format = {
+                        type: "json_schema",
+                        schema,
+                    };
+                }
+                else if (response_format.type === "json_object") {
+                }
+            }
+            break;
+        }
+        case "aws-bedrock": {
+            delete requestBody.model;
+            delete requestBody.stream;
+            delete requestBody.messages;
+            delete requestBody.tools;
+            delete requestBody.tool_choice;
+            let bedrockCacheControlCount = 0;
+            const bedrockMaxCacheControlBlocks = 4;
+            const bedrockProviderMapping = modelDef?.providers.find((p) => p.providerId === usedProvider);
+            const bedrockMinCacheableTokens = bedrockProviderMapping?.minCacheableTokens ?? 1024;
+            const bedrockMinCacheableChars = bedrockMinCacheableTokens * 4;
+            const bedrockSystemMessages = processedMessages.filter((m) => m.role === "system");
+            const bedrockNonSystemMessages = processedMessages.filter((m) => m.role !== "system");
+            if (bedrockSystemMessages.length > 0) {
+                const systemContent = [];
+                for (const sysMsg of bedrockSystemMessages) {
+                    let text;
+                    if (typeof sysMsg.content === "string") {
+                        text = sysMsg.content;
+                    }
+                    else if (Array.isArray(sysMsg.content)) {
+                        text = sysMsg.content
+                            .filter((c) => c.type === "text" && "text" in c)
+                            .map((c) => c.text)
+                            .join("");
+                    }
+                    else {
+                        continue;
+                    }
+                    if (!text || text.trim() === "") {
+                        continue;
+                    }
+                    systemContent.push({ text });
+                    const shouldCache = text.length >= bedrockMinCacheableChars &&
+                        bedrockCacheControlCount < bedrockMaxCacheControlBlocks;
+                    if (shouldCache) {
+                        bedrockCacheControlCount++;
+                        systemContent.push({ cachePoint: { type: "default" } });
+                    }
+                }
+                if (systemContent.length > 0) {
+                    requestBody.system = systemContent;
+                }
+            }
+            requestBody.messages = bedrockNonSystemMessages.map((msg) => {
+                const role = msg.role === "user" || msg.role === "tool" ? "user" : "assistant";
+                const bedrockMessage = {
+                    role: role,
+                    content: [],
+                };
+                if (msg.role === "tool") {
+                    bedrockMessage.content.push({
+                        toolResult: {
+                            toolUseId: msg.tool_call_id,
+                            content: [
+                                {
+                                    text: msg.content || "",
+                                },
+                            ],
+                        },
+                    });
+                    return bedrockMessage;
+                }
+                if (msg.role === "assistant" && msg.tool_calls) {
+                    if (msg.content) {
+                        bedrockMessage.content.push({
+                            text: msg.content,
+                        });
+                    }
+                    msg.tool_calls.forEach((toolCall) => {
+                        bedrockMessage.content.push({
+                            toolUse: {
+                                toolUseId: toolCall.id,
+                                name: toolCall.function.name,
+                                input: JSON.parse(toolCall.function.arguments),
+                            },
+                        });
+                    });
+                    return bedrockMessage;
+                }
+                if (typeof msg.content === "string") {
+                    if (msg.content.trim()) {
+                        bedrockMessage.content.push({
+                            text: msg.content,
+                        });
+                        const shouldCache = msg.content.length >= bedrockMinCacheableChars &&
+                            bedrockCacheControlCount < bedrockMaxCacheControlBlocks;
+                        if (shouldCache) {
+                            bedrockCacheControlCount++;
+                            bedrockMessage.content.push({
+                                cachePoint: { type: "default" },
+                            });
+                        }
+                    }
+                }
+                else if (Array.isArray(msg.content)) {
+                    msg.content.forEach((part) => {
+                        if (part.type === "text") {
+                            if (part.text && part.text.trim()) {
+                                bedrockMessage.content.push({
+                                    text: part.text,
+                                });
+                                const shouldCache = part.text.length >= bedrockMinCacheableChars &&
+                                    bedrockCacheControlCount < bedrockMaxCacheControlBlocks;
+                                if (shouldCache) {
+                                    bedrockCacheControlCount++;
+                                    bedrockMessage.content.push({
+                                        cachePoint: { type: "default" },
+                                    });
+                                }
+                            }
+                        }
+                        else if (part.type === "image_url") {
+                        }
+                    });
+                }
+                return bedrockMessage;
+            });
+            if (tools && tools.length > 0) {
+                const functionTools = tools.filter(isFunctionTool);
+                if (functionTools.length > 0) {
+                    requestBody.toolConfig = {
+                        tools: functionTools.map((tool) => ({
+                            toolSpec: {
+                                name: tool.function.name,
+                                description: tool.function.description,
+                                inputSchema: {
+                                    json: tool.function.parameters,
+                                },
+                            },
+                        })),
+                    };
+                }
+            }
+            const inferenceConfig = {};
+            if (temperature !== undefined) {
+                inferenceConfig.temperature = temperature;
+            }
+            if (max_tokens !== undefined) {
+                inferenceConfig.maxTokens = max_tokens;
+            }
+            if (top_p !== undefined) {
+                inferenceConfig.topP = top_p;
+            }
+            if (Object.keys(inferenceConfig).length > 0) {
+                requestBody.inferenceConfig = inferenceConfig;
+            }
+            if (response_format?.type === "json_schema" &&
+                response_format.json_schema) {
+                const schema = {
+                    ...response_format.json_schema.schema,
+                    additionalProperties: false,
+                };
+                requestBody.additionalModelRequestFields = {
+                    anthropic_beta: ["structured-outputs-2025-11-13"],
+                    output_format: {
+                        type: "json_schema",
+                        schema,
+                    },
+                };
+                requestBody.additionalModelResponseFieldPaths = ["/output_format"];
+            }
+            break;
+        }
+        case "google-ai-studio":
+        case "google-vertex": {
+            delete requestBody.model;
+            delete requestBody.stream;
+            delete requestBody.messages;
+            delete requestBody.tool_choice;
+            requestBody.contents = await transformGoogleMessages(processedMessages, isProd, maxImageSizeMB, userPlan);
+            if (tools && tools.length > 0) {
+                const functionTools = tools.filter(isFunctionTool);
+                if (functionTools.length > 0) {
+                    requestBody.tools = [
+                        {
+                            functionDeclarations: functionTools.map((tool) => {
+                                const cleanParameters = stripUnsupportedSchemaProperties(tool.function.parameters || {});
+                                return {
+                                    name: tool.function.name,
+                                    description: tool.function.description,
+                                    parameters: cleanParameters,
+                                };
+                            }),
+                        },
+                    ];
+                }
+            }
+            if (webSearchTool) {
+                if (!requestBody.tools) {
+                    requestBody.tools = [];
+                }
+                requestBody.tools.push({ google_search: {} });
+            }
+            requestBody.generationConfig = {};
+            if (temperature !== undefined) {
+                requestBody.generationConfig.temperature = temperature;
+            }
+            if (max_tokens !== undefined) {
+                requestBody.generationConfig.maxOutputTokens = max_tokens;
+            }
+            if (top_p !== undefined) {
+                requestBody.generationConfig.topP = top_p;
+            }
+            if (response_format?.type === "json_object") {
+                requestBody.generationConfig.responseMimeType = "application/json";
+            }
+            else if (response_format?.type === "json_schema") {
+                requestBody.generationConfig.responseMimeType = "application/json";
+                if (response_format.json_schema?.schema) {
+                    requestBody.generationConfig.responseSchema =
+                        convertOpenAISchemaToGoogle(response_format.json_schema.schema);
+                }
+            }
+            if (supportsReasoning) {
+                requestBody.generationConfig.thinkingConfig = {
+                    includeThoughts: true,
+                };
+                if (reasoning_effort !== undefined) {
+                    const getThinkingBudget = (effort) => {
+                        switch (effort) {
+                            case "minimal":
+                                return 512;
+                            case "low":
+                                return 2048;
+                            case "high":
+                                return 24576;
+                            case "medium":
+                            default:
+                                return 8192;
+                        }
+                    };
+                    requestBody.generationConfig.thinkingConfig.thinkingBudget =
+                        getThinkingBudget(reasoning_effort);
+                }
+            }
+            if (image_config?.aspect_ratio !== undefined ||
+                image_config?.image_size !== undefined) {
+                requestBody.generationConfig.responseModalities = ["TEXT", "IMAGE"];
+                requestBody.generationConfig.imageConfig = {};
+                if (image_config.aspect_ratio !== undefined) {
+                    requestBody.generationConfig.imageConfig.aspectRatio =
+                        image_config.aspect_ratio;
+                }
+                if (image_config.image_size !== undefined) {
+                    requestBody.generationConfig.imageConfig.imageSize =
+                        image_config.image_size;
+                }
+            }
+            requestBody.safetySettings = [
+                { category: "HARM_CATEGORY_HARASSMENT", threshold: "BLOCK_NONE" },
+                { category: "HARM_CATEGORY_HATE_SPEECH", threshold: "BLOCK_NONE" },
+                {
+                    category: "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+                    threshold: "BLOCK_NONE",
+                },
+                {
+                    category: "HARM_CATEGORY_DANGEROUS_CONTENT",
+                    threshold: "BLOCK_NONE",
+                },
+            ];
+            break;
+        }
+        case "inference.net":
+        case "together.ai": {
+            if (usedModel.startsWith(`${usedProvider}/`)) {
+                requestBody.model = usedModel.substring(usedProvider.length + 1);
+            }
+            if (temperature !== undefined) {
+                requestBody.temperature = temperature;
+            }
+            if (max_tokens !== undefined) {
+                requestBody.max_tokens = max_tokens;
+            }
+            if (top_p !== undefined) {
+                requestBody.top_p = top_p;
+            }
+            if (frequency_penalty !== undefined) {
+                requestBody.frequency_penalty = frequency_penalty;
+            }
+            if (presence_penalty !== undefined) {
+                requestBody.presence_penalty = presence_penalty;
+            }
+            break;
+        }
+        case "cerebras": {
+            if (stream) {
+                requestBody.stream_options = {
+                    include_usage: true,
+                };
+            }
+            if (response_format) {
+                if (response_format.type === "json_schema") {
+                    requestBody.response_format = {
+                        ...response_format,
+                        json_schema: {
+                            ...response_format.json_schema,
+                            strict: true,
+                            schema: response_format.json_schema?.schema
+                                ? sanitizeCerebrasSchema(response_format.json_schema.schema)
+                                : response_format.json_schema?.schema,
+                        },
+                    };
+                }
+                else {
+                    requestBody.response_format = response_format;
+                }
+            }
+            if (requestBody.tools && Array.isArray(requestBody.tools)) {
+                requestBody.tools = requestBody.tools.map((tool) => ({
+                    ...tool,
+                    function: {
+                        ...tool.function,
+                        strict: true,
+                        parameters: tool.function.parameters
+                            ? sanitizeCerebrasSchema(tool.function.parameters)
+                            : tool.function.parameters,
+                    },
+                }));
+            }
+            if (temperature !== undefined) {
+                requestBody.temperature = temperature;
+            }
+            if (max_tokens !== undefined) {
+                requestBody.max_tokens = max_tokens;
+            }
+            if (top_p !== undefined) {
+                requestBody.top_p = top_p;
+            }
+            if (frequency_penalty !== undefined) {
+                requestBody.frequency_penalty = frequency_penalty;
+            }
+            if (presence_penalty !== undefined) {
+                requestBody.presence_penalty = presence_penalty;
+            }
+            if (reasoning_effort !== undefined) {
+                requestBody.reasoning_effort = reasoning_effort;
+            }
+            break;
+        }
+        case "perplexity": {
+            if (stream) {
+                requestBody.stream_options = {
+                    include_usage: true,
+                };
+            }
+            if (response_format) {
+                if (response_format.type === "json_schema" &&
+                    response_format.json_schema) {
+                    requestBody.response_format = {
+                        type: "json_schema",
+                        json_schema: {
+                            schema: response_format.json_schema.schema,
+                        },
+                    };
+                }
+                else {
+                    requestBody.response_format = response_format;
+                }
+            }
+            if (temperature !== undefined) {
+                requestBody.temperature = temperature;
+            }
+            if (max_tokens !== undefined) {
+                requestBody.max_tokens = max_tokens;
+            }
+            if (top_p !== undefined) {
+                requestBody.top_p = top_p;
+            }
+            if (frequency_penalty !== undefined) {
+                requestBody.frequency_penalty = frequency_penalty;
+            }
+            if (presence_penalty !== undefined) {
+                requestBody.presence_penalty = presence_penalty;
+            }
+            break;
+        }
+        default: {
+            if (stream) {
+                requestBody.stream_options = {
+                    include_usage: true,
+                };
+            }
+            if (response_format) {
+                requestBody.response_format = response_format;
+            }
+            if (temperature !== undefined) {
+                requestBody.temperature = temperature;
+            }
+            if (max_tokens !== undefined) {
+                if (usedModel.startsWith("gpt-5")) {
+                    requestBody.max_completion_tokens = max_tokens;
+                }
+                else {
+                    requestBody.max_tokens = max_tokens;
+                }
+            }
+            if (top_p !== undefined) {
+                requestBody.top_p = top_p;
+            }
+            if (frequency_penalty !== undefined) {
+                requestBody.frequency_penalty = frequency_penalty;
+            }
+            if (presence_penalty !== undefined) {
+                requestBody.presence_penalty = presence_penalty;
+            }
+            if (reasoning_effort !== undefined) {
+                requestBody.reasoning_effort = reasoning_effort;
+            }
+            break;
+        }
+    }
+    return requestBody;
+}
+//# sourceMappingURL=prepare-request-body.js.map