import type { ModelMessage, ToolResultPart } from "ai"

import { mergeDeep, unique } from "remeda"

import type { JSONSchema7 } from "@ai-sdk/provider"

import type * as Provider from "./provider"

import type * as ModelsDev from "@opencode-ai/core/models-dev"

import { iife } from "@/util/iife"

type Modality = NonNullable<ModelsDev.Model["modalities"]>["input"][number]

function mimeToModality(mime: string): Modality | undefined {

if (mime.startsWith("image/")) return "image"

if (mime.startsWith("audio/")) return "audio"

if (mime.startsWith("video/")) return "video"

if (mime === "application/pdf") return "pdf"

return undefined

}

export const OUTPUT_TOKEN_MAX = 32_000

// OpenAI Responses `include` value that returns the encrypted reasoning state

// needed for stateless multi-turn reasoning (store: false). Hoisted so every

// branch that requests it stays in lockstep.

const INCLUDE_ENCRYPTED_REASONING = ["reasoning.encrypted_content"] as const

export function sanitizeSurrogates(content: string) {

return content.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "\uFFFD")

}

function isKimiFamily(model: Provider.Model) {

if (

[model.providerID, model.api.id].some((id) => {

const value = id.toLowerCase()

return value.includes("kimi") || value.includes("moonshot")

})

)

return true

const url = model.api.url.toLowerCase()

return ["api.kimi.com", "api.moonshot.ai", "api.moonshot.cn", "api.moonshotai.cn"].some((host) => url.includes(host))

}

// Maps npm package to the key the AI SDK expects for providerOptions

function sdkKey(npm: string): string | undefined {

switch (npm) {

case "@ai-sdk/github-copilot":

return "copilot"

case "@ai-sdk/azure":

return "azure"

case "@ai-sdk/openai":

return "openai"

case "@ai-sdk/amazon-bedrock/mantle":

return "openai"

case "@ai-sdk/amazon-bedrock":

return "bedrock"

case "@ai-sdk/anthropic":

case "@ai-sdk/google-vertex/anthropic":

return "anthropic"

case "@ai-sdk/google-vertex":

return "vertex"

case "@ai-sdk/google":

return "google"

case "@ai-sdk/alibaba":

return "alibaba"

case "@ai-sdk/cerebras":

return "cerebras"

case "@ai-sdk/cohere":

return "cohere"

case "@ai-sdk/deepinfra":

return "deepinfra"

case "@ai-sdk/groq":

return "groq"

case "@ai-sdk/mistral":

return "mistral"

case "@ai-sdk/perplexity":

return "perplexity"

case "@ai-sdk/togetherai":

return "togetherai"

case "@ai-sdk/vercel":

return "vercel"

case "@ai-sdk/xai":

return "xai"

case "venice-ai-sdk-provider":

return "venice"

case "@ai-sdk/gateway":

return "gateway"

case "@openrouter/ai-sdk-provider":

return "openrouter"

case "ai-gateway-provider":

// ai-gateway-provider/unified wraps createOpenAICompatible({ name: "Unified" }),

// and @ai-sdk/openai-compatible parses compatibleOptions from one of

// "openai-compatible" / "openaiCompatible" / "Unified" / "unified". The

// "openai-compatible" key emits a deprecation warning at runtime, so we

// pick the camelCase form the SDK now treats as canonical.

return "openaiCompatible"

}

return undefined

}

// TODO: fix this stupid inefficient dogshit function

function normalizeMessages(

msgs: ModelMessage[],

model: Provider.Model,

_options: Record<string, unknown>,

): ModelMessage[] {

const sanitizeToolResultOutput = (content: ToolResultPart) => {

if (content.output.type === "text" || content.output.type === "error-text") {

content.output.value = sanitizeSurrogates(content.output.value)

}

if (content.output.type === "content") {

content.output.value = content.output.value.map((item) => {

if (item.type === "text") {

item.text = sanitizeSurrogates(item.text)

}

return item

})

}

return content

}

msgs = msgs.map((msg) => {

switch (msg.role) {

case "tool":

if (!Array.isArray(msg.content)) return msg

msg.content = msg.content.map((content) => {

if (content.type === "tool-result") {

return sanitizeToolResultOutput(content)

}

return content

})

return msg

case "system":

msg.content = sanitizeSurrogates(msg.content)

return msg

case "user":

if (typeof msg.content === "string") {

msg.content = sanitizeSurrogates(msg.content)

} else {

msg.content = msg.content.map((content) => {

if (content.type === "text") {

content.text = sanitizeSurrogates(content.text)

}

return content

})

}

return msg

case "assistant":

if (typeof msg.content === "string") {

msg.content = sanitizeSurrogates(msg.content)

} else {

msg.content = msg.content.map((content) => {

if (content.type === "text" || content.type === "reasoning") {

content.text = sanitizeSurrogates(content.text)

}

if (content.type === "tool-result") {

return sanitizeToolResultOutput(content)

}

return content

})

}

return msg

}

})

// Anthropic rejects messages with empty content - filter out empty string messages

// and remove empty text/reasoning parts from array content

if (model.api.npm === "@ai-sdk/anthropic") {

msgs = msgs

.map((msg) => {

if (typeof msg.content === "string") {

if (msg.content === "") return undefined

return msg

}

if (!Array.isArray(msg.content)) return msg

const filtered = msg.content.filter((part) => {

if (part.type === "text") {

return part.text !== ""

}

if (part.type === "reasoning") {

return (

part.text.trim().length > 0 ||

part.providerOptions?.anthropic?.signature != null ||

part.providerOptions?.anthropic?.redactedData != null

)

}

return true

})

if (filtered.length === 0) return undefined

return { ...msg, content: filtered }

})

.filter((msg): msg is ModelMessage => msg !== undefined && msg.content !== "")

}

// Bedrock specific transforms

if (model.api.npm === "@ai-sdk/amazon-bedrock") {

msgs = msgs

.map((msg) => {

if (typeof msg.content === "string") {

if (msg.content === "") return undefined

return msg

}

if (!Array.isArray(msg.content)) return msg

const filtered = msg.content.filter((part) => {

if (part.type === "text") {

return part.text !== ""

}

if (part.type === "reasoning") {

return (

part.text.trim().length > 0 ||

part.providerOptions?.bedrock?.signature != null ||

part.providerOptions?.bedrock?.redactedData != null

)

}

return true

})

if (filtered.length === 0) return undefined

return { ...msg, content: filtered }

})

.filter((msg): msg is ModelMessage => msg !== undefined && msg.content !== "")

}

if (model.api.id.includes("claude")) {

const scrub = (id: string) => id.replace(/[^a-zA-Z0-9_-]/g, "_")

msgs = msgs.map((msg) => {

if (msg.role === "assistant" && Array.isArray(msg.content)) {

return {

...msg,

content: msg.content.map((part) => {

if (part.type === "tool-call" || part.type === "tool-result") {

return { ...part, toolCallId: scrub(part.toolCallId) }

}

return part

}),

}

}

if (msg.role === "tool" && Array.isArray(msg.content)) {

return {

...msg,

content: msg.content.map((part) => {

if (part.type === "tool-result") {

return { ...part, toolCallId: scrub(part.toolCallId) }

}

return part

}),

}

}

return msg

})

}

const modelID = model.api.id.toLowerCase()

if (

model.providerID === "mistral" ||

["mistral", "devstral", "codestral", "pixtral", "mixtral"].some((family) => modelID.includes(family))

) {

const scrub = (id: string) => {

return id

.replace(/[^a-zA-Z0-9]/g, "") // Remove non-alphanumeric characters

.substring(0, 9) // Take first 9 characters

.padEnd(9, "0") // Pad with zeros if less than 9 characters

}

const result: ModelMessage[] = []

for (let i = 0; i < msgs.length; i++) {

const msg = msgs[i]

const nextMsg = msgs[i + 1]

if (msg.role === "assistant" && Array.isArray(msg.content)) {

msg.content = msg.content.map((part) => {

if (part.type === "tool-call" || part.type === "tool-result") {

return { ...part, toolCallId: scrub(part.toolCallId) }

}

return part

})

}

if (msg.role === "tool" && Array.isArray(msg.content)) {

msg.content = msg.content.map((part) => {

if (part.type === "tool-result") {

return { ...part, toolCallId: scrub(part.toolCallId) }

}

return part

})

}

result.push(msg)

// Fix message sequence: tool messages cannot be followed by user messages

if (msg.role === "tool" && nextMsg?.role === "user") {

result.push({

role: "assistant",

content: [

{

type: "text",

text: "Done.",

},

],

})

}

}

return result

}

// Deepseek requires all assistant messages to have reasoning on them

if (model.api.id.toLowerCase().includes("deepseek")) {

msgs = msgs.map((msg) => {

if (msg.role !== "assistant") return msg

if (Array.isArray(msg.content)) {

if (msg.content.some((part) => part.type === "reasoning")) return msg

return { ...msg, content: [...msg.content, { type: "reasoning", text: "" }] }

}

return {

...msg,

content: [

...(msg.content ? [{ type: "text" as const, text: msg.content }] : []),

{ type: "reasoning" as const, text: "" },

],

}

})

}

if (

typeof model.capabilities.interleaved === "object" &&

model.capabilities.interleaved.field &&

model.api.npm !== "@openrouter/ai-sdk-provider"

) {

const field = model.capabilities.interleaved.field

return msgs.map((msg) => {

if (msg.role === "assistant" && Array.isArray(msg.content)) {

const reasoningParts = msg.content.filter((part: any) => part.type === "reasoning")

const reasoningText = reasoningParts.map((part: any) => part.text).join("")

// Filter out reasoning parts from content

const filteredContent = msg.content.filter((part: any) => part.type !== "reasoning")

// Include reasoning_content | reasoning_details directly on the message for all assistant messages.

// Always set the field even when empty — some providers (e.g. DeepSeek) may return empty

// reasoning_content which still needs to be sent back in subsequent requests.

return {

...msg,

content: filteredContent,

providerOptions: {

...msg.providerOptions,

openaiCompatible: {

...msg.providerOptions?.openaiCompatible,

[field]: reasoningText,

},

},

}

}

return msg

})

}

return msgs

}

function applyCaching(msgs: ModelMessage[], model: Provider.Model): ModelMessage[] {

const system = msgs.filter((msg) => msg.role === "system").slice(0, 2)

const final = msgs.filter((msg) => msg.role !== "system").slice(-2)

const providerOptions = {

anthropic: {

cacheControl: { type: "ephemeral" },

},

openrouter: {

cacheControl: { type: "ephemeral" },

},

bedrock: {

cachePoint: { type: "default" },

},

openaiCompatible: {

cache_control: { type: "ephemeral" },

},

copilot: {

copilot_cache_control: { type: "ephemeral" },

},

alibaba: {

cacheControl: { type: "ephemeral" },

},

}

for (const msg of unique([...system, ...final])) {

const useMessageLevelOptions =

model.providerID === "anthropic" ||

model.providerID.includes("bedrock") ||

model.api.npm === "@ai-sdk/amazon-bedrock"

const shouldUseContentOptions = !useMessageLevelOptions && Array.isArray(msg.content) && msg.content.length > 0

if (shouldUseContentOptions) {

const lastContent = msg.content[msg.content.length - 1]

if (

lastContent &&

typeof lastContent === "object" &&

lastContent.type !== "tool-approval-request" &&

lastContent.type !== "tool-approval-response"

) {

lastContent.providerOptions = mergeDeep(lastContent.providerOptions ?? {}, providerOptions)

continue

}

}

msg.providerOptions = mergeDeep(msg.providerOptions ?? {}, providerOptions)

}

return msgs

}

function unsupportedParts(msgs: ModelMessage[], model: Provider.Model): ModelMessage[] {

return msgs.map((msg) => {

if (msg.role !== "user" || !Array.isArray(msg.content)) return msg

const filtered = msg.content.map((part) => {

if (part.type !== "file" && part.type !== "image") return part

// Check for empty base64 image data

if (part.type === "image") {

const imageStr = String(part.image)

if (imageStr.startsWith("data:")) {

const match = imageStr.match(/^data:([^;]+);base64,(.*)$/)

if (match && (!match[2] || match[2].length === 0)) {

return {

type: "text" as const,

text: "ERROR: Image file is empty or corrupted. Please provide a valid image.",

}

}

}

}

const mime = part.type === "image" ? String(part.image).split(";")[0].replace("data:", "") : part.mediaType

const filename = part.type === "file" ? part.filename : undefined

const modality = mimeToModality(mime)

if (!modality) return part

if (model.capabilities.input[modality]) return part

const name = filename ? `"${filename}"` : modality

return {

type: "text" as const,

text: `ERROR: Cannot read ${name} (this model does not support ${modality} input). Inform the user.`,

}

})

return { ...msg, content: filtered }

})

}

function mapProviderOptions(

msgs: ModelMessage[],

transform: (options: Record<string, any> | undefined) => Record<string, any> | undefined,

) {

return msgs.map((msg) => {

if (!Array.isArray(msg.content)) return { ...msg, providerOptions: transform(msg.providerOptions) }

return {

...msg,

providerOptions: transform(msg.providerOptions),

content: msg.content.map((part) =>

part.type === "tool-approval-request" || part.type === "tool-approval-response"

? part

: { ...part, providerOptions: transform(part.providerOptions) },

),

} as typeof msg

})

}

export function message(msgs: ModelMessage[], model: Provider.Model, options: Record<string, unknown>) {

msgs = unsupportedParts(msgs, model)

msgs = normalizeMessages(msgs, model, options)

const usesAnthropicAutomaticCaching =

options.cacheControl !== undefined &&

(model.api.npm === "@ai-sdk/anthropic" || model.api.npm === "@ai-sdk/google-vertex/anthropic")

if (

(model.providerID === "anthropic" ||

model.providerID === "google-vertex-anthropic" ||

model.api.id.includes("anthropic") ||

model.api.id.includes("claude") ||

model.id.includes("anthropic") ||

model.id.includes("claude") ||

model.api.npm === "@ai-sdk/anthropic" ||

model.api.npm === "@ai-sdk/alibaba") &&

model.api.npm !== "@ai-sdk/gateway" &&

!usesAnthropicAutomaticCaching

) {

msgs = applyCaching(msgs, model)

}

// Remap providerOptions keys from stored providerID to expected SDK key

const key = sdkKey(model.api.npm)

if (key && key !== model.providerID) {

const remap = (opts: Record<string, any> | undefined) => {

if (!opts) return opts

if (!(model.providerID in opts)) return opts

const result = { ...opts }

result[key] = result[model.providerID]

delete result[model.providerID]

return result

}

msgs = mapProviderOptions(msgs, remap)

}

// Strip Responses item IDs before serialization, following Codex and keeping signed request bodies immutable.

if (

options.store !== true &&

key &&

["@ai-sdk/openai", "@ai-sdk/azure", "@ai-sdk/amazon-bedrock/mantle", "@ai-sdk/github-copilot"].includes(

model.api.npm,

)

) {

msgs = mapProviderOptions(msgs, (options) => {

if (!options?.[key] || !("itemId" in options[key])) return options

const metadata = { ...options[key] }

delete metadata.itemId

return { ...options, [key]: metadata }

})

}

return msgs

}

export function temperature(model: Provider.Model) {

const id = model.id.toLowerCase()

if (id.includes("north-mini-code")) return 1.0

if (id.includes("qwen")) return 0.55

if (id.includes("claude")) return undefined

if (id.includes("gemini")) return 1.0

if (id.includes("glm-4.6")) return 1.0

if (id.includes("glm-4.7")) return 1.0

if (id.includes("minimax-m2")) return 1.0

if (id.includes("kimi-k2")) {

// kimi-k2-thinking & kimi-k2.5 && kimi-k2p5 && kimi-k2-5

if (["thinking", "k2.", "k2p", "k2-5"].some((s) => id.includes(s))) {

return 1.0

}

return 0.6

}

return undefined

}

export function topP(model: Provider.Model) {

const id = model.id.toLowerCase()

if (id.includes("qwen")) return 1

if (["minimax-m2", "gemini", "kimi-k2.5", "kimi-k2p5", "kimi-k2-5"].some((s) => id.includes(s))) {

return 0.95

}

return undefined

}

export function topK(model: Provider.Model) {

const id = model.id.toLowerCase()

if (id.includes("minimax-m2")) {

if (["m2.", "m25", "m21"].some((s) => id.includes(s))) return 40

return 20

}

if (id.includes("gemini")) return 64

return undefined

}

const WIDELY_SUPPORTED_EFFORTS = ["low", "medium", "high"]

const OPENAI_EFFORTS = ["none", "minimal", ...WIDELY_SUPPORTED_EFFORTS, "xhigh"]

const OPENAI_GPT5_1_EFFORTS = ["none", ...WIDELY_SUPPORTED_EFFORTS]

const OPENAI_GPT5_2_PLUS_EFFORTS = [...OPENAI_GPT5_1_EFFORTS, "xhigh"]

const OPENAI_GPT5_PRO_EFFORTS = ["high"]

const OPENAI_GPT5_PRO_2_PLUS_EFFORTS = ["medium", "high", "xhigh"]

const OPENAI_GPT5_CHAT_EFFORTS = ["medium"]

const OPENAI_GPT5_CODEX_XHIGH_EFFORTS = [...WIDELY_SUPPORTED_EFFORTS, "xhigh"]

const OPENAI_GPT5_CODEX_3_PLUS_EFFORTS = ["none", ...OPENAI_GPT5_CODEX_XHIGH_EFFORTS]

// OpenAI rolled out the `none` reasoning_effort tier on this date (Responses API).

// Models released before it 400 on `reasoning_effort: "none"`, so we only expose

// it as a variant for models new enough to accept it.

const OPENAI_NONE_EFFORT_RELEASE_DATE = "2025-11-13"

// OpenAI rolled out the `xhigh` reasoning_effort tier on this date. Same reasoning.

const OPENAI_XHIGH_EFFORT_RELEASE_DATE = "2025-12-04"

// Matches members of the gpt-5 family across the id formats we encounter:

// "gpt-5", "gpt-5-nano", "gpt-5.4", "openai/gpt-5.4-codex".

// Anchored to start-of-string or "/" so it doesn't false-match "gpt-50" or "gpt-5o".

const GPT5_FAMILY_RE = /(?:^|\/)gpt-5(?:[.-]|$)/

const GPT5_VERSION_RE = /(?:^|\/)gpt-5[.-](\d+)(?:[.-]|$)/

const GPT5_PRO_RE = /(?:^|\/)gpt-5[.-]?pro(?:[.-]|$)/

const GPT5_VERSIONED_PRO_RE = /(?:^|\/)gpt-5[.-]\d+[.-]pro(?:[.-]|$)/

function gpt5Version(apiId: string) {

return Number(GPT5_VERSION_RE.exec(apiId)?.[1]) || undefined

}

function versionedGpt5ReasoningEfforts(apiId: string) {

if (GPT5_VERSIONED_PRO_RE.test(apiId)) return OPENAI_GPT5_PRO_2_PLUS_EFFORTS

const version = gpt5Version(apiId)

if (version === undefined) return undefined

if (version === 1) return OPENAI_GPT5_1_EFFORTS

return OPENAI_GPT5_2_PLUS_EFFORTS

}

function gpt5CodexReasoningEfforts(apiId: string) {

if (!GPT5_FAMILY_RE.test(apiId) || !apiId.includes("codex")) return undefined

const version = gpt5Version(apiId)

if (version !== undefined && version >= 3) return OPENAI_GPT5_CODEX_3_PLUS_EFFORTS

if (apiId.includes("codex-max") || (version !== undefined && version >= 2)) return OPENAI_GPT5_CODEX_XHIGH_EFFORTS

return WIDELY_SUPPORTED_EFFORTS

}

function gpt5ChatReasoningEfforts(apiId: string) {

if (!GPT5_FAMILY_RE.test(apiId) || !apiId.includes("-chat")) return undefined

return gpt5Version(apiId) === undefined ? [] : OPENAI_GPT5_CHAT_EFFORTS

}

// Computes the reasoning_effort tiers an OpenAI (or OpenAI-compatible upstream

// routed through it, e.g. cf-ai-gateway) model exposes. Effort order: weakest

// to strongest.

function openaiReasoningEfforts(apiId: string, releaseDate: string) {

const id = apiId.toLowerCase()

if (id.includes("deep-research")) return ["medium"]

const chatEfforts = gpt5ChatReasoningEfforts(id)

if (chatEfforts) return chatEfforts

if (GPT5_PRO_RE.test(id)) return OPENAI_GPT5_PRO_EFFORTS

const codexEfforts = gpt5CodexReasoningEfforts(id)

if (codexEfforts) return codexEfforts

const versionedEfforts = versionedGpt5ReasoningEfforts(id)

// GPT-5.1 replaced GPT-5's `minimal` effort with `none`; GPT-5.2+

// additionally accepts `xhigh`. Model pages list the supported subset.

if (versionedEfforts) return versionedEfforts

const efforts = [...WIDELY_SUPPORTED_EFFORTS]

if (GPT5_FAMILY_RE.test(id)) efforts.unshift("minimal")

if (releaseDate >= OPENAI_NONE_EFFORT_RELEASE_DATE) efforts.unshift("none")

if (releaseDate >= OPENAI_XHIGH_EFFORT_RELEASE_DATE) efforts.push("xhigh")

return efforts

}

function openaiCompatibleReasoningEfforts(id: string) {

const apiId = id.toLowerCase()

const chatEfforts = gpt5ChatReasoningEfforts(apiId)

if (chatEfforts) return chatEfforts

if (GPT5_PRO_RE.test(apiId)) return OPENAI_GPT5_PRO_EFFORTS

return gpt5CodexReasoningEfforts(apiId) ?? versionedGpt5ReasoningEfforts(apiId) ?? OPENAI_EFFORTS

}

function anthropicUsesModernAdaptiveThinking(apiId: string) {

if (!apiId.toLowerCase().includes("claude-")) return false

// Covers family-first IDs such as claude-opus-4.7 and version-first IDs such as claude-4.7-opus.

// Limit minors to two digits so release dates in IDs such as claude-opus-4-20250514 are not versions.

const version = /claude-(?:[a-z]+-)?(\d+)(?:[.-](\d{1,2}))?(?:[.@-]|$)/i.exec(apiId)

if (!version) return true

const major = Number(version[1])

const minor = Number(version[2] ?? 0)

return major > 4 || (major === 4 && minor >= 7)

}

function anthropicOpus45(apiId: string) {

return ["opus-4-5", "opus-4.5"].some((value) => apiId.includes(value))

}

function anthropicAdaptiveEfforts(apiId: string): string[] | null {

if (anthropicUsesModernAdaptiveThinking(apiId)) {

return ["low", "medium", "high", "xhigh", "max"]

}

if (

["opus-4-6", "opus-4.6", "4-6-opus", "4.6-opus", "sonnet-4-6", "sonnet-4.6", "4-6-sonnet", "4.6-sonnet"].some((v) =>

apiId.includes(v),

)

) {

return ["low", "medium", "high", "max"]

}

return null

}

function anthropicOmitsThinking(apiId: string) {

return anthropicUsesModernAdaptiveThinking(apiId)

}

function googleThinkingLevelEfforts(apiId: string) {

const id = apiId.toLowerCase()

if (!id.includes("gemini-3")) return ["low", "high"]

if (id.includes("flash-image")) return ["minimal", "high"]

if (id.includes("pro-image")) return ["high"]

if (id.includes("flash")) return ["minimal", "low", "medium", "high"]

return ["low", "medium", "high"]

}

function googleThinkingBudgetMax(apiId: string) {

const id = apiId.toLowerCase()

if (id.includes("2.5") && id.includes("pro") && !id.includes("flash")) return 32_768

return 24_576

}

// SAP's Zod schema drops unknown top-level keys; reasoning controls survive

// only via `modelParams` (catchall), forwarded verbatim by the SAP SDKs.

function wrapInSapModelParams(variants: Record<string, Record<string, any>>): Record<string, Record<string, any>> {

return Object.fromEntries(Object.entries(variants).map(([k, v]) => [k, { modelParams: v }]))

}

function googleThinkingVariants(model: Provider.Model): Record<string, Record<string, any>> {

const id = model.api.id.toLowerCase()

if (id.includes("2.5")) {

return {

high: { thinkingConfig: { includeThoughts: true, thinkingBudget: 16000 } },

max: {

thinkingConfig: { includeThoughts: true, thinkingBudget: googleThinkingBudgetMax(id) },

},

}

}

return Object.fromEntries(

googleThinkingLevelEfforts(id).map((effort) => [

effort,

{ thinkingConfig: { includeThoughts: true, thinkingLevel: effort } },

]),

)

}

export function variants(model: Provider.Model): Record<string, Record<string, any>> {

if (!model.capabilities.reasoning) return {}

const id = model.id.toLowerCase()

const glm52 = ["glm-5.2", "glm-5-2", "glm-5p2"].some(

(name) => id.includes(name) || model.api.id.toLowerCase().includes(name),

)

if (

model.api.id.toLowerCase().includes("minimax-m3") &&

["@ai-sdk/anthropic", "@ai-sdk/openai-compatible"].includes(model.api.npm)

) {

if (["nvidia", "lilac"].includes(model.providerID)) {

return {

none: { chat_template_kwargs: { thinking_mode: "disabled" } },

thinking: { chat_template_kwargs: { thinking_mode: "enabled" } },

}

}

return {

none: { thinking: { type: "disabled" } },

thinking: { thinking: { type: "adaptive" } },

}

}

const adaptiveThinkingOmitted = anthropicOmitsThinking(model.api.id)

const adaptiveEfforts = anthropicAdaptiveEfforts(model.api.id)

if (glm52 && model.api.npm === "@openrouter/ai-sdk-provider") {

// OpenRouter maps xhigh to GLM-5.2's native max effort.

return {

high: { reasoning: { effort: "high" } },

xhigh: { reasoning: { effort: "xhigh" } },

}

}

if (glm52 && model.api.npm === "@ai-sdk/openai-compatible") {

return {

high: { reasoningEffort: "high" },

max: { reasoningEffort: "max" },

}

}

if (glm52 && model.api.npm === "@ai-sdk/anthropic") {

return {

high: { effort: "high" },

max: { effort: "max" },

}

}

// Kimi's Anthropic-compatible transports implement adaptive thinking effort.

if (isKimiFamily(model) && ["@ai-sdk/anthropic", "@ai-sdk/google-vertex/anthropic"].includes(model.api.npm)) {

return Object.fromEntries(

["low", "medium", "high", "xhigh", "max"].map((effort) => [

effort,

{ thinking: { type: "adaptive", display: "summarized" }, effort },

]),

)

}

if (

id.includes("deepseek-chat") ||

id.includes("deepseek-reasoner") ||

id.includes("deepseek-r1") ||

id.includes("deepseek-v3") ||

id.includes("minimax") ||

(id.includes("glm") && !glm52) ||

id.includes("kimi") ||

id.includes("k2p") ||

id.includes("qwen") ||

id.includes("big-pickle")

)

return {}

// see: https://docs.x.ai/docs/guides/reasoning#control-how-hard-the-model-thinks

if (id.includes("grok") && id.includes("grok-3-mini")) {

if (model.api.npm === "@openrouter/ai-sdk-provider") {

return {

low: { reasoning: { effort: "low" } },

high: { reasoning: { effort: "high" } },

}

}

return {

low: { reasoningEffort: "low" },

high: { reasoningEffort: "high" },

}

}

switch (model.api.npm) {

case "@openrouter/ai-sdk-provider":

return Object.fromEntries(

(model.api.id.startsWith("openai/") || id.includes("gpt")

? openaiCompatibleReasoningEfforts(model.api.id)

: WIDELY_SUPPORTED_EFFORTS

).map((effort) => [effort, { reasoning: { effort } }]),

)

case "ai-gateway-provider": {

// Cloudflare AI Gateway routes every upstream through its OpenAI-compatible

// /v1/compat endpoint, so the body is always OAI-shaped. The gateway

// translates `reasoning_effort` to the upstream provider's native control

// (e.g. Anthropic thinking budgets) when needed. Variants therefore stay

// OAI-style for all upstreams, with an extended effort set for OpenAI

// models that support it.

if (model.api.id.startsWith("openai/")) {

const efforts = openaiReasoningEfforts(model.api.id, model.release_date)

return Object.fromEntries(efforts.map((effort) => [effort, { reasoningEffort: effort }]))

}

return Object.fromEntries(WIDELY_SUPPORTED_EFFORTS.map((effort) => [effort, { reasoningEffort: effort }]))

}

case "@ai-sdk/gateway":

if (model.api.id.includes("anthropic")) {

if (adaptiveEfforts) {

return Object.fromEntries(

adaptiveEfforts.map((effort) => [

effort,

{

thinking: {

type: "adaptive",

// Newer adaptive-only models default `display` to "omitted", which

// returns empty thinking blocks. Force "summarized" so summaries

// survive (4.6/Sonnet 4.6 already default to "summarized").

...(adaptiveThinkingOmitted ? { display: "summarized" } : {}),

},

effort,

},

]),

)

}

return {

high: {

thinking: {

type: "enabled",

budgetTokens: 16000,

},

},

max: {

thinking: {

type: "enabled",

budgetTokens: 31999,

},

},

}

}

if (model.api.id.includes("google")) {

if (model.api.id.includes("2.5")) {

return {

high: {

thinkingConfig: {

includeThoughts: true,

thinkingBudget: 16000,

},

},

max: {

thinkingConfig: {

includeThoughts: true,

thinkingBudget: googleThinkingBudgetMax(model.api.id.toLowerCase()),

},

},

}

}

return Object.fromEntries(

["low", "high"].map((effort) => [

effort,

{

includeThoughts: true,

thinkingLevel: effort,

},

]),

)

}

return Object.fromEntries(

openaiCompatibleReasoningEfforts(model.api.id).map((effort) => [effort, { reasoningEffort: effort }]),

)

case "@ai-sdk/github-copilot":

if (model.id.includes("gemini")) {

// currently github copilot only returns thinking

return {}

}

if (model.id.includes("claude")) {

return Object.fromEntries(WIDELY_SUPPORTED_EFFORTS.map((effort) => [effort, { reasoningEffort: effort }]))

}

const copilotEfforts = iife(() => {

if (id.includes("5.1-codex-max") || id.includes("5.2") || id.includes("5.3"))

return [...WIDELY_SUPPORTED_EFFORTS, "xhigh"]

const arr = [...WIDELY_SUPPORTED_EFFORTS]

if (id.includes("gpt-5") && model.release_date >= "2025-12-04") arr.push("xhigh")

return arr

})

return Object.fromEntries(

copilotEfforts.map((effort) => [

effort,

{

reasoningEffort: effort,

reasoningSummary: "auto",

include: INCLUDE_ENCRYPTED_REASONING,

},

]),

)

case "@ai-sdk/cerebras":

// https://v5.ai-sdk.dev/providers/ai-sdk-providers/cerebras

case "@ai-sdk/togetherai":

// https://v5.ai-sdk.dev/providers/ai-sdk-providers/togetherai

case "@ai-sdk/xai":

// https://v5.ai-sdk.dev/providers/ai-sdk-providers/xai

case "@ai-sdk/deepinfra":

// https://v5.ai-sdk.dev/providers/ai-sdk-providers/deepinfra

case "venice-ai-sdk-provider":

// https://docs.venice.ai/overview/guides/reasoning-models#reasoning-effort

case "@ai-sdk/openai-compatible":

if (model.api.id.toLowerCase().includes("north-mini-code")) {

return Object.fromEntries(["none", "high"].map((effort) => [effort, { reasoningEffort: effort }]))

}

const efforts = [...WIDELY_SUPPORTED_EFFORTS]

if (model.api.id.toLowerCase().includes("deepseek-v4")) {

efforts.push("max")

}

return Object.fromEntries(efforts.map((effort) => [effort, { reasoningEffort: effort }]))

case "@ai-sdk/azure":

// https://v5.ai-sdk.dev/providers/ai-sdk-providers/azure

if (id === "o1-mini") return {}

return Object.fromEntries(

openaiReasoningEfforts(id, model.release_date).map((effort) => [

effort,

{

reasoningEffort: effort,

reasoningSummary: "auto",

include: INCLUDE_ENCRYPTED_REASONING,

},

]),

)

case "@ai-sdk/amazon-bedrock/mantle":

case "@ai-sdk/openai": {

if (model.providerID === "meta") {

return Object.fromEntries(

OPENAI_EFFORTS.map((effort) => [

effort,

{

reasoningEffort: effort,

reasoningSummary: "auto",

include: INCLUDE_ENCRYPTED_REASONING,

},

]),

)

}

// https://v5.ai-sdk.dev/providers/ai-sdk-providers/openai

const efforts = openaiReasoningEfforts(model.api.id, model.release_date)

return Object.fromEntries(

efforts.map((effort) => [

effort,

{

reasoningEffort: effort,

reasoningSummary: "auto",

include: INCLUDE_ENCRYPTED_REASONING,

},

]),

)

}

case "@ai-sdk/anthropic":

// https://v5.ai-sdk.dev/providers/ai-sdk-providers/anthropic

case "@ai-sdk/google-vertex/anthropic":

// https://v5.ai-sdk.dev/providers/ai-sdk-providers/google-vertex#anthropic-provider

if (adaptiveEfforts) {

let efforts = [...adaptiveEfforts]

if (model.providerID === "github-copilot") {

if (model.api.id.includes("opus-4.7")) {

efforts = ["medium"]

}

// Efforts currently supported are: low, medium, high

efforts = efforts.filter((v) => v !== "max" && v !== "xhigh")

}

return Object.fromEntries(

efforts.map((effort) => [

effort,

{

thinking: {

type: "adaptive",

...(adaptiveThinkingOmitted ? { display: "summarized" } : {}),

},

effort,

},

]),

)

}

if (anthropicOpus45(model.api.id)) {

return Object.fromEntries(

WIDELY_SUPPORTED_EFFORTS.map((effort) => [effort, anthropicOpus45Effort(model, effort)]),

)

}

return {

high: {

thinking: {