Release v1.2.0 enrich model capabilities via models.dev

* feat: enrich model capabilities via models.dev and fix provider alias resolution

- Add env var fallback for API key in config hook (OMNIROUTE_API_KEY)
- Generate modelMetadata from enriched models so OpenCode applies capabilities
- Add top-level capability fields (temperature, reasoning, attachment, tool_call, modalities) to provider model output
- Generate reasoning effort variants (low/medium/high) for reasoning models
- Add provider aliases: glmt/glm→zai-coding-plan, kimi-coding/kmc→moonshotai, gh/github→google
- Add subscription fallback: zai-coding-plan→zai, kimi-for-coding→moonshotai
- Add model aliases for naming mismatches (kimi-k2.6-thinking→kimi-k2-thinking)
- Strip reasoning effort variant suffixes (gpt-5.5-xhigh→gpt-5.5) for lookup
- Close 19 of 132 models with 4096 default context limits

* fix: address model metadata review feedback

Preserve user modelMetadata while merging generated capabilities, propagate new capability fields through models.dev and combo paths, and consolidate alias resolution.

* fix: preserve combo attachment metadata

Treat missing attachment capability as unknown instead of false when folding combo model capabilities, while still honoring explicit false values.

* fix: respect explicit attachment false

Avoid falling back to vision support when models.dev or combo metadata explicitly marks attachments unsupported.

* fix: address code review issues from PR #18

- Fix temperature AND-chain bug in calculateLowestCommonCapabilities by tracking hasTemperatureMetadata
- Fix reasoning AND-chain bug in calculateLowestCommonCapabilities by tracking hasReasoningMetadata
- Respect explicit supportsAttachment=false for vision models in toProviderModel
- Add normalized key candidates to getModelLookupCandidates for better alias/variant matching

Addresses feedback from Copilot, Gemini Code Assist, and Kilo Code Bot reviews.

* fix: use nullish coalescing for API key fallback

* fix: add runtime validation for modelMetadata merge

* fix: improve modelMetadata validation coverage

* fix: include modelsDev config in cache key

* refactor: extract splitModelId to eliminate DRY violation

---------

Co-authored-by: Sebastian Rumpf <alp4d0g007@googlemail.com>

Author: abien

docs/superpowers/plans/2026-05-16-pr18-review-fixes.md

@@ -246,6 +246,18 @@ export function modelsDevToMetadata(model: ModelsDevModel): OmniRouteModelMetada
     metadata.maxTokens = model.limit.output;
   }
 
+  if (model.temperature !== undefined) {
+    metadata.supportsTemperature = model.temperature;
+  }
+
+  if (model.reasoning !== undefined) {
+    metadata.supportsReasoning = model.reasoning;
+  }
+
+  if (model.attachment !== undefined) {
+    metadata.supportsAttachment = model.attachment;
+  }
+
   // Derive vision support from modalities
   if (model.modalities?.input?.includes('image')) {
     metadata.supportsVision = true;
@@ -256,8 +268,6 @@ export function modelsDevToMetadata(model: ModelsDevModel): OmniRouteModelMetada
     metadata.supportsTools = true;
   }
 
-
-
   // Pricing
   if (model.cost?.input !== undefined || model.cost?.output !== undefined) {
     metadata.pricing = {};
@@ -292,6 +302,12 @@ export function calculateLowestCommonCapabilities(
   let minMaxTokens: number | undefined;
   let allSupportVision = true;
   let allSupportTools = true;
+  let allSupportTemperature = true;
+  let hasTemperatureMetadata = false;
+  let allSupportReasoning = true;
+  let hasReasoningMetadata = false;
+  let allSupportAttachment = true;
+  let hasAttachmentMetadata = false;
   let allSupportStreaming = true;
 
   for (const model of models) {
@@ -314,6 +330,21 @@ export function calculateLowestCommonCapabilities(
     // Tools: all must support it
     const supportsTools = model.tool_call === true;
     allSupportTools = allSupportTools && supportsTools;
+
+    if (model.temperature !== undefined) {
+      hasTemperatureMetadata = true;
+      allSupportTemperature = allSupportTemperature && model.temperature;
+    }
+
+    if (model.reasoning !== undefined) {
+      hasReasoningMetadata = true;
+      allSupportReasoning = allSupportReasoning && model.reasoning;
+    }
+
+    if (model.attachment !== undefined) {
+      hasAttachmentMetadata = true;
+      allSupportAttachment = allSupportAttachment && model.attachment;
+    }
   }
 
   const result: OmniRouteModelMetadata = {};
@@ -334,6 +365,24 @@ export function calculateLowestCommonCapabilities(
     result.supportsTools = true;
   }
 
+  if (hasTemperatureMetadata && allSupportTemperature) {
+    result.supportsTemperature = true;
+  } else if (hasTemperatureMetadata) {
+    result.supportsTemperature = false;
+  }
+
+  if (hasReasoningMetadata && allSupportReasoning) {
+    result.supportsReasoning = true;
+  } else if (hasReasoningMetadata) {
+    result.supportsReasoning = false;
+  }
+
+  if (hasAttachmentMetadata && allSupportAttachment) {
+    result.supportsAttachment = true;
+  } else if (hasAttachmentMetadata) {
+    result.supportsAttachment = false;
+  }
+
   // Streaming is generally supported by all modern models
   if (allSupportStreaming) {
     result.supportsStreaming = true;
@@ -343,6 +392,31 @@ export function calculateLowestCommonCapabilities(
 }
 
 
+/**
+ * Subscription → public provider fallback map.
+ * When a subscription provider (e.g. zai-coding-plan) lacks a model,
+ * try its public counterpart (e.g. zai) before giving up.
+ */
+export const SUBSCRIPTION_FALLBACKS: Record<string, string> = {
+  'zai-coding-plan': 'zai',
+  'kimi-for-coding': 'moonshotai',
+  'github-models': 'google',
+};
+
+/**
+ * Known model ID mismatches between OmniRoute and models.dev.
+ * Maps OmniRoute model names to their models.dev equivalents.
+ */
+export const MODEL_ALIASES: Record<string, string> = {
+  'kimi-k2.6-thinking': 'kimi-k2-thinking',
+  'kimi-k2.6-thinking-turbo': 'kimi-k2-thinking-turbo',
+};
+
+export function resolveModelAlias(modelKey: string): string {
+  const lower = modelKey.toLowerCase();
+  return MODEL_ALIASES[lower] ?? MODEL_ALIASES[normalizeModelKey(lower)] ?? modelKey;
+}
+
 /**
  * Resolve provider alias using config and defaults
  */
@@ -372,8 +446,35 @@ export function resolveProviderAlias(
     openrouter: 'openrouter',
     perplexity: 'perplexity',
     cohere: 'cohere',
+    glmt: 'zai-coding-plan',
+    glm: 'zai-coding-plan',
+    'kimi-coding': 'moonshotai',
+    kmc: 'moonshotai',
+    gh: 'google',
+    github: 'google',
     ...config?.modelsDev?.providerAliases,
   };
 
   return aliases[lower] ?? lower;
-}
+}
+
+/**
+ * Get the public fallback provider for a subscription provider.
+ * Returns null if no fallback exists.
+ */
+export function getSubscriptionFallback(provider: string): string | null {
+  return SUBSCRIPTION_FALLBACKS[provider.toLowerCase()] ?? null;
+}
+
+/**
+ * Strip reasoning effort variant suffix from a model name.
+ * Returns the base model name and true if a suffix was stripped.
+ */
+export function stripVariantSuffix(modelKey: string): { base: string; stripped: boolean } {
+  const variantPattern = /-(low|medium|high|xhigh)$/i;
+  const match = modelKey.match(variantPattern);
+  if (match) {
+    return { base: modelKey.slice(0, match.index), stripped: true };
+  }
+  return { base: modelKey, stripped: false };
+}

src/models-dev.ts

@@ -1,13 +1,20 @@
-import type { OmniRouteConfig, OmniRouteModel, OmniRouteModelMetadata, OmniRouteModelsResponse } from './types.js';
+import type { OmniRouteConfig, OmniRouteModel, OmniRouteModelsResponse } from './types.js';
 import {
   OMNIROUTE_DEFAULT_MODELS,
   OMNIROUTE_ENDPOINTS,
   MODEL_CACHE_TTL,
   REQUEST_TIMEOUT,
 } from './constants.js';
-import { getModelsDevIndex, normalizeModelKey } from './models-dev.js';
-import type { ModelsDevIndex } from './models-dev.js';
-import { enrichComboModels, clearComboCache } from './omniroute-combos.js';
+import {
+  getModelsDevIndex,
+  normalizeModelKey,
+  getSubscriptionFallback,
+  stripVariantSuffix,
+  resolveProviderAlias,
+  resolveModelAlias,
+} from './models-dev.js';
+import type { ModelsDevIndex, ModelsDevModel } from './models-dev.js';
+import { enrichComboModels, clearComboCache, splitModelId } from './omniroute-combos.js';
 import { warn, debug } from './logger.js';
 
 /**
@@ -28,7 +35,17 @@ const modelCache = new Map<string, ModelCache>();
  */
 function getCacheKey(config: OmniRouteConfig, apiKey: string): string {
   const baseUrl = config.baseUrl || OMNIROUTE_ENDPOINTS.BASE_URL;
-  return `${baseUrl}:${apiKey}`;
+
+  // Include modelsDev config in cache key to prevent stale data
+  const modelsDevHash = config.modelsDev
+    ? JSON.stringify({
+        enabled: config.modelsDev.enabled,
+        url: config.modelsDev.url,
+        providerAliases: config.modelsDev.providerAliases,
+      })
+    : '';
+
+  return `${baseUrl}:${apiKey}:${modelsDevHash}`;
 }
 
 /**
@@ -116,6 +133,9 @@ export async function fetchModels(
         supportsStreaming: model.supportsStreaming,
         supportsVision: model.supportsVision,
         supportsTools: model.supportsTools,
+        supportsTemperature: model.supportsTemperature,
+        supportsReasoning: model.supportsReasoning,
+        supportsAttachment: model.supportsAttachment,
       }));
 
     // Enrich with models.dev and combo capabilities
@@ -234,32 +254,17 @@ function applyModelsDevMetadata(
   config: OmniRouteConfig,
   index: ModelsDevIndex,
 ): OmniRouteModel {
-  const { providerKey, modelKey } = splitOmniRouteModelForLookup(model.id);
+  const { providerKey, modelKey } = splitModelId(model.id);
   const providerAlias = resolveProviderAlias(providerKey, config);
-  const lookupKey = modelKey.toLowerCase();
-  const normalizedKey = normalizeModelKey(modelKey);
-
-  // Try provider-specific exact match first
-  const providerExact = providerAlias
-    ? index.exactByProvider.get(providerAlias)?.get(lookupKey)
-    : undefined;
-
-  // Try provider-specific normalized match
-  const providerNorm = providerAlias
-    ? index.normalizedByProvider.get(providerAlias)?.get(normalizedKey)
-    : undefined;
-
-  // Try global exact match (only if single match to avoid ambiguity)
-  const globalExactList = index.exactGlobal.get(lookupKey);
-  const globalExact = globalExactList?.length === 1 ? globalExactList[0] : undefined;
-
-  // Try global normalized match (only if single match to avoid ambiguity)
-  const globalNormList = index.normalizedGlobal.get(normalizedKey);
-  const globalNorm = globalNormList?.length === 1 ? globalNormList[0] : undefined;
-
-  // Pick the best match (provider-specific preferred over global)
-  const best = providerExact ?? providerNorm ?? globalExact ?? globalNorm;
-
+  const candidates = getModelLookupCandidates(modelKey);
+  const providerCandidates = [
+    ...(providerAlias ? [providerAlias] : []),
+    ...(providerAlias
+      ? [getSubscriptionFallback(providerAlias)].filter((p): p is string => p !== null)
+      : []),
+  ];
+
+  const best = lookupModelsDevModel(index, providerCandidates, candidates);
   if (!best) return model;
 
   // Merge capabilities (only fill in missing values)
@@ -278,66 +283,65 @@ function applyModelsDevMetadata(
       ? { supportsTools: true }
       : {}),
     ...(model.supportsStreaming === undefined
-      ? { supportsStreaming: true } // Assume streaming is supported by default
+      ? { supportsStreaming: true }
+      : {}),
+    ...(model.supportsTemperature === undefined && best.temperature !== undefined
+      ? { supportsTemperature: best.temperature }
+      : {}),
+    ...(model.supportsReasoning === undefined && best.reasoning !== undefined
+      ? { supportsReasoning: best.reasoning }
+      : {}),
+    ...(model.supportsAttachment === undefined && best.attachment !== undefined
+      ? { supportsAttachment: best.attachment }
       : {}),
   };
 }
 
-/**
- * Split model ID for models.dev lookup
- */
-function splitOmniRouteModelForLookup(
-  modelId: string,
-): { providerKey: string | null; modelKey: string } {
-  const trimmed = modelId.trim();
-
-  // Remove omniroute prefix if present
-  const withoutPrefix = trimmed.replace(/^omniroute\//, '');
-
-  // Split by /
-  const parts = withoutPrefix.split('/').filter((p) => p.trim() !== '');
-
-  if (parts.length >= 2) {
-    return {
-      providerKey: parts[0] ?? null,
-      modelKey: parts.slice(1).join('/'),
-    };
+function getModelLookupCandidates(modelKey: string): string[] {
+  const candidates = new Set<string>();
+  const addCandidate = (key: string): void => {
+    candidates.add(key.toLowerCase());
+    candidates.add(resolveModelAlias(key).toLowerCase());
+    candidates.add(normalizeModelKey(key));
+    candidates.add(normalizeModelKey(resolveModelAlias(key)));
+  };
+
+  addCandidate(modelKey);
+
+  const { base, stripped } = stripVariantSuffix(modelKey);
+  if (stripped) {
+    addCandidate(base);
   }
 
-  return { providerKey: null, modelKey: withoutPrefix };
+  return [...candidates];
 }
 
-/**
- * Resolve provider alias using config
- */
-function resolveProviderAlias(
-  providerKey: string | null,
-  config: OmniRouteConfig,
-): string | null {
-  if (!providerKey) return null;
-
-  const lower = providerKey.toLowerCase();
-
-  // Default aliases
-  const aliases: Record<string, string> = {
-    oai: 'openai',
-    openai: 'openai',
-    cx: 'openai',
-    codex: 'openai',
-    anthropic: 'anthropic',
-    claude: 'anthropic',
-    gemini: 'google',
-    google: 'google',
-    deepseek: 'deepseek',
-    mistral: 'mistral',
-    xai: 'xai',
-    groq: 'groq',
-    together: 'together',
-    openrouter: 'openrouter',
-    perplexity: 'perplexity',
-    cohere: 'cohere',
-    ...config.modelsDev?.providerAliases,
-  };
+function lookupModelsDevModel(
+  index: ModelsDevIndex,
+  providerCandidates: string[],
+  modelCandidates: string[],
+): ModelsDevModel | undefined {
+  for (const provider of providerCandidates) {
+    for (const candidate of modelCandidates) {
+      const exact = index.exactByProvider.get(provider)?.get(candidate);
+      if (exact) return exact;
+
+      const normalized = index.normalizedByProvider
+        .get(provider)
+        ?.get(normalizeModelKey(candidate));
+      if (normalized) return normalized;
+    }
+  }
 
-  return aliases[lower] ?? lower;
+  for (const candidate of modelCandidates) {
+    const exactList = index.exactGlobal.get(candidate);
+    if (exactList?.length === 1) return exactList[0];
+
+    const normalizedList = index.normalizedGlobal.get(normalizeModelKey(candidate));
+    if (normalizedList?.length === 1) return normalizedList[0];
+  }
+
+  return undefined;
 }
+
+

src/models.ts

@@ -224,7 +224,7 @@ export function lookupModelInIndex(
  * Split a model ID into provider and model key
  * Handles formats like "provider/model", "omniroute/provider/model", etc.
  */
-function splitModelId(modelId: string): { providerKey: string | null; modelKey: string } {
+export function splitModelId(modelId: string): { providerKey: string | null; modelKey: string } {
   const trimmed = modelId.trim();
 
   // Remove omniroute prefix if present
@@ -366,6 +366,15 @@ export async function enrichComboModels(
         ...(capabilities.maxTokens !== undefined ? { maxTokens: capabilities.maxTokens } : {}),
         ...(capabilities.supportsVision !== undefined ? { supportsVision: capabilities.supportsVision } : {}),
         ...(capabilities.supportsTools !== undefined ? { supportsTools: capabilities.supportsTools } : {}),
+        ...(capabilities.supportsTemperature !== undefined
+          ? { supportsTemperature: capabilities.supportsTemperature }
+          : {}),
+        ...(capabilities.supportsReasoning !== undefined
+          ? { supportsReasoning: capabilities.supportsReasoning }
+          : {}),
+        ...(capabilities.supportsAttachment !== undefined
+          ? { supportsAttachment: capabilities.supportsAttachment }
+          : {}),
         ...(capabilities.supportsStreaming !== undefined ? { supportsStreaming: capabilities.supportsStreaming } : {}),
         ...(capabilities.pricing !== undefined ? { pricing: { ...model.pricing, ...capabilities.pricing } } : {}),
       };