@amir83nasr/10router 0.1.0

package/open-sse/providers/capabilities.js

@@ -0,0 +1,1543 @@
+// Model capabilities — what each model can read/do beyond plain text.
+//
+// Fallback order (first match wins), result merged over DEFAULT_CAPABILITIES:
+//   1. PROVIDER_CAPABILITIES[provider][model]  — provider-specific override
+//   2. MODEL_CAPABILITIES[model]               — canonical exact id (handles exceptions)
+//   3. PATTERN_CAPABILITIES                     — glob match, ordered specific -> generic
+//   4. DEFAULT_CAPABILITIES                     — safe floor (always returned)
+//
+// Two extra layers then refine the result, and neither can override the hand
+// written tables above (steps 1-2 short-circuit before they are consulted):
+//   • the synced catalog — modalities keyed by model, limits keyed by provider
+//     + model, refreshed from models.dev in the background. It reads a file, so
+//     the server installs it via setCatalogSource(); this module stays free of
+//     node:fs because the dashboard bundles it into the browser too.
+//   • visionPatterns.js — name-based vision detection, last resort so a model
+//     nobody has catalogued yet still accepts images.
+// Both only ever turn a capability ON.
+//
+// ── HOW TO ADD / UPDATE A MODEL ──────────────────────────────────────
+// Authoritative data source: https://models.dev/api.json (145 providers, 4000+
+// models, MIT). Each model exposes the exact fields we map below:
+//   modalities.input  ["text","image","pdf","audio","video"] -> vision / pdf / audioInput / videoInput
+//   modalities.output ["text","image","audio"]               -> imageOutput / audioOutput
+//   reasoning   -> reasoning      tool_call    -> tools
+//   limit.context -> contextWindow   limit.output -> maxOutput
+// Look up the model id, then:
+//   • If a PATTERN below already covers it correctly -> nothing to do.
+//   • If it is an exception (pattern would mis-match) -> add an exact entry to
+//     MODEL_CAPABILITIES (only the fields that differ from DEFAULT).
+//   • If a whole new family -> add an ordered PATTERN (specific before generic).
+// NOTE: models.dev has NO "search" flag (web search is a runtime tool, not a
+// model spec); set `search` from vendor docs (Claude 4.x+, GPT-5.x/4o, Gemini
+// 2.0+, Grok, Perplexity). Verify with: curl -s https://models.dev/api.json
+
+import { matchPattern } from "./pricing.js";
+import { looksLikeVisionModel } from "./visionPatterns.js";
+
+/**
+ * Safe floor — every resolved result is merged over this so consumers
+ * never need null-checks. Most modern LLMs meet these limits.
+ */
+export const DEFAULT_CAPABILITIES = {
+  // input modalities
+  vision: false, // read images
+  pdf: false, // read PDF / documents
+  audioInput: false, // read audio
+  videoInput: false, // read video
+  // output modalities
+  imageOutput: false, // generate images
+  audioOutput: false, // generate audio
+  // features
+  search: false, // built-in web search tool / grounding
+  tools: true, // function / tool calling
+  reasoning: false, // thinking / reasoning
+  // thinking wire format (only meaningful when reasoning:true). null → derive from transport.format.
+  // enum: openai|claude-adaptive|claude-budget|gemini-level|gemini-budget|zai|qwen|deepseek|kimi|minimax|hunyuan|step
+  thinkingFormat: null,
+  thinkingCanDisable: true, // false → model cannot turn thinking off (clamp to min instead of disable)
+  thinkingRange: null, // { min, max } for budget formats; null = no clamp
+  thinkingEffortSupported: false, // zai format only: model accepts a reasoning_effort level (GLM-5.2+; older GLM ignores it)
+  // limits (tokens)
+  contextWindow: 200000,
+  maxOutput: 64000,
+};
+
+// User-added model metadata can carry dashboard service kinds instead of the
+// runtime capability names used here. Map those typed model kinds into input /
+// output capabilities so custom vision models are not treated as text-only.
+const SERVICE_KIND_CAPABILITIES = {
+  imageToText: { vision: true },
+  image: { imageOutput: true },
+  stt: { audioInput: true },
+  tts: { audioOutput: true },
+  embedding: { tools: false },
+};
+
+export function capabilitiesFromServiceKind(kind) {
+  return SERVICE_KIND_CAPABILITIES[kind] || null;
+}
+
+/**
+ * Canonical exact-id overrides — used for exceptions that patterns would
+ * otherwise mis-match. Only declare deltas vs DEFAULT.
+ */
+export const MODEL_CAPABILITIES = {
+  // Claude Fable 5.1, Opus 5, 4.6/4.7/4.8, and Kiro Sonnet 5 have 1M context + adaptive thinking (override generic claude pattern)
+  "claude-fable-5-1": {
+    vision: true,
+    reasoning: true,
+    search: true,
+    thinkingFormat: "claude-adaptive",
+    thinkingCanDisable: false,
+    contextWindow: 1000000,
+    maxOutput: 128000,
+  },
+  "claude-opus-5": {
+    vision: true,
+    reasoning: true,
+    search: true,
+    thinkingFormat: "claude-adaptive",
+    contextWindow: 1000000,
+    maxOutput: 128000,
+  },
+  "claude-opus-5-thinking": {
+    vision: true,
+    reasoning: true,
+    search: true,
+    thinkingFormat: "claude-adaptive",
+    contextWindow: 1000000,
+    maxOutput: 128000,
+  },
+  "claude-opus-5-agentic": {
+    vision: true,
+    reasoning: true,
+    search: true,
+    thinkingFormat: "claude-adaptive",
+    contextWindow: 1000000,
+    maxOutput: 128000,
+  },
+  "claude-opus-5-thinking-agentic": {
+    vision: true,
+    reasoning: true,
+    search: true,
+    thinkingFormat: "claude-adaptive",
+    contextWindow: 1000000,
+    maxOutput: 128000,
+  },
+  "claude-opus-4.6": {
+    vision: true,
+    reasoning: true,
+    search: true,
+    thinkingFormat: "claude-adaptive",
+    contextWindow: 1000000,
+    maxOutput: 128000,
+  },
+  "claude-opus-4.7": {
+    vision: true,
+    reasoning: true,
+    search: true,
+    thinkingFormat: "claude-adaptive",
+    contextWindow: 1000000,
+    maxOutput: 128000,
+  },
+  "claude-opus-4-7": {
+    vision: true,
+    reasoning: true,
+    search: true,
+    thinkingFormat: "claude-adaptive",
+    contextWindow: 1000000,
+    maxOutput: 128000,
+  },
+  "claude-opus-4.8": {
+    vision: true,
+    reasoning: true,
+    search: true,
+    thinkingFormat: "claude-adaptive",
+    contextWindow: 1000000,
+    maxOutput: 128000,
+  },
+  "claude-opus-4-6": {
+    vision: true,
+    reasoning: true,
+    search: true,
+    thinkingFormat: "claude-adaptive",
+    contextWindow: 1000000,
+    maxOutput: 128000,
+  },
+  "claude-opus-4-8": {
+    vision: true,
+    reasoning: true,
+    search: true,
+    thinkingFormat: "claude-adaptive",
+    contextWindow: 1000000,
+    maxOutput: 128000,
+  },
+  "claude-opus-4.8-thinking": {
+    vision: true,
+    reasoning: true,
+    search: true,
+    thinkingFormat: "claude-adaptive",
+    contextWindow: 1000000,
+    maxOutput: 128000,
+  },
+  "claude-opus-4-8-thinking": {
+    vision: true,
+    reasoning: true,
+    search: true,
+    thinkingFormat: "claude-adaptive",
+    contextWindow: 1000000,
+    maxOutput: 128000,
+  },
+  "claude-sonnet-4.6": {
+    vision: true,
+    reasoning: true,
+    search: true,
+    thinkingFormat: "claude-adaptive",
+    contextWindow: 1000000,
+    maxOutput: 128000,
+  },
+  "claude-sonnet-4-6": {
+    vision: true,
+    reasoning: true,
+    search: true,
+    thinkingFormat: "claude-adaptive",
+    contextWindow: 1000000,
+    maxOutput: 128000,
+  },
+  "claude-sonnet-5": {
+    vision: true,
+    reasoning: true,
+    search: true,
+    thinkingFormat: "claude-adaptive",
+    contextWindow: 1000000,
+    maxOutput: 128000,
+  },
+  "claude-sonnet-5-thinking": {
+    vision: true,
+    reasoning: true,
+    search: true,
+    thinkingFormat: "claude-adaptive",
+    contextWindow: 1000000,
+    maxOutput: 128000,
+  },
+  "claude-sonnet-5-agentic": {
+    vision: true,
+    reasoning: true,
+    search: true,
+    thinkingFormat: "claude-adaptive",
+    contextWindow: 1000000,
+    maxOutput: 128000,
+  },
+  "claude-sonnet-5-thinking-agentic": {
+    vision: true,
+    reasoning: true,
+    search: true,
+    thinkingFormat: "claude-adaptive",
+    contextWindow: 1000000,
+    maxOutput: 128000,
+  },
+
+  // Gemini image-gen / OpenAI image / xai image variants
+  "gpt-image-1": { imageOutput: true, tools: false },
+
+  // GLM vision variants (text GLM has no vision) — 5.3-Flash and 5V-Turbo are
+  // natively multimodal per z.ai, and 5.3-Flash carries the full 1M window.
+  "glm-5.3-flash": {
+    vision: true,
+    videoInput: true,
+    pdf: true,
+    reasoning: true,
+    thinkingFormat: "zai",
+    thinkingEffortSupported: true,
+    contextWindow: 1000000,
+    maxOutput: 131072,
+  },
+  "glm-4.6v": {
+    vision: true,
+    videoInput: true,
+    reasoning: true,
+    thinkingFormat: "zai",
+    contextWindow: 128000,
+    maxOutput: 32768,
+  },
+  "glm-4.5v": {
+    vision: true,
+    videoInput: true,
+    reasoning: true,
+    thinkingFormat: "zai",
+    contextWindow: 64000,
+    maxOutput: 16384,
+  },
+
+  // DeepSeek's first V4 model with image input; text limits match V4-Flash.
+  "deepseek-v4-flash-vision-exp": {
+    vision: true,
+    reasoning: true,
+    thinkingFormat: "deepseek",
+    contextWindow: 1000000,
+    maxOutput: 384000,
+  },
+
+  // DeepSeek V4.1-Flash is natively multimodal — models.dev lists
+  // opencode-go/deepseek-v4.1-flash with modalities.input ["text","image"] — and upstream
+  // the retired v4-flash / vision-exp ids route to it, so the live V4.1 ids carry the
+  // same image capability as the exp id above. "deepseek-flash" is the GA id on the
+  // DeepSeek API; it previously fell through to the generic *deepseek* pattern, whose
+  // 128K/64K limits are kept here. The repeated fields are deliberate: an exact entry
+  // short-circuits the pattern table, so a vision-only delta would drop them.
+  "deepseek-v4.1-flash": {
+    vision: true,
+    reasoning: true,
+    thinkingFormat: "deepseek",
+    contextWindow: 1000000,
+    maxOutput: 384000,
+  },
+  "deepseek-flash": {
+    vision: true,
+    reasoning: true,
+    thinkingFormat: "deepseek",
+    contextWindow: 128000,
+    maxOutput: 64000,
+  },
+
+  // Qwen plain coder/text (no vision) — registry "vision-model" / "coder-model" aliases
+  "vision-model": { vision: true, reasoning: true, thinkingFormat: "qwen", contextWindow: 1000000 },
+  "coder-model": { reasoning: true, thinkingFormat: "qwen", contextWindow: 1000000 },
+
+  // Kimi flagship + coding (platform + Kimi Code ids) — vision/video native
+  "kimi-k3": {
+    vision: true,
+    videoInput: true,
+    reasoning: true,
+    thinkingFormat: "kimi",
+    thinkingCanDisable: false,
+    contextWindow: 1048576,
+    maxOutput: 131072,
+  },
+  k3: {
+    vision: true,
+    videoInput: true,
+    reasoning: true,
+    thinkingFormat: "kimi",
+    thinkingCanDisable: false,
+    contextWindow: 1048576,
+    maxOutput: 131072,
+  },
+  "kimi-for-coding": {
+    vision: true,
+    videoInput: true,
+    reasoning: true,
+    thinkingFormat: "kimi",
+    thinkingCanDisable: false,
+    contextWindow: 262144,
+    maxOutput: 65536,
+  },
+  "kimi-for-coding-highspeed": {
+    vision: true,
+    videoInput: true,
+    reasoning: true,
+    thinkingFormat: "kimi",
+    thinkingCanDisable: false,
+    contextWindow: 262144,
+    maxOutput: 65536,
+  },
+  "kimi-k2.7-code": {
+    vision: true,
+    videoInput: true,
+    reasoning: true,
+    thinkingFormat: "kimi",
+    thinkingCanDisable: false,
+    contextWindow: 262144,
+    maxOutput: 65536,
+  },
+  "kimi-k2.7-code-highspeed": {
+    vision: true,
+    videoInput: true,
+    reasoning: true,
+    thinkingFormat: "kimi",
+    thinkingCanDisable: false,
+    contextWindow: 262144,
+    maxOutput: 65536,
+  },
+  // OpenCode Free Muse Spark — multimodal (text+image per models.dev meta/muse-spark)
+  // via OpenAI Responses input_image; reasoning supports up to xhigh.
+  "muse-spark-1.2-contributor-free": {
+    vision: true,
+    reasoning: true,
+    thinkingFormat: "openai",
+    contextWindow: 1048576,
+    maxOutput: 131072,
+  },
+  "muse-spark-1.3-contributor-free": {
+    vision: true,
+    reasoning: true,
+    thinkingFormat: "openai",
+    contextWindow: 1048576,
+    maxOutput: 131072,
+  },
+  // OpenCode Free Union Alpha — multimodal (text+vision), 262K context, 131K max output
+  "union-alpha": { vision: true, contextWindow: 262144, maxOutput: 131072 },
+};
+
+// Codex OAuth (ChatGPT backend) — per-model context window reported by upstream
+// (lower than OpenAI API's 1.05M). Sol differs from Terra/Luna. #2720
+const CODEX_GPT_56_SOL_CAPS = {
+  vision: true,
+  reasoning: true,
+  search: true,
+  thinkingFormat: "openai",
+  contextWindow: 372000,
+  maxOutput: 128000,
+};
+const CODEX_GPT_56_DEFAULT_CAPS = {
+  vision: true,
+  reasoning: true,
+  search: true,
+  thinkingFormat: "openai",
+  contextWindow: 272000,
+  maxOutput: 128000,
+};
+
+/**
+ * Provider-specific capability overrides. Keyed by provider alias/id.
+ */
+export const PROVIDER_CAPABILITIES = {
+  // NVIDIA NIM is OpenAI-compatible → rejects MiniMax/GLM native `thinking` field.
+  // Force openai reasoning_effort format for its reasoning models. #issue
+  nvidia: {
+    "minimaxai/minimax-m2.7": {
+      reasoning: true,
+      thinkingFormat: "openai",
+      thinkingCanDisable: false,
+      contextWindow: 200000,
+      maxOutput: 131072,
+    },
+    "minimaxai/minimax-m3": {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "openai",
+      thinkingCanDisable: false,
+      contextWindow: 512000,
+      maxOutput: 131072,
+    },
+    "z-ai/glm-5.2": {
+      reasoning: true,
+      thinkingFormat: "openai",
+      contextWindow: 200000,
+      maxOutput: 128000,
+    },
+    "deepseek-ai/deepseek-v4-pro": {
+      reasoning: true,
+      thinkingFormat: "openai",
+      contextWindow: 1000000,
+      maxOutput: 65536,
+    },
+    "deepseek-ai/deepseek-v4-flash": {
+      reasoning: true,
+      thinkingFormat: "openai",
+      contextWindow: 1000000,
+      maxOutput: 65536,
+    },
+  },
+  codex: {
+    "gpt-6-astra": {
+      vision: true,
+      reasoning: true,
+      search: true,
+      thinkingFormat: "openai",
+      contextWindow: 272000,
+      maxOutput: 128000,
+    },
+    "gpt-5.6-sol": CODEX_GPT_56_SOL_CAPS,
+    "gpt-5.6-sol-review": CODEX_GPT_56_SOL_CAPS,
+    "gpt-5.6-terra": CODEX_GPT_56_DEFAULT_CAPS,
+    "gpt-5.6-terra-review": CODEX_GPT_56_DEFAULT_CAPS,
+    "gpt-5.6-luna": CODEX_GPT_56_DEFAULT_CAPS,
+    "gpt-5.6-luna-review": CODEX_GPT_56_DEFAULT_CAPS,
+  },
+  // CodeBuddy.cn — authoritative per-model metadata from the gateway's model
+  // config (contextWindow=maxInputTokens, maxOutput=maxOutputTokens, vision=
+  // supportsImages). Every model reasons via OpenAI-style reasoning_effort
+  // (see registry thinkingFormat). For thinkingCanDisable use the server's
+  // reasoning.canDisableThinking flag — see the note in the codebuddy-cn block
+  // below; it is NOT the inverse of onlyReasoning.
+  "codebuddy-cn": {
+    "glm-5.2": {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "openai",
+      thinkingCanDisable: true,
+      contextWindow: 1000000,
+      maxOutput: 48000,
+    },
+    "glm-5.1": {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "openai",
+      thinkingCanDisable: false,
+      contextWindow: 200000,
+      maxOutput: 48000,
+    },
+    "glm-5.0": {
+      reasoning: true,
+      thinkingFormat: "openai",
+      contextWindow: 200000,
+      maxOutput: 48000,
+    },
+    // maxOutput 64000 per both the plugin-baked fallback and the live server
+    // table (the old 38000 had no source and truncated output).
+    "glm-5v-turbo": {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "openai",
+      thinkingCanDisable: false,
+      contextWindow: 200000,
+      maxOutput: 64000,
+    },
+    "glm-4.7": {
+      reasoning: true,
+      thinkingFormat: "openai",
+      contextWindow: 200000,
+      maxOutput: 48000,
+    },
+    "minimax-m3": {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "openai",
+      thinkingCanDisable: false,
+      contextWindow: 512000,
+      maxOutput: 128000,
+    },
+    "kimi-k2.7": {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "openai",
+      thinkingCanDisable: false,
+      contextWindow: 256000,
+      maxOutput: 32000,
+    },
+    "kimi-k2.6": {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "openai",
+      thinkingCanDisable: false,
+      contextWindow: 256000,
+      maxOutput: 32000,
+    },
+    // Per-model values mirror the server's product-config payload (the plugin
+    // fetches it from copilot.tencent.com; the `models[]` entries carry
+    // maxInputTokens/maxOutputTokens/supportsImages). contextWindow =
+    // maxInputTokens, maxOutput = maxOutputTokens. Where the server and the
+    // plugin-baked fallback disagree, the server table wins.
+    // ⚠️ thinkingCanDisable maps to the server's reasoning.canDisableThinking —
+    // it is NOT the inverse of onlyReasoning. onlyReasoning means "thinking is
+    // on by default"; canDisableThinking means "it CAN be turned off". glm-5.3
+    // and glm-5.3-flash are onlyReasoning:true BUT canDisableThinking:true, so
+    // their thinking is switchable; the hy* models are forced always-on.
+    hy3: {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "openai",
+      thinkingCanDisable: false,
+      contextWindow: 192000,
+      maxOutput: 64000,
+    },
+    "hy4-preview": {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "openai",
+      thinkingCanDisable: false,
+      contextWindow: 1000000,
+      maxOutput: 64000,
+    },
+    "glm-5.3": {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "openai",
+      thinkingCanDisable: true,
+      contextWindow: 1000000,
+      maxOutput: 48000,
+    },
+    "glm-5.3-flash": {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "openai",
+      thinkingCanDisable: true,
+      contextWindow: 1000000,
+      maxOutput: 32000,
+    },
+    "kimi-k3-1": {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "openai",
+      thinkingCanDisable: false,
+      contextWindow: 1000000,
+      maxOutput: 32000,
+    },
+    "deepseek-v4-pro": {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "openai",
+      thinkingCanDisable: true,
+      contextWindow: 1000000,
+      maxOutput: 50000,
+    },
+    // deepseek-v4.1-flash replaces v4-flash (dropped from the server list;
+    // the old endpoint still answers 200 but the published list is the
+    // contract). maxOutput 128000 per the server's product-config payload.
+    "deepseek-v4.1-flash": {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "openai",
+      thinkingCanDisable: true,
+      contextWindow: 1000000,
+      maxOutput: 128000,
+    },
+  },
+  // CodeBuddy intl — same gateway catalog as CN, so deepseek-v4.1-flash mirrors
+  // the codebuddy-cn entry (the openai-style reasoning_effort format matters:
+  // the generic *deepseek-v4* pattern would otherwise pick the vendor-native
+  // "deepseek" thinking shape, which the CodeBuddy gateway does not accept).
+  "codebuddy-intl": {
+    "deepseek-v4.1-flash": {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "openai",
+      thinkingCanDisable: true,
+      contextWindow: 1000000,
+      maxOutput: 128000,
+    },
+  },
+  // Qoder — upstream exposes opaque internal ids (dfmodel, kmodel, …); the
+  // registry `name` is display-only and capability lookup matches on the raw
+  // id, so every qoder model would fall through to DEFAULT_CAPABILITIES
+  // (200K) without this map. contextWindow follows the real model family's
+  // spec: the /algo/api/v2/model/list max_input_tokens under-reports some
+  // windows (GLM-5.3 / Kimi-K3 / Qwen3.8-Max claim 180K but accept more).
+  // max_output_tokens arrives as 0 for every model, so outputs are
+  // best-guess from the real model family. Vision tags below follow the
+  // upstream is_vl flag. The executor uploads inlined images to
+  // /api/v2/image/upload and leaves image_urls/chat_context.imageUrls null
+  // (same as qodercli). reasoning:true on all of them — every model can
+  // reason; the upstream is_reasoning flag only drives model_config selection.
+  // thinkingFormat keeps the true-model family for documentation/UI, but
+  // thinkingCanDisable:false everywhere: the executor only forwards
+  // messages/tools/max_tokens, and thinking is fixed upstream via
+  // modelConfig.is_reasoning — client thinking intent is dropped, so "none"
+  // must never be offered as an option.
+  qoder: {
+    ultimate: {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "claude-adaptive",
+      thinkingCanDisable: false,
+      contextWindow: 1000000,
+      maxOutput: 128000,
+    }, // Claude Opus 5
+    performance: {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "claude-adaptive",
+      thinkingCanDisable: false,
+      contextWindow: 1000000,
+      maxOutput: 128000,
+    }, // Claude Sonnet 5
+    dmodel: {
+      reasoning: true,
+      thinkingFormat: "deepseek",
+      thinkingCanDisable: false,
+      contextWindow: 1000000,
+      maxOutput: 65536,
+    }, // DeepSeek-V4-Pro
+    dfmodel: {
+      reasoning: true,
+      thinkingFormat: "deepseek",
+      thinkingCanDisable: false,
+      contextWindow: 1000000,
+      maxOutput: 65536,
+    }, // DeepSeek-V4-Flash
+    gmodel: {
+      reasoning: true,
+      thinkingFormat: "zai",
+      thinkingCanDisable: false,
+      contextWindow: 1000000,
+      maxOutput: 128000,
+    }, // GLM-5.3
+    gfmodel: {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "zai",
+      thinkingCanDisable: false,
+      contextWindow: 1000000,
+      maxOutput: 128000,
+    }, // GLM-5.3-Flash
+    kmodel_latest: {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "kimi",
+      thinkingCanDisable: false,
+      contextWindow: 1000000,
+      maxOutput: 65536,
+    }, // Kimi-K3
+    kmodel: {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "kimi",
+      thinkingCanDisable: false,
+      contextWindow: 256000,
+      maxOutput: 65536,
+    }, // Kimi-K2.7-Code
+    mmodel: {
+      reasoning: true,
+      thinkingFormat: "minimax",
+      thinkingCanDisable: false,
+      contextWindow: 1000000,
+      maxOutput: 512000,
+    }, // MiniMax-M3
+    qmodel_latest: {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "qwen",
+      thinkingCanDisable: false,
+      contextWindow: 1000000,
+      maxOutput: 65536,
+    }, // Qwen3.7-Max
+    qmodel: {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "qwen",
+      thinkingCanDisable: false,
+      contextWindow: 1000000,
+      maxOutput: 65536,
+    }, // Qwen3.7-Plus
+    qfmodel: {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "qwen",
+      thinkingCanDisable: false,
+      contextWindow: 1000000,
+      maxOutput: 65536,
+    }, // Qwen3.8-Flash
+    qmodel_38max: {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "qwen",
+      thinkingCanDisable: false,
+      contextWindow: 1000000,
+      maxOutput: 65536,
+    }, // Qwen3.8-Max
+  },
+  // Poolside Laguna — OpenAI-compatible, all reasoning-capable (32K max output).
+  poolside: {
+    "laguna-s-2.1": {
+      reasoning: true,
+      thinkingFormat: "openai",
+      contextWindow: 1000000,
+      maxOutput: 32000,
+    },
+    "laguna-xs-2.1": {
+      reasoning: true,
+      thinkingFormat: "openai",
+      contextWindow: 200000,
+      maxOutput: 32000,
+    },
+  },
+  // Ollama Cloud — the generic *deepseek-v4* pattern misses the vision badge
+  // the library page publishes for this model (text+image in, 1M context).
+  // ponytail: thinkingFormat stays "deepseek" to preserve today's body shape;
+  // Ollama's native toggle is the top-level `think` field (bool or
+  // low/medium/high/max), which no format in thinkingUnified.js emits yet —
+  // openai-to-ollama.js drops it. Wire a "think" format when thinking on
+  // Ollama Cloud is actually needed.
+  ollama: {
+    "deepseek-v4.1-flash:cloud": {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "deepseek",
+      contextWindow: 1000000,
+      maxOutput: 384000,
+    },
+  },
+};
+
+/**
+ * Pattern fallback — glob (* = wildcard), matched case-insensitively and
+ * anchored (^...$) so a pattern must match the full model id. ORDER MATTERS:
+ * vision/specific variants first, text-only/generic families last, to avoid
+ * a broad family pattern swallowing an exception (e.g. glm-4.6v vs glm-5).
+ */
+export const PATTERN_CAPABILITIES = [
+  // ── Claude (4.6+ = adaptive thinking; older/haiku = budget) ──────
+  {
+    pattern: "*claude*opus-5*",
+    caps: {
+      vision: true,
+      reasoning: true,
+      search: true,
+      thinkingFormat: "claude-adaptive",
+      contextWindow: 1000000,
+      maxOutput: 128000,
+    },
+  },
+  {
+    pattern: "*claude*opus-4.6*",
+    caps: { vision: true, reasoning: true, search: true, thinkingFormat: "claude-adaptive" },
+  },
+  {
+    pattern: "*claude*opus-4.7*",
+    caps: { vision: true, reasoning: true, search: true, thinkingFormat: "claude-adaptive" },
+  },
+  {
+    pattern: "*claude*opus-4.8*",
+    caps: { vision: true, reasoning: true, search: true, thinkingFormat: "claude-adaptive" },
+  },
+  {
+    pattern: "*claude*sonnet-4.6*",
+    caps: { vision: true, reasoning: true, search: true, thinkingFormat: "claude-adaptive" },
+  },
+  {
+    pattern: "*claude*sonnet-4.7*",
+    caps: { vision: true, reasoning: true, search: true, thinkingFormat: "claude-adaptive" },
+  },
+  {
+    pattern: "*claude*haiku*",
+    caps: { vision: true, reasoning: true, search: true, thinkingFormat: "claude-budget" },
+  },
+  {
+    pattern: "*claude*opus*",
+    caps: { vision: true, reasoning: true, search: true, thinkingFormat: "claude-budget" },
+  },
+  {
+    pattern: "*claude*sonnet*",
+    caps: { vision: true, reasoning: true, search: true, thinkingFormat: "claude-budget" },
+  },
+  {
+    pattern: "*claude*fable*",
+    caps: {
+      vision: true,
+      reasoning: true,
+      search: true,
+      thinkingFormat: "claude-budget",
+      contextWindow: 1000000,
+      maxOutput: 128000,
+    },
+  },
+  {
+    pattern: "*claude*mythos*",
+    caps: {
+      vision: true,
+      reasoning: true,
+      search: true,
+      thinkingFormat: "claude-budget",
+      contextWindow: 1000000,
+      maxOutput: 128000,
+    },
+  },
+  { pattern: "*claude-3*", caps: { vision: true } },
+  {
+    pattern: "*claude*",
+    caps: { vision: true, reasoning: true, search: true, thinkingFormat: "claude-budget" },
+  },
+
+  // ── Gemini (all 2.0+ multimodal + google_search grounding, 1M ctx) ─
+  { pattern: "*gemini*image*", caps: { vision: true, imageOutput: true, contextWindow: 1048576 } },
+  {
+    pattern: "*gemini-3.8*",
+    caps: {
+      vision: true,
+      audioInput: true,
+      videoInput: true,
+      reasoning: true,
+      search: true,
+      thinkingFormat: "gemini-level",
+      thinkingCanDisable: false,
+      contextWindow: 1048576,
+      maxOutput: 65536,
+    },
+  },
+  {
+    pattern: "*gemini-3.7*",
+    caps: {
+      vision: true,
+      audioInput: true,
+      videoInput: true,
+      reasoning: true,
+      search: true,
+      thinkingFormat: "gemini-level",
+      thinkingCanDisable: false,
+      contextWindow: 1048576,
+      maxOutput: 65536,
+    },
+  },
+  {
+    pattern: "*gemini-3*pro*",
+    caps: {
+      vision: true,
+      audioInput: true,
+      videoInput: true,
+      reasoning: true,
+      search: true,
+      thinkingFormat: "gemini-level",
+      thinkingCanDisable: false,
+      contextWindow: 1048576,
+      maxOutput: 65535,
+    },
+  },
+  {
+    pattern: "*gemini-3*",
+    caps: {
+      vision: true,
+      audioInput: true,
+      videoInput: true,
+      reasoning: true,
+      search: true,
+      thinkingFormat: "gemini-level",
+      thinkingCanDisable: false,
+      contextWindow: 1048576,
+      maxOutput: 65536,
+    },
+  },
+  {
+    pattern: "*gemini-2.5*",
+    caps: {
+      vision: true,
+      audioInput: true,
+      videoInput: true,
+      reasoning: true,
+      search: true,
+      thinkingFormat: "gemini-budget",
+      thinkingRange: { min: 0, max: 24576 },
+      contextWindow: 1048576,
+      maxOutput: 65536,
+    },
+  },
+  {
+    pattern: "*gemini-2*",
+    caps: {
+      vision: true,
+      audioInput: true,
+      videoInput: true,
+      search: true,
+      contextWindow: 1048576,
+      maxOutput: 65536,
+    },
+  },
+  { pattern: "*gemini*", caps: { vision: true, search: true, contextWindow: 1048576 } },
+  { pattern: "*gemma*", caps: { vision: true, contextWindow: 128000 } },
+  { pattern: "*nanobanana*", caps: { vision: true, imageOutput: true } },
+
+  // ── OpenAI GPT-6.x (vision + thinking + web search) ──────────────
+  {
+    pattern: "*gpt-6*",
+    caps: {
+      vision: true,
+      reasoning: true,
+      search: true,
+      thinkingFormat: "openai",
+      contextWindow: 272000,
+      maxOutput: 128000,
+    },
+  },
+
+  // ── OpenAI GPT-5.x (vision + thinking + web search) ──────────────
+  { pattern: "*gpt-5*image*", caps: { imageOutput: true } },
+  {
+    pattern: "*gpt-5*codex*",
+    caps: {
+      reasoning: true,
+      search: true,
+      thinkingFormat: "openai",
+      contextWindow: 400000,
+      maxOutput: 128000,
+    },
+  },
+  {
+    pattern: "*gpt-5*",
+    caps: {
+      vision: true,
+      reasoning: true,
+      search: true,
+      thinkingFormat: "openai",
+      contextWindow: 400000,
+      maxOutput: 128000,
+    },
+  },
+  {
+    pattern: "*gpt-4o*",
+    caps: { vision: true, search: true, contextWindow: 128000, maxOutput: 16384 },
+  },
+  { pattern: "*gpt-4.1*", caps: { vision: true, contextWindow: 1000000, maxOutput: 32768 } },
+  { pattern: "*gpt-4-turbo*", caps: { vision: true, contextWindow: 128000 } },
+  { pattern: "*gpt-4*", caps: { contextWindow: 128000 } },
+  { pattern: "*gpt-3.5*", caps: { contextWindow: 16385, maxOutput: 4096 } },
+  {
+    pattern: "*gpt-oss*",
+    caps: { reasoning: true, thinkingFormat: "openai", contextWindow: 128000 },
+  },
+
+  // ── OpenAI o-series (reasoning, vision) ──────────────────────────
+  {
+    pattern: "*o1-mini*",
+    caps: { reasoning: true, thinkingFormat: "openai", contextWindow: 128000 },
+  },
+  {
+    pattern: "*o1*",
+    caps: {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "openai",
+      contextWindow: 200000,
+      maxOutput: 100000,
+    },
+  },
+  {
+    pattern: "*o3*",
+    caps: {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "openai",
+      contextWindow: 200000,
+      maxOutput: 100000,
+    },
+  },
+  {
+    pattern: "*o4*",
+    caps: {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "openai",
+      contextWindow: 200000,
+      maxOutput: 100000,
+    },
+  },
+
+  // ── Grok (vision + Live Search) ──────────────────────────────────
+  { pattern: "*grok*image*", caps: { imageOutput: true } },
+  {
+    pattern: "*grok-code*",
+    caps: { reasoning: true, thinkingFormat: "openai", contextWindow: 256000 },
+  },
+  // Grok 4.6: 500k context, no text output limit (docs.x.ai/developers/grok-4-6)
+  {
+    pattern: "*grok-4.6*",
+    caps: {
+      vision: true,
+      reasoning: true,
+      search: true,
+      thinkingFormat: "openai",
+      contextWindow: 500000,
+      maxOutput: 500000,
+    },
+  },
+  // Grok 4.5 (Grok CLI / Grok Build): 500k context per cli-chat-proxy /v1/models
+  {
+    pattern: "*grok-4.5*",
+    caps: {
+      vision: true,
+      reasoning: true,
+      search: true,
+      thinkingFormat: "openai",
+      contextWindow: 500000,
+      maxOutput: 64000,
+    },
+  },
+  {
+    pattern: "*grok-4*",
+    caps: {
+      vision: true,
+      reasoning: true,
+      search: true,
+      thinkingFormat: "openai",
+      contextWindow: 256000,
+    },
+  },
+  {
+    pattern: "*grok-3*",
+    caps: {
+      vision: true,
+      reasoning: true,
+      search: true,
+      thinkingFormat: "openai",
+      contextWindow: 131072,
+    },
+  },
+  {
+    pattern: "*grok*",
+    caps: {
+      vision: true,
+      reasoning: true,
+      search: true,
+      thinkingFormat: "openai",
+      contextWindow: 256000,
+    },
+  },
+
+  // ── Qwen (3.5+ = native vision/video; coder & max = text-only; QwQ = thinking-only) ─
+  {
+    pattern: "*qwen*vl*",
+    caps: { vision: true, reasoning: true, thinkingFormat: "qwen", contextWindow: 262144 },
+  },
+  {
+    pattern: "*qwen*omni*",
+    caps: {
+      vision: true,
+      audioInput: true,
+      videoInput: true,
+      reasoning: true,
+      thinkingFormat: "qwen",
+      contextWindow: 262144,
+      maxOutput: 65536,
+    },
+  },
+  {
+    pattern: "*qwen*coder*",
+    caps: { reasoning: true, thinkingFormat: "qwen", contextWindow: 1000000 },
+  },
+  {
+    pattern: "*qwen*max*",
+    caps: { reasoning: true, thinkingFormat: "qwen", contextWindow: 1000000, maxOutput: 65536 },
+  },
+  {
+    pattern: "*qwen3.5*",
+    caps: {
+      vision: true,
+      videoInput: true,
+      reasoning: true,
+      thinkingFormat: "qwen",
+      contextWindow: 1000000,
+      maxOutput: 65536,
+    },
+  },
+  {
+    pattern: "*qwen3.6*",
+    caps: {
+      vision: true,
+      videoInput: true,
+      reasoning: true,
+      thinkingFormat: "qwen",
+      contextWindow: 1000000,
+      maxOutput: 65536,
+    },
+  },
+  {
+    pattern: "*qwen3.7*",
+    caps: {
+      vision: true,
+      videoInput: true,
+      reasoning: true,
+      thinkingFormat: "qwen",
+      contextWindow: 1000000,
+      maxOutput: 65536,
+    },
+  },
+  {
+    pattern: "*qwen*plus*",
+    caps: {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "qwen",
+      contextWindow: 1000000,
+      maxOutput: 65536,
+    },
+  },
+  {
+    pattern: "*qwen*235b*",
+    caps: { reasoning: true, thinkingFormat: "qwen", contextWindow: 262144 },
+  },
+  {
+    pattern: "*qwq*",
+    caps: {
+      reasoning: true,
+      thinkingFormat: "qwen",
+      thinkingCanDisable: false,
+      contextWindow: 131072,
+    },
+  },
+  { pattern: "*qwen*", caps: { reasoning: true, thinkingFormat: "qwen", contextWindow: 262144 } },
+
+  // ── Kimi (enabled→reasoning_effort; K2.7-code cannot disable) ─────
+  {
+    pattern: "*kimi*k3*",
+    caps: {
+      vision: true,
+      videoInput: true,
+      reasoning: true,
+      thinkingFormat: "kimi",
+      thinkingCanDisable: false,
+      contextWindow: 1048576,
+      maxOutput: 131072,
+    },
+  },
+  {
+    pattern: "*kimi*for-coding*",
+    caps: {
+      vision: true,
+      videoInput: true,
+      reasoning: true,
+      thinkingFormat: "kimi",
+      thinkingCanDisable: false,
+      contextWindow: 262144,
+      maxOutput: 65536,
+    },
+  },
+  {
+    pattern: "*kimi*k2.7*code*",
+    caps: {
+      vision: true,
+      videoInput: true,
+      reasoning: true,
+      thinkingFormat: "kimi",
+      thinkingCanDisable: false,
+      contextWindow: 262144,
+      maxOutput: 65536,
+    },
+  },
+  {
+    pattern: "*kimi*k2*",
+    caps: {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "kimi",
+      contextWindow: 262144,
+      maxOutput: 262144,
+    },
+  },
+  { pattern: "*kimi*", caps: { reasoning: true, thinkingFormat: "kimi", contextWindow: 262144 } },
+
+  // ── GLM / Z.ai (thinking.enabled; disable via enable_thinking:false) ─
+  // reasoning_effort is only read by z.ai from GLM-5.2 onward (docs.z.ai/guides/capabilities/thinking) —
+  // older GLM (4.x, 5.0, 5.1, 5-turbo, 5v-turbo) ignore it, so gate it per exact version, not the "*glm-5*" catch-all.
+  {
+    pattern: "*glm-5.3*",
+    caps: {
+      reasoning: true,
+      thinkingFormat: "zai",
+      thinkingEffortSupported: true,
+      contextWindow: 200000,
+      maxOutput: 128000,
+    },
+  },
+  {
+    pattern: "*glm-5.2*",
+    caps: {
+      reasoning: true,
+      thinkingFormat: "zai",
+      thinkingEffortSupported: true,
+      contextWindow: 200000,
+      maxOutput: 128000,
+    },
+  },
+  {
+    pattern: "*glm-5*",
+    caps: { reasoning: true, thinkingFormat: "zai", contextWindow: 200000, maxOutput: 128000 },
+  },
+  {
+    pattern: "*glm-4.7*",
+    caps: { reasoning: true, thinkingFormat: "zai", contextWindow: 200000, maxOutput: 128000 },
+  },
+  { pattern: "*glm-4*", caps: { reasoning: true, thinkingFormat: "zai", contextWindow: 200000 } },
+  { pattern: "*glm*", caps: { reasoning: true, thinkingFormat: "zai", contextWindow: 200000 } },
+
+  // ── DeepSeek (thinking.enabled + reasoning_effort; r1 = thinking-only) ─
+  // v4.1+ has real image input (probed live on Alibaba MaaS: correct color
+  // read from a PNG). v4-pro / v4-flash-0731 accept image blocks but ignore
+  // them (answered "Unknown"), so vision stays scoped to v4.* dotted releases.
+  {
+    pattern: "*deepseek-v4.*",
+    caps: {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "deepseek",
+      thinkingEffortSupported: true,
+      contextWindow: 1000000,
+      maxOutput: 128000,
+    },
+  },
+  {
+    pattern: "*deepseek-v4*",
+    caps: {
+      reasoning: true,
+      thinkingFormat: "deepseek",
+      thinkingEffortSupported: true,
+      contextWindow: 1000000,
+      maxOutput: 384000,
+    },
+  },
+  {
+    pattern: "*reasoner*",
+    caps: {
+      reasoning: true,
+      thinkingFormat: "deepseek",
+      thinkingCanDisable: false,
+      contextWindow: 128000,
+    },
+  },
+  {
+    pattern: "*deepseek-r*",
+    caps: {
+      reasoning: true,
+      thinkingFormat: "deepseek",
+      thinkingCanDisable: false,
+      contextWindow: 128000,
+    },
+  },
+  { pattern: "*deepseek-chat*", caps: { contextWindow: 128000 } },
+  {
+    pattern: "*deepseek*",
+    caps: { reasoning: true, thinkingFormat: "deepseek", contextWindow: 128000 },
+  },
+
+  // ── MiniMax (M3 = adaptive; M2.x cannot disable) ─────────────────
+  { pattern: "*minimax*image*", caps: { imageOutput: true } },
+  {
+    pattern: "*minimax-m3*",
+    caps: {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "minimax",
+      contextWindow: 1048576,
+      maxOutput: 512000,
+    },
+  },
+  {
+    pattern: "*minimax-m2.7*",
+    caps: {
+      reasoning: true,
+      thinkingFormat: "minimax",
+      thinkingCanDisable: false,
+      contextWindow: 204800,
+      maxOutput: 131072,
+    },
+  },
+  {
+    pattern: "*minimax*",
+    caps: {
+      reasoning: true,
+      thinkingFormat: "minimax",
+      thinkingCanDisable: false,
+      contextWindow: 200000,
+      maxOutput: 131072,
+    },
+  },
+
+  // ── Xiaomi MiMo (vision, 1M / 262K ctx) ──────────────────────────
+  {
+    pattern: "*mimo*v2.5*",
+    caps: {
+      vision: true,
+      audioInput: true,
+      videoInput: true,
+      contextWindow: 1048576,
+      maxOutput: 131072,
+    },
+  },
+  {
+    pattern: "*mimo*omni*",
+    caps: { vision: true, audioInput: true, contextWindow: 262144, maxOutput: 131072 },
+  },
+  { pattern: "*mimo*", caps: { vision: true, contextWindow: 262144, maxOutput: 131072 } },
+
+  // ── Llama (4 = vision/1M; 3.x = text-only/128K) ──────────────────
+  { pattern: "*llama-4*", caps: { vision: true, contextWindow: 1000000 } },
+  { pattern: "*llama*", caps: { contextWindow: 128000 } },
+
+  // ── Mistral (Large 3 = vision/256K; codestral text) ──────────────
+  { pattern: "*codestral*", caps: { contextWindow: 256000 } },
+  { pattern: "*mistral-large*", caps: { vision: true, contextWindow: 256000 } },
+  { pattern: "*mistral*", caps: { contextWindow: 128000 } },
+
+  // ── Cohere (Command A Vision = vision; others text) ──────────────
+  { pattern: "*command-a-vision*", caps: { vision: true, contextWindow: 128000 } },
+  { pattern: "*command*", caps: { contextWindow: 128000 } },
+
+  // ── Perplexity (web search native) ───────────────────────────────
+  { pattern: "*sonar*", caps: { search: true, contextWindow: 128000 } },
+  { pattern: "*pplx*", caps: { search: true, contextWindow: 128000 } },
+  { pattern: "*perplexity*", caps: { search: true, contextWindow: 128000 } },
+
+  // ── Poolside Laguna (resellers: openrouter/nvidia/kilocode/vercel/...) ──
+  // Free tiers cap S 2.1 well below the paid 1M window → match the free suffix
+  // (":free" or "-free", depending on reseller) before the plain id.
+  {
+    pattern: "*laguna-s-2.1*free*",
+    caps: { reasoning: true, thinkingFormat: "openai", contextWindow: 200000, maxOutput: 32000 },
+  },
+  {
+    pattern: "*laguna-s-2.1*",
+    caps: { reasoning: true, thinkingFormat: "openai", contextWindow: 1000000, maxOutput: 32000 },
+  },
+  {
+    pattern: "*laguna*",
+    caps: { reasoning: true, thinkingFormat: "openai", contextWindow: 200000, maxOutput: 32000 },
+  },
+
+  // ── OpenCode Free Muse Spark (multimodal text+image; OpenAI Responses reasoning supports up to xhigh) ─
+  {
+    pattern: "*muse*spark*",
+    caps: {
+      vision: true,
+      reasoning: true,
+      thinkingFormat: "openai",
+      contextWindow: 1048576,
+      maxOutput: 131072,
+    },
+  },
+  // ── Others ───────────────────────────────────────────────────────
+  {
+    pattern: "*hunyuan*",
+    caps: { reasoning: true, thinkingFormat: "hunyuan", contextWindow: 262144, maxOutput: 262144 },
+  },
+  {
+    pattern: "hy3*",
+    caps: { reasoning: true, thinkingFormat: "hunyuan", contextWindow: 262144, maxOutput: 262144 },
+  },
+  { pattern: "*step-*", caps: { reasoning: true, thinkingFormat: "step", contextWindow: 128000 } },
+  { pattern: "*nemotron*", caps: { reasoning: true, contextWindow: 128000 } },
+  { pattern: "*ling-*", caps: { reasoning: true, contextWindow: 128000 } },
+];
+
+/**
+ * Resolve capabilities for a model using the 4-step fallback chain,
+ * merged over DEFAULT_CAPABILITIES so the result is always complete.
+ *
+ * @param {string} provider
+ * @param {string} model
+ * @returns {object} full capabilities object
+ */
+const MODALITY_KEYS = ["vision", "pdf", "audioInput", "videoInput"];
+
+// Catalog lookups, installed by the server at startup. Left as no-ops in the
+// browser bundle, where there is no file to read.
+//
+// The server bundles this module into every route chunk that needs it, and each
+// copy carries its own module state, so an install landing in the copy the
+// startup hook imported stays invisible to the copy resolving requests. The slot
+// lives on globalThis instead; the local binding is the fast path.
+let catalogSource = null;
+
+/**
+ * Install the synced catalog reader (server only).
+ * @param {{ getModalities: (provider: string, model: string) => object|null,
+ *           getLimits: (provider: string, model: string) => object|null } | null} source
+ */
+export function setCatalogSource(source) {
+  catalogSource = source;
+  if (typeof globalThis !== "undefined") globalThis.__9rCatalogSource = source;
+}
+
+function getCatalogSource() {
+  if (catalogSource) return catalogSource;
+  if (typeof globalThis === "undefined") return null;
+  return (catalogSource = globalThis.__9rCatalogSource || null);
+}
+
+// Apply the synced catalog + name heuristic on top of a table-resolved result.
+// Strictly additive: a capability already true stays true, and a false one only
+// flips when an outside source positively declares support.
+function refine(base, provider, model) {
+  const result = { ...DEFAULT_CAPABILITIES, ...base };
+
+  const source = getCatalogSource();
+  if (source) {
+    const modalities = source.getModalities(provider, model);
+    if (modalities) {
+      for (const key of MODALITY_KEYS) {
+        if (modalities[key] === true) result[key] = true;
+      }
+    }
+
+    const limits = source.getLimits(provider, model);
+    if (limits) {
+      if (limits.contextWindow > 0) result.contextWindow = limits.contextWindow;
+      if (limits.maxOutput > 0) result.maxOutput = limits.maxOutput;
+    }
+  }
+
+  if (!result.vision && looksLikeVisionModel(model)) result.vision = true;
+
+  return result;
+}
+
+// Mirrors Command Code CLI `isKnownTextOnlyModel` (no image input). New models
+// default to vision; only this denylist stays text-only.
+const COMMANDCODE_TEXT_ONLY = new Set([
+  "deepseek/deepseek-v4-pro",
+  "deepseek/deepseek-v4-flash",
+  "deepseek/deepseek-v4-flash-fast",
+  "zai-org/glm-5.3",
+  "zai-org/glm-5.2",
+  "zai-org/glm-5.2-fast",
+  "zai-org/glm-5.1",
+  "zai-org/glm-5",
+  "minimaxai/minimax-m2.7",
+  "minimax/minimax-m2.7-free",
+  "minimaxai/minimax-m2.5",
+  "xiaomi/mimo-v2.5-pro",
+  "qwen/qwen3.6-max-preview",
+  "qwen/qwen3.7-max",
+  "meituan/longcat-2.0:free",
+  "stepfun/step-3.5-flash",
+  "tencent/hy4-preview",
+  "tencent/hy3",
+  "tencent/hy3-paid",
+  "nvidia/nemotron-3-ultra-550b-a55b",
+  "poolside/laguna-s-2.1-free",
+  "inclusionai/ling-3.0-flash-free",
+  "inclusionai/ling-3.0-flash-sante:free",
+]);
+
+function isCommandCodeTextOnly(model) {
+  const key = String(model || "").toLowerCase();
+  if (COMMANDCODE_TEXT_ONLY.has(key)) return true;
+  for (const id of COMMANDCODE_TEXT_ONLY) {
+    const base = id.includes("/") ? id.slice(id.lastIndexOf("/") + 1) : id;
+    if (key === base || key.endsWith("/" + base)) return true;
+  }
+  return false;
+}
+export function getCapabilitiesForModel(provider, model) {
+  if (!model) return { ...DEFAULT_CAPABILITIES };
+
+  // Canonical exact lookup strips vendor prefix: "anthropic/claude-opus-4.7" -> "claude-opus-4.7".
+  const baseModel = model.includes("/") ? model.split("/").pop() : model;
+
+  // CommandCode wire is /alpha/generate for every model. Family patterns
+  // (deepseek-v4 → thinkingFormat:deepseek, vision:false) must not win here.
+  if (provider === "commandcode" || provider === "cmc") {
+    const providerCaps = PROVIDER_CAPABILITIES.commandcode;
+    if (providerCaps?.[model]) return { ...DEFAULT_CAPABILITIES, ...providerCaps[model] };
+    if (providerCaps?.[baseModel]) return { ...DEFAULT_CAPABILITIES, ...providerCaps[baseModel] };
+    return {
+      ...DEFAULT_CAPABILITIES,
+      reasoning: true,
+      thinkingFormat: "commandcode",
+      thinkingEffortSupported: true,
+      vision: !isCommandCodeTextOnly(model),
+      contextWindow: 1000000,
+      maxOutput: 384000,
+    };
+  }
+
+  // 1. Provider-specific override
+  if (provider) {
+    const providerCaps = PROVIDER_CAPABILITIES[provider];
+    if (providerCaps?.[model]) return { ...DEFAULT_CAPABILITIES, ...providerCaps[model] };
+    if (providerCaps?.[baseModel]) return { ...DEFAULT_CAPABILITIES, ...providerCaps[baseModel] };
+  }
+
+  // 2. Canonical exact
+  if (MODEL_CAPABILITIES[baseModel])
+    return { ...DEFAULT_CAPABILITIES, ...MODEL_CAPABILITIES[baseModel] };
+  if (MODEL_CAPABILITIES[model]) return { ...DEFAULT_CAPABILITIES, ...MODEL_CAPABILITIES[model] };
+
+  // 3. Pattern match (first match wins), refined by catalog + name heuristic
+  for (const { pattern, caps } of PATTERN_CAPABILITIES) {
+    if (matchPattern(pattern, baseModel) || matchPattern(pattern, model)) {
+      return refine(caps, provider, model);
+    }
+  }
+
+  // 4. Floor
+  return refine(null, provider, model);
+}