feat: normalize OmniRoute model metadata and deduplicate alias entries

src/constants.ts

@@ -73,9 +73,27 @@ export const MODEL_CACHE_TTL = 5 * 60 * 1000;
  */
 export const REQUEST_TIMEOUT = 30000;
 
+/**
+ * Default model limits
+ */
+export const DEFAULT_CONTEXT_LIMIT = 4096;
+export const DEFAULT_OUTPUT_LIMIT = 4096;
+
 /**
  * models.dev enrichment defaults
  */
 export const MODELS_DEV_DEFAULT_URL = 'https://models.dev/api.json';
 export const MODELS_DEV_CACHE_TTL = 24 * 60 * 60 * 1000;
 export const MODELS_DEV_TIMEOUT_MS = 1000;
+
+/**
+ * Provider alias-to-canonical mapping for deduplication
+ */
+export const PROVIDER_ALIAS_TO_CANONICAL: Record<string, string> = {
+  ollamacloud: 'ollama-cloud',
+  cc: 'claude',
+  gh: 'github',
+  cx: 'codex',
+  kr: 'kiro',
+  if: 'qoder',
+};

src/logger.ts

@@ -1,4 +1,5 @@
-import { appendFileSync, readdirSync, statSync, existsSync } from 'fs';
+import { readdirSync, statSync, existsSync } from 'fs';
+import { appendFile } from 'fs/promises';
 import { join } from 'path';
 import { homedir } from 'os';
 
@@ -32,62 +33,34 @@ function findCurrentLogFile(): string | null {
 let cachedLogFile: string | null = findCurrentLogFile();
 
 function getLogFile(): string | null {
-  if (cachedLogFile === null) {
-    // Re-scan if no file found at module load (OpenCode may create one later)
+  if (cachedLogFile === null || !existsSync(cachedLogFile)) {
+    // Re-scan if no file found at module load or if cached file was deleted (log rotation)
     cachedLogFile = findCurrentLogFile();
   }
   return cachedLogFile;
 }
 
-function isNodeError(error: unknown): error is NodeJS.ErrnoException {
-  return (
-    typeof error === 'object' &&
-    error !== null &&
-    'code' in error &&
-    typeof (error as NodeJS.ErrnoException).code === 'string'
-  );
-}
-
-function writeLog(level: string, message: string): void {
-  let logFile = getLogFile();
-  if (!logFile) return;
-
-  // Check if cached file still exists (handles log rotation)
-  if (!existsSync(logFile)) {
-    cachedLogFile = findCurrentLogFile();
-    logFile = cachedLogFile;
-    if (!logFile) return;
-  }
-
+function formatLogLine(level: string, message: string): string {
   const timestamp = new Date().toISOString();
-  const line = `${level.padEnd(5)} ${timestamp} +0ms service=omniroute ${message}\n`;
-
-  try {
-    appendFileSync(logFile, line);
-  } catch (error: unknown) {
-    if (isNodeError(error) && error.code === 'ENOENT') {
-      // Log file was deleted, re-scan
-      cachedLogFile = findCurrentLogFile();
-      // Retry once with new file
-      const newLogFile = cachedLogFile;
-      if (newLogFile) {
-        try {
-          appendFileSync(newLogFile, line);
-        } catch {
-          // Silently fail on second attempt
-        }
-      }
-    }
-    // Silently fail for all other errors
-  }
+  return `${level.padEnd(5)} ${timestamp} +0ms service=omniroute ${message}\n`;
 }
 
 export function warn(message: string): void {
-  writeLog('WARN', message);
+  const logFile = getLogFile();
+  if (!logFile) return;
+
+  const line = formatLogLine('WARN', message);
+  // Fire-and-forget: don't await, don't crash on error
+  appendFile(logFile, line).catch(() => {});
 }
 
 export function debug(message: string): void {
   // Strict comparison: only "1" enables debug logging
   if (process.env.OMNIROUTE_DEBUG !== '1') return;
-  writeLog('DEBUG', message);
+
+  const logFile = getLogFile();
+  if (!logFile) return;
+
+  const line = formatLogLine('DEBUG', message);
+  appendFile(logFile, line).catch(() => {});
 }

src/models-dev.ts

@@ -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) {
@@ -312,8 +328,26 @@ export function calculateLowestCommonCapabilities(
     allSupportVision = allSupportVision && supportsVision;
 
     // Tools: all must support it
+    // For combos: only advertise tools if ALL underlying models explicitly support them
+    // This is intentionally stricter than single-model defaults because a combo
+    // with one tool-less model cannot reliably use tools across all backends
     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 +368,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 +395,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 +449,36 @@ 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 };
+}
+