@gencode/agents 0.0.9 → 0.0.10

package/dist/llm/openai-completions-compat.d.ts

@@ -1,23 +0,0 @@
-import { type SimpleStreamOptions, type StreamFunction } from "@mariozechner/pi-ai";
-export interface OpenAICompletionsOptions {
-    temperature?: number;
-    maxTokens?: number;
-    signal?: AbortSignal;
-    apiKey?: string;
-    sessionId?: string;
-    onPayload?: (payload: unknown) => void;
-    headers?: Record<string, string>;
-    maxRetryDelayMs?: number;
-    metadata?: Record<string, unknown>;
-    cacheRetention?: "none" | "short" | "long";
-    toolChoice?: "auto" | "none" | "required" | {
-        type: "function";
-        function: {
-            name: string;
-        };
-    };
-    reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh";
-}
-export declare const streamOpenAICompletionsCompat: StreamFunction<"openai-completions", OpenAICompletionsOptions>;
-export declare const streamSimpleOpenAICompletionsCompat: StreamFunction<"openai-completions", SimpleStreamOptions>;
-//# sourceMappingURL=openai-completions-compat.d.ts.map

package/dist/llm/openai-completions-compat.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"openai-completions-compat.d.ts","sourceRoot":"","sources":["../../src/llm/openai-completions-compat.ts"],"names":[],"mappings":"AAKA,OAAO,EAML,KAAK,mBAAmB,EACxB,KAAK,cAAc,EAEpB,MAAM,qBAAqB,CAAC;AAU7B,MAAM,WAAW,wBAAwB;IACvC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IACvC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,cAAc,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;IAC3C,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG;QAAE,IAAI,EAAE,UAAU,CAAC;QAAC,QAAQ,EAAE;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;IAC7F,eAAe,CAAC,EAAE,SAAS,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC;CACnE;AAED,eAAO,MAAM,6BAA6B,EAAE,cAAc,CACxD,oBAAoB,EACpB,wBAAwB,CA+OzB,CAAC;AAEF,eAAO,MAAM,mCAAmC,EAAE,cAAc,CAC9D,oBAAoB,EACpB,mBAAmB,CAepB,CAAC"}

package/dist/llm/openai-completions-compat.js

@@ -1,602 +0,0 @@
-import OpenAI from "openai";
-import { calculateCost, getEnvApiKey, supportsXhigh, } from "@mariozechner/pi-ai";
-import { parseStreamingJson } from "@mariozechner/pi-ai";
-import { AssistantMessageEventStream } from "@mariozechner/pi-ai/dist/utils/event-stream.js";
-import { sanitizeSurrogates } from "@mariozechner/pi-ai/dist/utils/sanitize-unicode.js";
-import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "@mariozechner/pi-ai/dist/providers/github-copilot-headers.js";
-import { buildBaseOptions, clampReasoning } from "@mariozechner/pi-ai/dist/providers/simple-options.js";
-import { transformMessages } from "@mariozechner/pi-ai/dist/providers/transform-messages.js";
-import { LlmRequestError } from "./client.js";
-import { parseOpenAIStreamPayloadError } from "./openai-stream-error.js";
-export const streamOpenAICompletionsCompat = (model, context, options) => {
-    const stream = new AssistantMessageEventStream();
-    void (async () => {
-        const output = {
-            role: "assistant",
-            content: [],
-            api: model.api,
-            provider: model.provider,
-            model: model.id,
-            usage: {
-                input: 0,
-                output: 0,
-                cacheRead: 0,
-                cacheWrite: 0,
-                totalTokens: 0,
-                cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-            },
-            stopReason: "stop",
-            timestamp: Date.now(),
-            errorMessage: undefined,
-        };
-        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 client.chat.completions.create(params, { signal: options?.signal });
-            stream.push({ type: "start", partial: output });
-            let currentBlock = null;
-            const blocks = output.content;
-            const blockIndex = () => blocks.length - 1;
-            const finishCurrentBlock = (block) => {
-                if (!block) {
-                    return;
-                }
-                if (block.type === "text") {
-                    stream.push({
-                        type: "text_end",
-                        contentIndex: blockIndex(),
-                        content: block.text,
-                        partial: output,
-                    });
-                    return;
-                }
-                if (block.type === "thinking") {
-                    stream.push({
-                        type: "thinking_end",
-                        contentIndex: blockIndex(),
-                        content: block.thinking,
-                        partial: output,
-                    });
-                    return;
-                }
-                if (block.type === "toolCall") {
-                    block.arguments = parseStreamingJson(block.partialArgs);
-                    delete block.partialArgs;
-                    stream.push({
-                        type: "toolcall_end",
-                        contentIndex: blockIndex(),
-                        toolCall: block,
-                        partial: output,
-                    });
-                }
-            };
-            for await (const chunk of openaiStream) {
-                const payloadError = parseOpenAIStreamPayloadError(chunk);
-                if (payloadError) {
-                    throw new LlmRequestError({
-                        message: `LLM upstream returned an error payload in a 200 stream: ${payloadError.message}`,
-                        code: "stream_payload_error",
-                        providerMessage: payloadError.providerMessage,
-                        retryable: payloadError.retryable,
-                        cause: payloadError.raw,
-                    });
-                }
-                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 = {
-                        input,
-                        output: outputTokens,
-                        cacheRead: cachedTokens,
-                        cacheWrite: 0,
-                        totalTokens: input + outputTokens + cachedTokens,
-                        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-                    };
-                    calculateCost(model, output.usage);
-                }
-                const choice = chunk.choices?.[0];
-                if (!choice) {
-                    continue;
-                }
-                if (choice.finish_reason) {
-                    output.stopReason = mapStopReason(choice.finish_reason);
-                }
-                if (!choice.delta) {
-                    continue;
-                }
-                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 });
-                    }
-                    currentBlock.text += choice.delta.content;
-                    stream.push({
-                        type: "text_delta",
-                        contentIndex: blockIndex(),
-                        delta: choice.delta.content,
-                        partial: output,
-                    });
-                }
-                const reasoningFields = ["reasoning_content", "reasoning", "reasoning_text"];
-                const foundReasoningField = reasoningFields.find((field) => {
-                    const value = choice.delta[field];
-                    return value !== null && value !== undefined && value.length > 0;
-                });
-                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 });
-                    }
-                    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 (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((block) => block.type === "toolCall" && block.id === detail.id);
-                            if (matchingToolCall) {
-                                matchingToolCall.thoughtSignature = JSON.stringify(detail);
-                            }
-                        }
-                    }
-                }
-            }
-            finishCurrentBlock(currentBlock);
-            if (options?.signal?.aborted) {
-                throw new Error("Request was aborted");
-            }
-            if (output.stopReason === "aborted" || output.stopReason === "error") {
-                throw new Error(output.errorMessage
-                    ?? (output.stopReason === "aborted"
-                        ? "Request was aborted"
-                        : `LLM stream ended with stopReason=${output.stopReason}`));
-            }
-            stream.push({ type: "done", reason: output.stopReason, message: 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);
-            const rawMetadata = error?.error?.metadata?.raw;
-            if (rawMetadata) {
-                output.errorMessage += `\n${rawMetadata}`;
-            }
-            stream.push({ type: "error", reason: output.stopReason, error: output });
-            stream.end();
-        }
-    })();
-    return stream;
-};
-export const streamSimpleOpenAICompletionsCompat = (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 = supportsXhigh(model) ? options?.reasoning : clampReasoning(options?.reasoning);
-    return streamOpenAICompletionsCompat(model, context, {
-        ...base,
-        reasoningEffort,
-        toolChoice: undefined,
-    });
-};
-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 };
-    if (model.provider === "github-copilot") {
-        const hasImages = hasCopilotVisionInput(context.messages);
-        Object.assign(headers, buildCopilotDynamicHeaders({ messages: context.messages, hasImages }));
-    }
-    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, compat);
-    }
-    else if (hasToolHistory(context.messages)) {
-        params.tools = [];
-    }
-    if (options?.toolChoice) {
-        params.tool_choice = options.toolChoice;
-    }
-    if ((compat.thinkingFormat === "zai" || compat.thinkingFormat === "qwen") && model.reasoning) {
-        params.enable_thinking = !!options?.reasoningEffort;
-    }
-    else if (options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) {
-        params.reasoning_effort = options.reasoningEffort;
-    }
-    if (model.baseUrl.includes("openrouter.ai") && model.compat?.openRouterRouting) {
-        params.provider = model.compat.openRouterRouting;
-    }
-    if (model.baseUrl.includes("ai-gateway.vercel.sh") && model.compat?.vercelGatewayRouting) {
-        const routing = model.compat.vercelGatewayRouting;
-        if (routing.only || routing.order) {
-            const gatewayOptions = {};
-            if (routing.only)
-                gatewayOptions.only = routing.only;
-            if (routing.order)
-                gatewayOptions.order = routing.order;
-            params.providerOptions = { gateway: gatewayOptions };
-        }
-    }
-    return params;
-}
-function hasToolHistory(messages) {
-    for (const msg of messages) {
-        if (msg.role === "toolResult") {
-            return true;
-        }
-        if (msg.role === "assistant" && msg.content.some((block) => block.type === "toolCall")) {
-            return true;
-        }
-    }
-    return false;
-}
-function normalizeMistralToolId(id) {
-    let normalized = id.replace(/[^a-zA-Z0-9]/g, "");
-    if (normalized.length < 9) {
-        normalized += "ABCDEFGHI".slice(0, 9 - normalized.length);
-    }
-    else if (normalized.length > 9) {
-        normalized = normalized.slice(0, 9);
-    }
-    return normalized;
-}
-function maybeAddOpenRouterAnthropicCacheControl(model, messages) {
-    if (model.provider !== "openrouter" || !model.id.startsWith("anthropic/")) {
-        return;
-    }
-    for (let i = messages.length - 1; i >= 0; i -= 1) {
-        const msg = messages[i];
-        if (msg.role !== "user" && msg.role !== "assistant") {
-            continue;
-        }
-        const content = msg.content;
-        if (typeof content === "string") {
-            msg.content = [{ type: "text", text: content, cache_control: { type: "ephemeral" } }];
-            return;
-        }
-        if (!Array.isArray(content)) {
-            continue;
-        }
-        for (let j = content.length - 1; j >= 0; j -= 1) {
-            const part = content[j];
-            if (part?.type === "text") {
-                Object.assign(part, { cache_control: { type: "ephemeral" } });
-                return;
-            }
-        }
-    }
-}
-function convertMessages(model, context, compat) {
-    const params = [];
-    const normalizeToolCallId = (id) => {
-        if (compat.requiresMistralToolIds)
-            return normalizeMistralToolId(id);
-        if (id.includes("|")) {
-            const [callId] = id.split("|");
-            return callId.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 40);
-        }
-        if (model.provider === "openai")
-            return id.length > 40 ? id.slice(0, 40) : id;
-        return id;
-    };
-    const transformedMessages = transformMessages(context.messages, model, (id) => normalizeToolCallId(id));
-    if (context.systemPrompt) {
-        const role = model.reasoning && compat.supportsDeveloperRole ? "developer" : "system";
-        params.push({ role, content: sanitizeSurrogates(context.systemPrompt) });
-    }
-    let lastRole = null;
-    for (let i = 0; i < transformedMessages.length; i += 1) {
-        const msg = transformedMessages[i];
-        if (compat.requiresAssistantAfterToolResult && lastRole === "toolResult" && msg.role === "user") {
-            params.push({ role: "assistant", content: "I have processed the tool results." });
-        }
-        if (msg.role === "user") {
-            if (typeof msg.content === "string") {
-                params.push({ role: "user", content: sanitizeSurrogates(msg.content) });
-            }
-            else {
-                const content = msg.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 filteredContent = !model.input.includes("image")
-                    ? content.filter((item) => item.type !== "image_url")
-                    : content;
-                if (filteredContent.length === 0)
-                    continue;
-                params.push({ role: "user", content: filteredContent });
-            }
-            lastRole = msg.role;
-            continue;
-        }
-        if (msg.role === "assistant") {
-            const assistantMsg = {
-                role: "assistant",
-                content: compat.requiresAssistantAfterToolResult ? "" : null,
-            };
-            const textBlocks = msg.content.filter((block) => block.type === "text" && block.text?.trim().length > 0);
-            if (textBlocks.length > 0) {
-                assistantMsg.content = model.provider === "github-copilot"
-                    ? textBlocks.map((block) => sanitizeSurrogates(block.text)).join("")
-                    : textBlocks.map((block) => ({ type: "text", text: sanitizeSurrogates(block.text) }));
-            }
-            const thinkingBlocks = msg.content.filter((block) => block.type === "thinking" && block.thinking?.trim().length > 0);
-            if (thinkingBlocks.length > 0) {
-                if (compat.requiresThinkingAsText) {
-                    const thinkingText = thinkingBlocks.map((block) => block.thinking).join("\n\n");
-                    if (assistantMsg.content) {
-                        assistantMsg.content.unshift({ type: "text", text: thinkingText });
-                    }
-                    else {
-                        assistantMsg.content = [{ type: "text", text: thinkingText }];
-                    }
-                }
-                else {
-                    const signature = thinkingBlocks[0].thinkingSignature;
-                    if (signature && signature.length > 0) {
-                        assistantMsg[signature] = thinkingBlocks.map((block) => block.thinking).join("\n");
-                    }
-                }
-            }
-            const toolCalls = msg.content.filter((block) => block.type === "toolCall");
-            if (toolCalls.length > 0) {
-                assistantMsg.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) {
-                    assistantMsg.reasoning_details = reasoningDetails;
-                }
-            }
-            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;
-            }
-            params.push(assistantMsg);
-            lastRole = msg.role;
-            continue;
-        }
-        if (msg.role === "toolResult") {
-            const imageBlocks = [];
-            let j = i;
-            for (; j < transformedMessages.length && transformedMessages[j].role === "toolResult"; j += 1) {
-                const toolMsg = transformedMessages[j];
-                const textResult = toolMsg.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
-                const hasImages = toolMsg.content.some((c) => c.type === "image");
-                const toolResultMsg = {
-                    role: "tool",
-                    content: sanitizeSurrogates(textResult.length > 0 ? 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}` },
-                            });
-                        }
-                    }
-                }
-            }
-            i = j - 1;
-            if (imageBlocks.length > 0) {
-                if (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],
-                });
-                lastRole = "user";
-            }
-            else {
-                lastRole = "toolResult";
-            }
-        }
-    }
-    return params;
-}
-function convertTools(tools, compat) {
-    return tools.map((tool) => ({
-        type: "function",
-        function: {
-            name: tool.name,
-            description: tool.description,
-            parameters: tool.parameters,
-            ...(compat.supportsStrictMode !== false && { strict: false }),
-        },
-    }));
-}
-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 "error":
-        case "content_filter":
-            return "error";
-        default:
-            throw new Error(`Unhandled stop reason: ${reason}`);
-    }
-}
-function detectCompat(model) {
-    const provider = model.provider;
-    const baseUrl = model.baseUrl;
-    const isZai = provider === "zai" || baseUrl.includes("api.z.ai");
-    const isNonStandard = provider === "cerebras" ||
-        baseUrl.includes("cerebras.ai") ||
-        provider === "xai" ||
-        baseUrl.includes("api.x.ai") ||
-        provider === "mistral" ||
-        baseUrl.includes("mistral.ai") ||
-        baseUrl.includes("chutes.ai") ||
-        baseUrl.includes("deepseek.com") ||
-        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");
-    return {
-        supportsStore: !isNonStandard,
-        supportsDeveloperRole: !isNonStandard,
-        supportsReasoningEffort: !isGrok && !isZai,
-        supportsUsageInStreaming: true,
-        maxTokensField: useMaxTokens ? "max_tokens" : "max_completion_tokens",
-        requiresToolResultName: isMistral,
-        requiresAssistantAfterToolResult: false,
-        requiresThinkingAsText: isMistral,
-        requiresMistralToolIds: isMistral,
-        thinkingFormat: isZai ? "zai" : "openai",
-        openRouterRouting: {},
-        vercelGatewayRouting: {},
-        supportsStrictMode: true,
-    };
-}
-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 ?? {},
-        vercelGatewayRouting: model.compat.vercelGatewayRouting ?? detected.vercelGatewayRouting,
-        supportsStrictMode: model.compat.supportsStrictMode ?? detected.supportsStrictMode,
-    };
-}
-//# sourceMappingURL=openai-completions-compat.js.map