@sleepy-ai/cli 0.1.16 → 0.1.17

package/src/provider/transform.ts

@@ -1,1393 +0,0 @@
-import type { ModelMessage } from "ai"
-import { mergeDeep, unique } from "remeda"
-import type { JSONSchema7 } from "@ai-sdk/provider"
-import type { JSONSchema } from "zod/v4/core"
-import type * as Provider from "./provider"
-import type * as ModelsDev from "./models"
-import { iife } from "@/util/iife"
-import { Flag } from "@/flag/flag"
-
-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
-}
-
-// Sleepy vision support isn't reflected in models.dev modality data, so the
-// generic capability check would strip images before they reach the model.
-// sleepy-auto and sleepy-v2.5 accept images; sleepy-v2.5-pro is text-only.
-function supportsImageInput(model: Provider.Model): boolean {
-  if (model.providerID === "sleepy" || model.providerID === "sleepy" || model.providerID === "sleepy") {
-    const id = model.id.toLowerCase()
-    if (id.includes("v2.5-pro")) return false
-    if (id === "sleepy-auto" || id.includes("v2.5")) return true
-  }
-  // Claude and GPT models are all multimodal regardless of catalog data.
-  const id = model.id.toLowerCase()
-  const apiID = model.api.id.toLowerCase()
-  if (id.includes("claude") || apiID.includes("claude") || model.providerID === "anthropic") return true
-  if (id.includes("gpt") || apiID.includes("gpt")) return true
-  return model.capabilities.input.image
-}
-
-export const OUTPUT_TOKEN_MAX = Flag.SLEEPYCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX || 32_000
-const SLEEPY_OUTPUT_TOKEN_MAX = 128_000
-
-// 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":
-      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/gateway":
-      return "gateway"
-    case "@openrouter/ai-sdk-provider":
-      return "openrouter"
-  }
-  return undefined
-}
-
-function normalizeMessages(
-  msgs: ModelMessage[],
-  model: Provider.Model,
-  _options: Record<string, unknown>,
-): ModelMessage[] {
-  // 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" || 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" || part.type === "reasoning") {
-            return part.text !== ""
-          }
-          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
-    })
-  }
-  if (["@ai-sdk/anthropic", "@ai-sdk/google-vertex/anthropic"].includes(model.api.npm)) {
-    // Anthropic rejects assistant turns where tool_use blocks are followed by non-tool
-    // content, e.g. [tool_use, tool_use, text], with:
-    // `tool_use` ids were found without `tool_result` blocks immediately after...
-    //
-    // Reorder that invalid shape into [text] + [tool_use, tool_use]. Consecutive
-    // assistant messages are later merged by the provider/SDK, so preserving the
-    // original [tool_use...] then [text] order still produces the invalid payload.
-    //
-    // The root cause appears to be somewhere upstream where the stream is originally
-    // processed. We were unable to locate an exact narrower reproduction elsewhere,
-    // so we keep this transform in place for the time being.
-    msgs = msgs.flatMap((msg) => {
-      if (msg.role !== "assistant" || !Array.isArray(msg.content)) return [msg]
-
-      const parts = msg.content
-      const first = parts.findIndex((part) => part.type === "tool-call")
-      if (first === -1) return [msg]
-      if (!parts.slice(first).some((part) => part.type !== "tool-call")) return [msg]
-      return [
-        { ...msg, content: parts.filter((part) => part.type !== "tool-call") },
-        { ...msg, content: parts.filter((part) => part.type === "tool-call") },
-      ]
-    })
-  }
-  if (
-    model.providerID === "mistral" ||
-    model.api.id.toLowerCase().includes("mistral") ||
-    model.api.id.toLocaleLowerCase().includes("devstral")
-  ) {
-    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
-  }
-
-  if (typeof model.capabilities.interleaved === "object" && model.capabilities.interleaved.field) {
-    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
-        if (reasoningText) {
-          return {
-            ...msg,
-            content: filteredContent,
-            providerOptions: {
-              ...msg.providerOptions,
-              openaiCompatible: {
-                ...msg.providerOptions?.openaiCompatible,
-                [field]: reasoningText,
-              },
-            },
-          }
-        }
-
-        return {
-          ...msg,
-          content: filteredContent,
-        }
-      }
-
-      return msg
-    })
-  }
-
-  return msgs
-}
-
-// Determines whether a model's provider respects inline cache_control / cachePoint
-// markers. Pure name matching (model.api.id.includes("claude")) is fragile — a Claude
-// model behind an OpenAI-compatible proxy gets matched but markers are silently dropped.
-// See docs/cache-policy.md and upstream opencode#26786.
-function supportsCacheMarkers(model: Provider.Model): boolean {
-  // Anthropic-only SDKs — always support inline markers
-  if (model.api.npm === "@ai-sdk/anthropic" || model.api.npm === "@ai-sdk/google-vertex/anthropic") return true
-  if (model.providerID === "anthropic" || model.providerID === "google-vertex-anthropic") return true
-  // Bedrock cachePoint is a Converse API feature, works across model families
-  if (model.api.npm === "@ai-sdk/amazon-bedrock") return true
-  // Multi-model providers: only Anthropic/Claude models support cache markers
-  if (
-    model.api.npm === "@openrouter/ai-sdk-provider" ||
-    model.api.npm === "@ai-sdk/github-copilot" ||
-    model.api.npm === "@ai-sdk/alibaba"
-  ) {
-    return (
-      model.api.id.includes("claude") ||
-      model.api.id.includes("anthropic") ||
-      model.id.includes("claude") ||
-      model.id.includes("anthropic")
-    )
-  }
-  return false
-}
-
-// The cache-control marker shape differs per provider/SDK. This is the single
-// source of truth, keyed by the SDK provider-options namespace. `applyCaching`
-// attaches the whole object (keyed by stored providerID) and lets `message()`
-// remap the active provider's namespace to its SDK key; `tools()` (which
-// bypasses that remap) resolves a single namespace up front via `cacheMarkerFor`.
-// Only Anthropic and OpenRouter expose a TTL in their AI SDK — the others ignore
-// an unknown `ttl`, so we thread it only there.
-function cacheMarkerOptions(model: Provider.Model) {
-  const ttl = model.cachePromptTTL === "1h" ? { ttl: "1h" as const } : {}
-  return {
-    anthropic: { cacheControl: { type: "ephemeral", ...ttl } },
-    openrouter: { cacheControl: { type: "ephemeral", ...ttl } },
-    bedrock: { cachePoint: { type: "default" } },
-    openaiCompatible: { cache_control: { type: "ephemeral" } },
-    copilot: { copilot_cache_control: { type: "ephemeral" } },
-    alibaba: { cacheControl: { type: "ephemeral" } },
-  }
-}
-
-// Resolve the marker for a single model, already keyed under the SDK namespace
-// the AI SDK expects — i.e. the remap that `message()` performs for messages,
-// done up front. Used by `tools()`, whose tools never pass through `message()`.
-// Returns undefined for providers that don't take inline markers (callers gate
-// on `supportsCacheMarkers` first, so this is just a type-safety fallback).
-function cacheMarkerFor(model: Provider.Model): Record<string, unknown> | undefined {
-  const shapes = cacheMarkerOptions(model)
-  const ns: keyof typeof shapes | undefined =
-    model.api.npm === "@ai-sdk/anthropic" || model.api.npm === "@ai-sdk/google-vertex/anthropic"
-      ? "anthropic"
-      : model.api.npm === "@openrouter/ai-sdk-provider"
-        ? "openrouter"
-        : model.api.npm === "@ai-sdk/amazon-bedrock"
-          ? "bedrock"
-          : model.api.npm === "@ai-sdk/github-copilot"
-            ? "copilot"
-            : model.api.npm === "@ai-sdk/alibaba"
-              ? "alibaba"
-              : undefined
-  if (!ns) return undefined
-  return { [ns]: shapes[ns] }
-}
-
-function applyCaching(msgs: ModelMessage[], model: Provider.Model): ModelMessage[] {
-  const providerOptions = cacheMarkerOptions(model)
-
-  // Strategy: prefix caching is longest-common-prefix based with a backward
-  // lookback window (Anthropic walks back ~20 blocks from a breakpoint to find
-  // a prior write). The markers that grow the cached prefix are pinned to the
-  // *tail* of the request. We place up to three stable breakpoints (Anthropic
-  // allows max 4):
-  // 1. Last system message — the immutable prompt prefix.
-  // 2+3. The last TWO messages — a "rolling double buffer". Each turn marks
-  //      messages[-2] and messages[-1]; next turn the old [-1] is now [-2] and
-  //      still carries its marker, so the lookback gets a cache READ hit, while
-  //      the new [-1] is the WRITE for the turn after.
-  //
-  //      Why two and not one: the second (next-to-last) marker is the safety
-  //      net for the tail boundary. When the last message is removed — a
-  //      tool-call retry, a Ctrl-C, or the user editing/deleting their latest
-  //      message — a lone tail marker disappears with it, and how much of the
-  //      surrounding prefix the provider then evicts depends on the upstream
-  //      (Anthropic) KV-cache implementation. The next-to-last marker is a
-  //      still-present, further-back write the next lookback can land on, so the
-  //      worst case degrades to "recompute only the removed message" instead of
-  //      "recompute the whole history". It also covers turns that append >20
-  //      blocks (tool spam pushes the prior write outside the lookback window).
-  //      Cost is ~equal to a single marker: the two adjacent breakpoints write
-  //      roughly the same incremental bytes as one, split in two, and a hit
-  //      never rewrites. A third marker would write a segment never read
-  //      independently, so two is the minimum that covers the boundary.
-  // We deliberately do NOT mark a drifting midpoint or a fixed before-last-user
-  // INDEX: those shift every turn without tracking the tail.
-  const targets: ModelMessage[] = []
-
-  const systemMsgs = msgs.filter((msg) => msg.role === "system")
-  if (systemMsgs.length > 0) targets.push(systemMsgs[systemMsgs.length - 1])
-
-  const nonSystem = msgs.filter((msg) => msg.role !== "system")
-  for (const msg of nonSystem.slice(-2)) targets.push(msg)
-
-  for (const msg of unique(targets)) {
-    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
-}
-
-// Minimal crash guard: ensure msg.content is never a non-string non-array value
-// (object, undefined, null) that would blow up downstream `.map()` calls.
-// Strings are valid ModelMessage content (the AI SDK accepts content: string |
-// Array) and are left untouched. Only genuinely-invalid types are normalized
-// to a safe empty array so every downstream path can safely call `.map()`.
-function normalizeContentArray(msgs: ModelMessage[]): ModelMessage[] {
-  return msgs.map((msg) => {
-    if (typeof msg.content === "string" || Array.isArray(msg.content)) return msg
-    // object / undefined / null — not a valid ModelMessage content shape;
-    // wrap in an empty array so .map() downstream never throws.
-    return { ...msg, content: [] } as ModelMessage
-  })
-}
-
-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
-      const supported = modality === "image" ? supportsImageInput(model) : model.capabilities.input[modality]
-      if (supported) 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 }
-  })
-}
-
-// Returns the decoded byte size of a base64 data URL, or undefined for inputs
-// that aren't data URLs (remote URLs, raw binary) and therefore can't be sized.
-function imageByteSize(image: string): number | undefined {
-  if (!image.startsWith("data:")) return undefined
-  const base64 = image.slice(image.indexOf(",") + 1)
-  if (!base64) return 0
-  const padding = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0
-  return Math.floor((base64.length * 3) / 4) - padding
-}
-
-function limitImages(msgs: ModelMessage[]): ModelMessage[] {
-  const maxImages = Flag.SLEEPYCODE_MAX_PROMPT_IMAGES
-  const maxSize = Flag.SLEEPYCODE_MAX_PROMPT_IMAGE_SIZE
-  if (maxImages === undefined && maxSize === undefined) return msgs
-
-  const total = msgs.reduce(
-    (sum, msg) =>
-      msg.role === "user" && Array.isArray(msg.content)
-        ? sum + msg.content.filter((part) => part.type === "image").length
-        : sum,
-    0,
-  )
-  // Drop the oldest excess images so the most recent ones reach the model.
-  let toDrop = maxImages === undefined ? 0 : Math.max(0, total - maxImages)
-
-  return msgs.map((msg) => {
-    if (msg.role !== "user" || !Array.isArray(msg.content)) return msg
-    const content = msg.content.map((part) => {
-      if (part.type !== "image") return part
-      if (toDrop > 0) {
-        toDrop--
-        return { type: "text" as const, text: `[Image omitted: exceeds the configured limit of ${maxImages} prompt image(s).]` }
-      }
-      if (maxSize !== undefined) {
-        const size = imageByteSize(String(part.image))
-        if (size !== undefined && size > maxSize) {
-          return { type: "text" as const, text: `[Image omitted: exceeds the configured ${maxSize}-byte prompt image size limit.]` }
-        }
-      }
-      return part
-    })
-    return { ...msg, content }
-  })
-}
-
-export function message(msgs: ModelMessage[], model: Provider.Model, options: Record<string, unknown>) {
-  // Guard against genuinely-invalid content (object/undefined/null) that would
-  // blow up downstream .map() calls. Strings are valid and left untouched.
-  msgs = normalizeContentArray(msgs)
-  msgs = unsupportedParts(msgs, model)
-  msgs = limitImages(msgs)
-  msgs = normalizeMessages(msgs, model, options)
-  if (supportsCacheMarkers(model)) {
-    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 = msgs.map((msg) => {
-      if (!Array.isArray(msg.content)) return { ...msg, providerOptions: remap(msg.providerOptions) }
-      return {
-        ...msg,
-        providerOptions: remap(msg.providerOptions),
-        content: msg.content.map((part) => {
-          if (part.type === "tool-approval-request" || part.type === "tool-approval-response") {
-            return { ...part }
-          }
-          return { ...part, providerOptions: remap(part.providerOptions) }
-        }),
-      } as typeof msg
-    })
-  }
-
-  return msgs
-}
-
-// Place a cache breakpoint on the tool definitions. The cache hierarchy is
-// `tools` → `system` → `messages`, so marking the LAST tool caches the entire
-// tool-schema block (often several KB) as a stable prefix that sits in front of
-// the system + message caches. Tools are passed to the SDK separately from
-// `message()` and never go through its providerID→SDK-key remap, so we resolve
-// the SDK-keyed marker via `cacheMarkerFor`. Tool registration order is stable
-// (insertion order of the tools record), so "last tool" is deterministic.
-export function tools<T extends Record<string, any>>(tools: T, model: Provider.Model): T {
-  if (!supportsCacheMarkers(model)) return tools
-  const marker = cacheMarkerFor(model)
-  if (!marker) return tools
-  const names = Object.keys(tools)
-  if (names.length === 0) return tools
-
-  const last = tools[names[names.length - 1]]
-  last.providerOptions = mergeDeep(last.providerOptions ?? {}, marker)
-  return tools
-}
-
-export function temperature(model: Provider.Model) {
-  const id = model.id.toLowerCase()
-  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("sleepy")) 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"]
-
-function anthropicAdaptiveEfforts(apiId: string): string[] | null {
-  if (["opus-4-7", "opus-4.7", "opus-4-8", "opus-4.8"].some((v) => apiId.includes(v))) {
-    return ["low", "medium", "high", "xhigh", "max"]
-  }
-  if (["opus-4-6", "opus-4.6", "sonnet-4-6", "sonnet-4.6"].some((v) => apiId.includes(v))) {
-    return ["low", "medium", "high", "max"]
-  }
-  return null
-}
-
-export function variants(model: Provider.Model): Record<string, Record<string, any>> {
-  if (!model.capabilities.reasoning) return {}
-
-  const id = model.id.toLowerCase()
-  const adaptiveEfforts = anthropicAdaptiveEfforts(model.api.id)
-  if (
-    id.includes("deepseek") ||
-    id.includes("minimax") ||
-    id.includes("glm") ||
-    id.includes("mistral") ||
-    id.includes("kimi") ||
-    id.includes("k2p5") ||
-    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" },
-    }
-  }
-  if (id.includes("grok")) return {}
-
-  switch (model.api.npm) {
-    case "@openrouter/ai-sdk-provider":
-      if (!model.id.includes("gpt") && !model.id.includes("gemini-3") && !model.id.includes("claude")) return {}
-      return Object.fromEntries(OPENAI_EFFORTS.map((effort) => [effort, { reasoning: { effort } }]))
-
-    case "@ai-sdk/gateway":
-      if (model.id.includes("anthropic")) {
-        if (adaptiveEfforts) {
-          return Object.fromEntries(
-            adaptiveEfforts.map((effort) => [
-              effort,
-              {
-                thinking: {
-                  type: "adaptive",
-                },
-                effort,
-              },
-            ]),
-          )
-        }
-        return {
-          high: {
-            thinking: {
-              type: "enabled",
-              budgetTokens: 16000,
-            },
-          },
-          max: {
-            thinking: {
-              type: "enabled",
-              budgetTokens: 31999,
-            },
-          },
-        }
-      }
-      if (model.id.includes("google")) {
-        if (id.includes("2.5")) {
-          return {
-            high: {
-              thinkingConfig: {
-                includeThoughts: true,
-                thinkingBudget: 16000,
-              },
-            },
-            max: {
-              thinkingConfig: {
-                includeThoughts: true,
-                thinkingBudget: 24576,
-              },
-            },
-          }
-        }
-        return Object.fromEntries(
-          ["low", "high"].map((effort) => [
-            effort,
-            {
-              includeThoughts: true,
-              thinkingLevel: effort,
-            },
-          ]),
-        )
-      }
-      return Object.fromEntries(OPENAI_EFFORTS.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: ["reasoning.encrypted_content"],
-          },
-        ]),
-      )
-
-    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":
-      return Object.fromEntries(WIDELY_SUPPORTED_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 {}
-      const azureEfforts = ["low", "medium", "high"]
-      if (id.includes("gpt-5-") || id === "gpt-5") {
-        azureEfforts.unshift("minimal")
-      }
-      return Object.fromEntries(
-        azureEfforts.map((effort) => [
-          effort,
-          {
-            reasoningEffort: effort,
-            reasoningSummary: "auto",
-            include: ["reasoning.encrypted_content"],
-          },
-        ]),
-      )
-    case "@ai-sdk/openai":
-      // https://v5.ai-sdk.dev/providers/ai-sdk-providers/openai
-      if (id === "gpt-5-pro") return {}
-      const openaiEfforts = iife(() => {
-        if (id.includes("codex")) {
-          if (id.includes("5.2") || id.includes("5.3")) return [...WIDELY_SUPPORTED_EFFORTS, "xhigh"]
-          return WIDELY_SUPPORTED_EFFORTS
-        }
-        const arr = [...WIDELY_SUPPORTED_EFFORTS]
-        if (id.includes("gpt-5-") || id === "gpt-5") {
-          arr.unshift("minimal")
-        }
-        if (model.release_date >= "2025-11-13") {
-          arr.unshift("none")
-        }
-        if (model.release_date >= "2025-12-04") {
-          arr.push("xhigh")
-        }
-        return arr
-      })
-      return Object.fromEntries(
-        openaiEfforts.map((effort) => [
-          effort,
-          {
-            reasoningEffort: effort,
-            reasoningSummary: "auto",
-            include: ["reasoning.encrypted_content"],
-          },
-        ]),
-      )
-
-    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 (model.providerID === "github-copilot") {
-        if (model.api.id.includes("opus-4.7")) {
-          return Object.fromEntries(["medium"].map((effort) => [effort, { reasoningEffort: effort }]))
-        }
-      }
-
-      if (adaptiveEfforts) {
-        return Object.fromEntries(
-          adaptiveEfforts.map((effort) => [
-            effort,
-            {
-              thinking: {
-                type: "adaptive",
-                ...(["opus-4-7", "opus-4.7", "opus-4-8", "opus-4.8"].some((v) => model.api.id.includes(v))
-                  ? { display: "summarized" }
-                  : {}),
-              },
-              effort,
-            },
-          ]),
-        )
-      }
-
-      return {
-        high: {
-          thinking: {
-            type: "enabled",
-            budgetTokens: Math.min(16_000, Math.floor(model.limit.output / 2 - 1)),
-          },
-        },
-        max: {
-          thinking: {
-            type: "enabled",
-            budgetTokens: Math.min(31_999, model.limit.output - 1),
-          },
-        },
-      }
-
-    case "@ai-sdk/amazon-bedrock":
-      // https://v5.ai-sdk.dev/providers/ai-sdk-providers/amazon-bedrock
-      if (adaptiveEfforts) {
-        return Object.fromEntries(
-          adaptiveEfforts.map((effort) => [
-            effort,
-            {
-              reasoningConfig: {
-                type: "adaptive",
-                maxReasoningEffort: effort,
-                ...(["opus-4-7", "opus-4.7", "opus-4-8", "opus-4.8"].some((v) => model.api.id.includes(v))
-                  ? { display: "summarized" }
-                  : {}),
-              },
-            },
-          ]),
-        )
-      }
-      // For Anthropic models on Bedrock, use reasoningConfig with budgetTokens
-      if (model.api.id.includes("anthropic")) {
-        return {
-          high: {
-            reasoningConfig: {
-              type: "enabled",
-              budgetTokens: 16000,
-            },
-          },
-          max: {
-            reasoningConfig: {
-              type: "enabled",
-              budgetTokens: 31999,
-            },
-          },
-        }
-      }
-
-      // For Amazon Nova models, use reasoningConfig with maxReasoningEffort
-      return Object.fromEntries(
-        WIDELY_SUPPORTED_EFFORTS.map((effort) => [
-          effort,
-          {
-            reasoningConfig: {
-              type: "enabled",
-              maxReasoningEffort: effort,
-            },
-          },
-        ]),
-      )
-
-    case "@ai-sdk/google-vertex":
-    // https://v5.ai-sdk.dev/providers/ai-sdk-providers/google-vertex
-    case "@ai-sdk/google":
-      // https://v5.ai-sdk.dev/providers/ai-sdk-providers/google-generative-ai
-      if (id.includes("2.5")) {
-        return {
-          high: {
-            thinkingConfig: {
-              includeThoughts: true,
-              thinkingBudget: 16000,
-            },
-          },
-          max: {
-            thinkingConfig: {
-              includeThoughts: true,
-              thinkingBudget: 24576,
-            },
-          },
-        }
-      }
-      let levels = ["low", "high"]
-      if (id.includes("3.1")) {
-        levels = ["low", "medium", "high"]
-      }
-
-      return Object.fromEntries(
-        levels.map((effort) => [
-          effort,
-          {
-            thinkingConfig: {
-              includeThoughts: true,
-              thinkingLevel: effort,
-            },
-          },
-        ]),
-      )
-
-    case "@ai-sdk/mistral":
-      // https://v5.ai-sdk.dev/providers/ai-sdk-providers/mistral
-      return {}
-
-    case "@ai-sdk/cohere":
-      // https://v5.ai-sdk.dev/providers/ai-sdk-providers/cohere
-      return {}
-
-    case "@ai-sdk/groq":
-      // https://v5.ai-sdk.dev/providers/ai-sdk-providers/groq
-      const groqEffort = ["none", ...WIDELY_SUPPORTED_EFFORTS]
-      return Object.fromEntries(
-        groqEffort.map((effort) => [
-          effort,
-          {
-            reasoningEffort: effort,
-          },
-        ]),
-      )
-
-    case "@ai-sdk/perplexity":
-      // https://v5.ai-sdk.dev/providers/ai-sdk-providers/perplexity
-      return {}
-
-    case "@jerome-benoit/sap-ai-provider-v2":
-      if (model.api.id.includes("anthropic")) {
-        if (adaptiveEfforts) {
-          return Object.fromEntries(
-            adaptiveEfforts.map((effort) => [
-              effort,
-              {
-                thinking: {
-                  type: "adaptive",
-                },
-                effort,
-              },
-            ]),
-          )
-        }
-        return {
-          high: {
-            thinking: {
-              type: "enabled",
-              budgetTokens: 16000,
-            },
-          },
-          max: {
-            thinking: {
-              type: "enabled",
-              budgetTokens: 31999,
-            },
-          },
-        }
-      }
-      if (model.api.id.includes("gemini") && id.includes("2.5")) {
-        return {
-          high: {
-            thinkingConfig: {
-              includeThoughts: true,
-              thinkingBudget: 16000,
-            },
-          },
-          max: {
-            thinkingConfig: {
-              includeThoughts: true,
-              thinkingBudget: 24576,
-            },
-          },
-        }
-      }
-      if (model.api.id.includes("gpt") || /\bo[1-9]/.test(model.api.id)) {
-        return Object.fromEntries(WIDELY_SUPPORTED_EFFORTS.map((effort) => [effort, { reasoningEffort: effort }]))
-      }
-      return {}
-  }
-  return {}
-}
-
-export function options(input: {
-  model: Provider.Model
-  sessionID: string
-  providerOptions?: Record<string, any>
-}): Record<string, any> {
-  const result: Record<string, any> = {}
-
-  // openai and providers using openai package should set store to false by default.
-  if (
-    input.model.providerID === "openai" ||
-    input.model.api.npm === "@ai-sdk/openai" ||
-    input.model.api.npm === "@ai-sdk/github-copilot"
-  ) {
-    result["store"] = false
-  }
-
-  if (input.model.api.npm === "@ai-sdk/azure") {
-    result["store"] = true
-    result["promptCacheKey"] = input.sessionID
-  }
-
-  if (input.model.api.npm === "@openrouter/ai-sdk-provider" || input.model.api.npm === "@llmgateway/ai-sdk-provider") {
-    result["usage"] = {
-      include: true,
-    }
-    if (input.model.api.id.includes("gemini-3")) {
-      result["reasoning"] = { effort: "high" }
-    }
-  }
-
-  if (
-    input.model.providerID === "baseten" ||
-    (input.model.providerID === "opencode" && ["kimi-k2-thinking", "glm-4.6"].includes(input.model.api.id))
-  ) {
-    result["chat_template_args"] = { enable_thinking: true }
-  }
-
-  if (
-    ["zai", "zhipuai"].some((id) => input.model.providerID.includes(id)) &&
-    input.model.api.npm === "@ai-sdk/openai-compatible"
-  ) {
-    result["thinking"] = {
-      type: "enabled",
-      clear_thinking: false,
-    }
-  }
-
-  if (input.model.providerID === "openai" || input.providerOptions?.setCacheKey) {
-    result["promptCacheKey"] = input.sessionID
-  }
-
-  if (input.model.api.npm === "@ai-sdk/google" || input.model.api.npm === "@ai-sdk/google-vertex") {
-    if (input.model.capabilities.reasoning) {
-      result["thinkingConfig"] = {
-        includeThoughts: true,
-      }
-      if (input.model.api.id.includes("gemini-3")) {
-        result["thinkingConfig"]["thinkingLevel"] = "high"
-      }
-    }
-  }
-
-  // Enable thinking by default for kimi-k2.5/k2p5 models using anthropic SDK
-  const modelId = input.model.api.id.toLowerCase()
-  if (
-    (input.model.api.npm === "@ai-sdk/anthropic" || input.model.api.npm === "@ai-sdk/google-vertex/anthropic") &&
-    (modelId.includes("k2p5") || modelId.includes("kimi-k2.5") || modelId.includes("kimi-k2p5"))
-  ) {
-    result["thinking"] = {
-      type: "enabled",
-      budgetTokens: Math.min(16_000, Math.floor(input.model.limit.output / 2 - 1)),
-    }
-  }
-
-  // Enable thinking for reasoning models on alibaba-cn (DashScope).
-  // DashScope's OpenAI-compatible API requires `enable_thinking: true` in the request body
-  // to return reasoning_content. Without it, models like kimi-k2.5, qwen-plus, qwen3, qwq,
-  // deepseek-r1, etc. never output thinking/reasoning tokens.
-  // Note: kimi-k2-thinking is excluded as it returns reasoning_content by default.
-  if (
-    input.model.providerID === "alibaba-cn" &&
-    input.model.capabilities.reasoning &&
-    input.model.api.npm === "@ai-sdk/openai-compatible" &&
-    !modelId.includes("kimi-k2-thinking")
-  ) {
-    result["enable_thinking"] = true
-  }
-
-  if (input.model.api.id.includes("gpt-5") && !input.model.api.id.includes("gpt-5-chat")) {
-    if (!input.model.api.id.includes("gpt-5-pro")) {
-      result["reasoningEffort"] = "medium"
-      // Only inject reasoningSummary for providers that support it natively.
-      // @ai-sdk/openai-compatible proxies (e.g. LiteLLM) do not understand this
-      // parameter and return "Unknown parameter: 'reasoningSummary'".
-      if (
-        input.model.api.npm === "@ai-sdk/openai" ||
-        input.model.api.npm === "@ai-sdk/azure" ||
-        input.model.api.npm === "@ai-sdk/github-copilot"
-      ) {
-        result["reasoningSummary"] = "auto"
-      }
-    }
-
-    // Only set textVerbosity for non-chat gpt-5.x models
-    // Chat models (e.g. gpt-5.2-chat-latest) only support "medium" verbosity
-    if (
-      input.model.api.id.includes("gpt-5.") &&
-      !input.model.api.id.includes("codex") &&
-      !input.model.api.id.includes("-chat") &&
-      input.model.providerID !== "azure"
-    ) {
-      result["textVerbosity"] = "low"
-    }
-
-    if (input.model.providerID.startsWith("opencode")) {
-      result["promptCacheKey"] = input.sessionID
-      result["include"] = ["reasoning.encrypted_content"]
-      result["reasoningSummary"] = "auto"
-    }
-  }
-
-  if (input.model.providerID === "venice") {
-    result["promptCacheKey"] = input.sessionID
-  }
-
-  if (input.model.providerID === "openrouter") {
-    result["prompt_cache_key"] = input.sessionID
-  }
-  if (input.model.api.npm === "@ai-sdk/gateway") {
-    result["gateway"] = {
-      caching: "auto",
-    }
-  }
-
-  return result
-}
-
-export function smallOptions(model: Provider.Model) {
-  if (
-    model.providerID === "openai" ||
-    model.api.npm === "@ai-sdk/openai" ||
-    model.api.npm === "@ai-sdk/github-copilot"
-  ) {
-    if (model.api.id.includes("gpt-5")) {
-      if (model.api.id.includes("5.") || model.api.id.includes("5-mini")) {
-        return { store: false, reasoningEffort: "low" }
-      }
-      return { store: false, reasoningEffort: "minimal" }
-    }
-    return { store: false }
-  }
-  if (model.providerID === "google") {
-    // gemini-3 uses thinkingLevel, gemini-2.5 uses thinkingBudget
-    if (model.api.id.includes("gemini-3")) {
-      return { thinkingConfig: { thinkingLevel: "minimal" } }
-    }
-    return { thinkingConfig: { thinkingBudget: 0 } }
-  }
-  if (model.providerID === "openrouter" || model.providerID === "llmgateway") {
-    if (model.api.id.includes("google")) {
-      return { reasoning: { enabled: false } }
-    }
-    return { reasoningEffort: "minimal" }
-  }
-
-  if (model.providerID === "venice") {
-    return { veniceParameters: { disableThinking: true } }
-  }
-
-  return {}
-}
-
-// Maps model ID prefix to provider slug used in providerOptions.
-// Example: "amazon/nova-2-lite" → "bedrock"
-const SLUG_OVERRIDES: Record<string, string> = {
-  amazon: "bedrock",
-}
-
-export function providerOptions(model: Provider.Model, options: { [x: string]: any }) {
-  if (model.api.npm === "@ai-sdk/gateway") {
-    // Gateway providerOptions are split across two namespaces:
-    // - `gateway`: gateway-native routing/caching controls (order, only, byok, etc.)
-    // - `<upstream slug>`: provider-specific model options (anthropic/openai/...)
-    // We keep `gateway` as-is and route every other top-level option under the
-    // model-derived upstream slug.
-    const i = model.api.id.indexOf("/")
-    const rawSlug = i > 0 ? model.api.id.slice(0, i) : undefined
-    const slug = rawSlug ? (SLUG_OVERRIDES[rawSlug] ?? rawSlug) : undefined
-    const gateway = options.gateway
-    const rest = Object.fromEntries(Object.entries(options).filter(([k]) => k !== "gateway"))
-    const has = Object.keys(rest).length > 0
-
-    const result: Record<string, any> = {}
-    if (gateway !== undefined) result.gateway = gateway
-
-    if (has) {
-      if (slug) {
-        // Route model-specific options under the provider slug
-        result[slug] = rest
-      } else if (gateway && typeof gateway === "object" && !Array.isArray(gateway)) {
-        result.gateway = { ...gateway, ...rest }
-      } else {
-        result.gateway = rest
-      }
-    }
-
-    return result
-  }
-
-  const key = sdkKey(model.api.npm) ?? model.providerID
-  // @ai-sdk/azure delegates to OpenAIChatLanguageModel which reads from
-  // providerOptions["openai"], but OpenAIResponsesLanguageModel checks
-  // "azure" first. Pass both so model options work on either code path.
-  if (model.api.npm === "@ai-sdk/azure") {
-    return { openai: options, azure: options }
-  }
-  return { [key]: options }
-}
-
-export function maxOutputTokens(model: Provider.Model): number {
-  if (model.providerID === "sleepy" || model.providerID === "sleepy" || model.providerID === "sleepy" || model.id.toLowerCase().includes("sleepy")) {
-    return SLEEPY_OUTPUT_TOKEN_MAX
-  }
-  return Math.min(model.limit.output, OUTPUT_TOKEN_MAX) || OUTPUT_TOKEN_MAX
-}
-
-// Flatten a root-level `anyOf` / `oneOf` (typically from `z.discriminatedUnion`)
-// into a single `type: "object"` schema with all variant properties merged at
-// the root. The discriminator key becomes an `enum`, and per-variant required
-// fields are encoded as a textual hint on the discriminator's description.
-//
-// OpenAI's function-calling validator rejects oneOf/anyOf/allOf/enum/not at the
-// top level outright, so this is the only shape that gets through. We retain
-// `additionalProperties: false` to keep the model from inventing fields, and
-// rely on zod's runtime parse (still using the original discriminated union)
-// to enforce per-action required fields strictly.
-function flattenDiscriminatedUnion(schema: JSONSchema.BaseSchema | JSONSchema7): JSONSchema7 {
-  const root = schema as Record<string, any>
-  const variants = (root.anyOf ?? root.oneOf) as Array<Record<string, any>> | undefined
-  if (!variants?.length) return schema as JSONSchema7
-
-  // Find the discriminator: a property whose `const` differs across all variants.
-  const constByKey = new Map<string, Set<unknown>>()
-  for (const v of variants) {
-    if (!v.properties) continue
-    for (const [key, prop] of Object.entries(v.properties as Record<string, any>)) {
-      if (prop && typeof prop === "object" && "const" in prop) {
-        if (!constByKey.has(key)) constByKey.set(key, new Set())
-        constByKey.get(key)!.add(prop.const)
-      }
-    }
-  }
-  let discriminator: string | undefined
-  for (const [key, values] of constByKey) {
-    if (values.size === variants.length) {
-      discriminator = key
-      break
-    }
-  }
-
-  // Merge non-discriminator properties from every variant. Track which variants
-  // each property appeared in so the description can tell the model
-  // "(only when action='X'|'Y')" — flat schemas tempt some models (notably
-  // gpt-5.5) to fill every property regardless of which action they chose.
-  const properties: Record<string, any> = {}
-  const propertyOwners: Record<string, unknown[]> = {}
-  for (const v of variants) {
-    if (!v.properties) continue
-    const variantValue = discriminator
-      ? (v.properties as Record<string, any>)[discriminator]?.const
-      : undefined
-    for (const [key, prop] of Object.entries(v.properties as Record<string, any>)) {
-      if (key === discriminator) continue
-      if (!(key in properties)) properties[key] = prop
-      if (variantValue !== undefined) {
-        if (!propertyOwners[key]) propertyOwners[key] = []
-        propertyOwners[key].push(variantValue)
-      }
-    }
-  }
-  if (discriminator) {
-    for (const [key, owners] of Object.entries(propertyOwners)) {
-      if (owners.length === variants.length) continue // present in every variant — no annotation
-      const tag = `(only when ${discriminator}=${owners.map((o) => JSON.stringify(o)).join("|")})`
-      const original = (properties[key] as Record<string, any>).description as string | undefined
-      properties[key] = {
-        ...properties[key],
-        description: original ? `${tag} ${original}` : tag,
-      }
-    }
-  }
-
-  // Discriminator becomes an enum with per-variant required fields hinted in
-  // its description. Without this hint the model only sees a flat bag of
-  // optional fields and forgets what to provide for each action.
-  if (discriminator) {
-    const proto = (variants[0].properties as Record<string, any>)[discriminator]
-    const enumValues = variants.map((v) => (v.properties as Record<string, any>)[discriminator!]?.const)
-    const baseDescription = (proto?.description as string | undefined) ?? ""
-    const hints = variants
-      .map((v) => {
-        const value = (v.properties as Record<string, any>)[discriminator!]?.const
-        const required = ((v.required as string[] | undefined) ?? []).filter((r) => r !== discriminator)
-        return required.length > 0 ? `${value}: requires ${required.join(", ")}` : `${value}: no extra required fields`
-      })
-      .join("; ")
-    properties[discriminator] = {
-      type: "string",
-      enum: enumValues,
-      description: baseDescription ? `${baseDescription}\n\nPer-${discriminator}: ${hints}.` : `Per-${discriminator}: ${hints}.`,
-    }
-  }
-
-  return {
-    type: "object",
-    properties,
-    required: discriminator ? [discriminator] : [],
-    additionalProperties: false,
-  } as JSONSchema7
-}
-
-export function schema(model: Provider.Model, schema: JSONSchema.BaseSchema | JSONSchema7): JSONSchema7 {
-  /*
-  if (["openai", "azure"].includes(providerID)) {
-    if (schema.type === "object" && schema.properties) {
-      for (const [key, value] of Object.entries(schema.properties)) {
-        if (schema.required?.includes(key)) continue
-        schema.properties[key] = {
-          anyOf: [
-            value as JSONSchema.JSONSchema,
-            {
-              type: "null",
-            },
-          ],
-        }
-      }
-    }
-  }
-  */
-
-  // Many providers reject root-level `anyOf`/`oneOf` in tool schemas:
-  // - OpenAI/Azure: "schema must have type 'object' and not have 'oneOf'/'anyOf'"
-  // - Bedrock: "input_schema.type: Field required"
-  // - Anthropic proxies to Bedrock: same Bedrock error
-  // Flatten unconditionally — all providers accept a flat `type: "object"` schema,
-  // and zod's runtime parse still enforces per-variant required fields strictly.
-  schema = flattenDiscriminatedUnion(schema)
-
-  // Convert integer enums to string enums for Google/Gemini
-  if (model.providerID === "google" || model.api.id.includes("gemini")) {
-    const isPlainObject = (node: unknown): node is Record<string, any> =>
-      typeof node === "object" && node !== null && !Array.isArray(node)
-    const hasCombiner = (node: unknown) =>
-      isPlainObject(node) && (Array.isArray(node.anyOf) || Array.isArray(node.oneOf) || Array.isArray(node.allOf))
-    const hasSchemaIntent = (node: unknown) => {
-      if (!isPlainObject(node)) return false
-      if (hasCombiner(node)) return true
-      return [
-        "type",
-        "properties",
-        "items",
-        "prefixItems",
-        "enum",
-        "const",
-        "$ref",
-        "additionalProperties",
-        "patternProperties",
-        "required",
-        "not",
-        "if",
-        "then",
-        "else",
-      ].some((key) => key in node)
-    }
-
-    const sanitizeGemini = (obj: any): any => {
-      if (obj === null || typeof obj !== "object") {
-        return obj
-      }
-
-      if (Array.isArray(obj)) {
-        return obj.map(sanitizeGemini)
-      }
-
-      const result: any = {}
-      for (const [key, value] of Object.entries(obj)) {
-        if (key === "enum" && Array.isArray(value)) {
-          // Convert all enum values to strings
-          result[key] = value.map((v) => String(v))
-          // If we have integer type with enum, change type to string
-          if (result.type === "integer" || result.type === "number") {
-            result.type = "string"
-          }
-        } else if (typeof value === "object" && value !== null) {
-          result[key] = sanitizeGemini(value)
-        } else {
-          result[key] = value
-        }
-      }
-
-      // Filter required array to only include fields that exist in properties
-      if (result.type === "object" && result.properties && Array.isArray(result.required)) {
-        result.required = result.required.filter((field: any) => field in result.properties)
-      }
-
-      if (result.type === "array" && !hasCombiner(result)) {
-        if (result.items == null) {
-          result.items = {}
-        }
-        // Ensure items has a type only when it's still schema-empty.
-        if (isPlainObject(result.items) && !hasSchemaIntent(result.items)) {
-          result.items.type = "string"
-        }
-      }
-
-      // Remove properties/required from non-object types (Gemini rejects these)
-      if (result.type && result.type !== "object" && !hasCombiner(result)) {
-        delete result.properties
-        delete result.required
-      }
-
-      return result
-    }
-
-    schema = sanitizeGemini(schema)
-  }
-
-  return schema as JSONSchema7
-}