converse-mcp-server 1.5.4 → 1.6.0

package/README.md

@@ -67,6 +67,8 @@ MAX_MCP_OUTPUT_TOKENS=200000
 # Optional: Provider-specific settings
 XAI_BASE_URL=https://api.x.ai/v1
 OPENROUTER_REFERER=https://github.com/FallDownTheSystem/converse
+OPENROUTER_TITLE=YourAppName
+OPENROUTER_DYNAMIC_MODELS=true
 ```
 
 ### 2. Get API Keys
@@ -102,6 +104,8 @@ There are several ways to add the Converse MCP Server to Claude:
         "DEEPSEEK_API_KEY": "your_key_here",
         "OPENROUTER_API_KEY": "your_key_here",
         "OPENROUTER_REFERER": "https://github.com/YourUsername/YourApp",
+        "OPENROUTER_DYNAMIC_MODELS": "true",
+        "OPENROUTER_TITLE": "YourAppName",
         "MAX_MCP_OUTPUT_TOKENS": "200000"
       }
     }
@@ -128,6 +132,8 @@ There are several ways to add the Converse MCP Server to Claude:
         "DEEPSEEK_API_KEY": "your_key_here",
         "OPENROUTER_API_KEY": "your_key_here",
         "OPENROUTER_REFERER": "https://github.com/YourUsername/YourApp",
+        "OPENROUTER_DYNAMIC_MODELS": "true",
+        "OPENROUTER_TITLE": "YourAppName",
         "MAX_MCP_OUTPUT_TOKENS": "200000"
       }
     }
@@ -197,13 +203,15 @@ For more detailed instructions, see the [official MCP configuration guide](https
 
 ### 1. Chat Tool
 
-General conversational AI with context and continuation support.
+General conversational AI with context and continuation support. Supports automatic model routing - simple names route by keyword, slash format (e.g., `anthropic/claude-3.5-sonnet`) checks native providers first before routing to OpenRouter.
 
 ```javascript
 // Example usage
 {
   "prompt": "How should I structure the authentication module for this Express.js API?",
-  "model": "gemini-2.5-flash",
+  "model": "gemini-2.5-flash",         // Routes to Google
+  // "model": "anthropic/claude-3.5-sonnet", // Routes to OpenRouter (if enabled)
+  // "model": "openrouter/auto",          // Auto-select best model
   "files": ["/path/to/src/auth.js", "/path/to/config.json"],
   "images": ["/path/to/architecture.png"],
   "temperature": 0.5,

package/docs/PROVIDERS.md

@@ -67,12 +67,20 @@ This guide documents all supported AI providers in the Converse MCP Server and t
 - **Environment Variables**: 
   - `OPENROUTER_API_KEY` - Your API key
   - `OPENROUTER_REFERER` - Required referer URL (e.g., your GitHub repo)
-- **Supported Models**: Access to multiple providers through unified API
+  - `OPENROUTER_TITLE` - Optional title for request tracking
+  - `OPENROUTER_DYNAMIC_MODELS` - Enable dynamic model discovery (default: false)
+- **Static Models**: Pre-configured models available without dynamic discovery
+  - `qwen/qwen3-235b-a22b-thinking-2507` - Qwen3 235B with thinking capabilities
+  - `qwen/qwen3-coder` - Qwen3 specialized for coding
+  - `moonshotai/kimi-k2` - Kimi K2 with 200K context window
+  - `openrouter/auto` - Auto-selects best model using NotDiamond routing
+- **Dynamic Models**: When `OPENROUTER_DYNAMIC_MODELS=true`, any model in `provider/model` format
   - `anthropic/claude-3.5-sonnet`
   - `openai/gpt-4-turbo`
   - `google/gemini-pro`
   - `mistralai/mistral-large`
   - `meta-llama/llama-3.1-405b-instruct`
+  - And many more - see [openrouter.ai/models](https://openrouter.ai/models)
 
 ## Configuration Examples
 
@@ -87,6 +95,10 @@ DEEPSEEK_API_KEY=your_deepseek_key_here
 # OpenRouter requires both API key and referer
 OPENROUTER_API_KEY=sk-or-your_key_here
 OPENROUTER_REFERER=https://github.com/YourUsername/YourApp
+# Optional: Enable dynamic model discovery to use any OpenRouter model
+OPENROUTER_DYNAMIC_MODELS=true
+# Optional: Add title for request tracking
+OPENROUTER_TITLE=YourAppName
 ```
 
 ### Claude Configuration (claude_desktop_config.json)
@@ -102,7 +114,9 @@ OPENROUTER_REFERER=https://github.com/YourUsername/YourApp
         "MISTRAL_API_KEY": "your_key_here",
         "DEEPSEEK_API_KEY": "your_key_here",
         "OPENROUTER_API_KEY": "your_key_here",
-        "OPENROUTER_REFERER": "https://github.com/YourUsername/YourApp"
+        "OPENROUTER_REFERER": "https://github.com/YourUsername/YourApp",
+        "OPENROUTER_DYNAMIC_MODELS": "true",
+        "OPENROUTER_TITLE": "YourAppName"
       }
     }
   }
@@ -133,17 +147,38 @@ All providers support streaming responses for real-time output.
 
 When using the chat or consensus tools, specify models using their identifiers:
 
+### Model Routing Logic
+
+1. **Simple Names**: Models without "/" are routed by keyword matching:
+   - Contains "gpt", "o1", "o3", "o4" → OpenAI
+   - Contains "claude", "opus", "sonnet", "haiku" → Anthropic
+   - Contains "gemini", "flash", "pro" → Google
+   - Contains "grok" → X.AI
+   - Contains "mistral", "magistral" → Mistral
+   - Contains "deepseek", "reasoner", "r1" → DeepSeek
+   - Contains "qwen", "kimi", "k2" → OpenRouter
+
+2. **Slash Format**: Models with "/" check native providers first:
+   - If exact model exists in a native provider → Routes to that provider
+   - If not found in any native provider → Routes to OpenRouter
+   - This allows using models like "anthropic/claude-3.5-sonnet" via OpenRouter
+
+3. **OpenRouter Auto**: Special aliases route to OpenRouter's auto-selection:
+   - "openrouter/auto", "openrouter auto", "auto router", "auto-router"
+
 ```javascript
 // Chat tool examples
 {
-  "model": "gpt-4o",              // OpenAI
-  "model": "claude-opus-4",       // Anthropic (auto-resolves to claude-opus-4-20250514)
-  "model": "sonnet",              // Anthropic (resolves to latest Sonnet 4)
-  "model": "gemini-2.5-pro",      // Google
-  "model": "grok-4-0709",         // X.AI
-  "model": "mistral-large",       // Mistral
-  "model": "deepseek-chat",       // DeepSeek
-  "model": "anthropic/claude-3.5-sonnet"  // OpenRouter
+  "model": "gpt-4o",              // OpenAI (keyword match)
+  "model": "claude-opus-4",       // Anthropic (keyword match, auto-resolves)
+  "model": "sonnet",              // Anthropic (keyword match)
+  "model": "gemini-2.5-pro",      // Google (keyword match)
+  "model": "grok-4-0709",         // X.AI (keyword match)
+  "model": "mistral-large",       // Mistral (keyword match)
+  "model": "deepseek-chat",       // DeepSeek (keyword match)
+  "model": "anthropic/claude-3.5-sonnet",  // OpenRouter (slash format, not in Anthropic)
+  "model": "qwen/qwen3-coder",            // OpenRouter (static model)
+  "model": "openrouter/auto"              // OpenRouter auto-selection
 }
 
 // Consensus tool with multiple providers
@@ -176,4 +211,11 @@ When using the chat or consensus tools, specify models using their identifiers:
 ### OpenRouter Compliance
 - The `OPENROUTER_REFERER` header is **required**
 - Use your application URL or GitHub repository
-- This helps OpenRouter track usage for compliance
+- This helps OpenRouter track usage for compliance
+
+### OpenRouter Dynamic Models
+- Enable with `OPENROUTER_DYNAMIC_MODELS=true`
+- First request to a new model may be slower (fetches capabilities)
+- Model capabilities are cached for 24 hours
+- Use any model from [openrouter.ai/models](https://openrouter.ai/models)
+- Models must use `provider/model` format (e.g., `meta-llama/llama-3.2-90b`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "converse-mcp-server",
-  "version": "1.5.4",
+  "version": "1.6.0",
   "description": "Converse MCP Server - Converse with other LLMs with chat and consensus tools",
   "type": "module",
   "main": "src/index.js",

package/src/config.js

@@ -86,6 +86,8 @@ const CONFIG_SCHEMA = {
   // Provider-specific configuration
   providers: {
     OPENROUTER_REFERER: { type: 'string', required: false, description: 'OpenRouter referer header for compliance' },
+    OPENROUTER_TITLE: { type: 'string', required: false, description: 'OpenRouter X-Title header for request tracking' },
+    OPENROUTER_DYNAMIC_MODELS: { type: 'boolean', default: false, description: 'Enable dynamic model discovery via OpenRouter endpoints API' },
   },
 
 

package/src/providers/anthropic.js

@@ -364,7 +364,9 @@ export const anthropicProvider = {
       apiKey: config.apiKeys.anthropic,
       defaultHeaders: {
         'anthropic-beta': betaHeaders.join(',')
-      }
+      },
+      // Increase timeout to 20 minutes for thinking models that may take longer
+      timeout: 20 * 60 * 1000
     });
 
     // Convert messages to Anthropic format (system messages are always cached)
@@ -383,15 +385,13 @@ export const anthropicProvider = {
       requestPayload.system = systemPrompt;
     }
 
-    // Add max tokens only if explicitly requested
-    // For Claude 4 series models, let the SDK use its defaults (32k for opus, 64k for sonnet)
+    // Set max tokens - API requires this field
     if (maxTokens) {
       requestPayload.max_tokens = Math.min(maxTokens, modelConfig.maxOutputTokens || 8192);
-    } else if (!resolvedModel.includes('claude-opus-4') && !resolvedModel.includes('claude-sonnet-4')) {
-      // For non-4 series models, we still need to set max_tokens
+    } else {
+      // Use model's default max output tokens
       requestPayload.max_tokens = modelConfig.maxOutputTokens || 8192;
     }
-    // For 4 series models without explicit maxTokens, don't set max_tokens - let SDK use defaults
 
     // Add thinking configuration for models that support it
     if (modelConfig.supportsThinking && reasoning_effort) {
@@ -523,15 +523,6 @@ export const anthropicProvider = {
         debugError(`[Anthropic] Error message:`, error.message);
         debugError(`[Anthropic] Error response:`, error.response);
         throw new AnthropicProviderError(`Context length exceeded for model: ${error.message}`, ErrorCodes.CONTEXT_LENGTH_EXCEEDED, error);
-      } else if (error.message?.includes('Streaming is strongly recommended')) {
-        // This is just a warning from the SDK about long requests
-        debugLog(`[Anthropic] SDK streaming recommendation warning`);
-        debugError(`[Anthropic] Full error object:`, error);
-        // Check if there's an actual error response
-        if (error.response || error.status) {
-          debugError(`[Anthropic] Error response status:`, error.status);
-          debugError(`[Anthropic] Error response data:`, error.response);
-        }
       }
 
       // Generic error handling

package/src/providers/openrouter-endpoints-client.js

@@ -0,0 +1,216 @@
+/**
+ * OpenRouter Endpoints API Client
+ * 
+ * Handles fetching model capabilities from OpenRouter's endpoints API.
+ * Provides caching and error handling for dynamic model discovery.
+ */
+
+import { debugLog, debugError } from '../utils/console.js';
+
+/**
+ * Parse an OpenRouter model ID into author and slug components
+ * @param {string} modelId - Model ID in format "author/slug"
+ * @returns {{author: string, slug: string} | null} Parsed components or null if invalid
+ */
+function parseModelId(modelId) {
+  if (!modelId || typeof modelId !== 'string') {
+    return null;
+  }
+  
+  const parts = modelId.split('/');
+  if (parts.length !== 2) {
+    return null;
+  }
+  
+  const [author, slug] = parts;
+  if (!author || !slug) {
+    return null;
+  }
+  
+  return { author, slug };
+}
+
+/**
+ * Convert endpoint data to model configuration format
+ * @param {Object} endpointData - Raw endpoint data from API
+ * @returns {Object} Model configuration object
+ */
+function convertEndpointToModelConfig(endpointData) {
+  const data = endpointData.data;
+  const modelId = data.id;
+  
+  // Find the best endpoint (prefer primary providers)
+  const preferredProviders = ['Anthropic', 'OpenAI', 'Google', 'XAI'];
+  let selectedEndpoint = data.endpoints[0]; // Default to first
+  
+  for (const endpoint of data.endpoints) {
+    if (preferredProviders.includes(endpoint.provider_name)) {
+      selectedEndpoint = endpoint;
+      break;
+    }
+  }
+  
+  // Extract supported parameters
+  const supportedParams = selectedEndpoint.supported_parameters || [];
+  
+  return {
+    modelName: modelId,
+    friendlyName: data.name || `${modelId} (via OpenRouter)`,
+    description: data.description || `Dynamic model: ${modelId}`,
+    contextWindow: selectedEndpoint.context_length || 8192,
+    maxOutputTokens: selectedEndpoint.max_completion_tokens || 4096,
+    supportsStreaming: true, // Most models support streaming
+    supportsImages: data.architecture?.input_modalities?.includes('image') || false,
+    supportsTemperature: supportedParams.includes('temperature'),
+    supportsWebSearch: false, // Not in API response, conservative default
+    supportsThinking: supportedParams.includes('reasoning'),
+    supportsTools: supportedParams.includes('tools'),
+    timeout: 300000, // 5 minutes default
+    isDynamic: true,
+    // Store additional metadata
+    metadata: {
+      architecture: data.architecture,
+      endpoints: data.endpoints,
+      pricing: selectedEndpoint.pricing,
+      selectedProvider: selectedEndpoint.provider_name,
+      maxPromptTokens: selectedEndpoint.max_prompt_tokens
+    }
+  };
+}
+
+/**
+ * Fetch model endpoints from OpenRouter API
+ * @param {string} modelId - Model ID in format "author/slug"
+ * @returns {Promise<Object|null>} Model configuration or null if not found
+ */
+export async function fetchModelEndpoints(modelId) {
+  const parsed = parseModelId(modelId);
+  if (!parsed) {
+    debugLog(`[OpenRouter Endpoints] Invalid model ID format: ${modelId}`);
+    return null;
+  }
+  
+  const { author, slug } = parsed;
+  const url = `https://openrouter.ai/api/v1/models/${author}/${slug}/endpoints`;
+  
+  try {
+    debugLog(`[OpenRouter Endpoints] Fetching endpoints for ${modelId}`);
+    
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: {
+        'Accept': 'application/json'
+      }
+    });
+    
+    if (response.status === 404) {
+      debugLog(`[OpenRouter Endpoints] Model not found: ${modelId}`);
+      return null;
+    }
+    
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    
+    const data = await response.json();
+    
+    // Validate response structure
+    if (!data?.data?.id || !data?.data?.endpoints?.length) {
+      debugLog(`[OpenRouter Endpoints] Invalid response structure for ${modelId}`);
+      return null;
+    }
+    
+    const modelConfig = convertEndpointToModelConfig(data);
+    debugLog(`[OpenRouter Endpoints] Successfully fetched config for ${modelId}`);
+    
+    return modelConfig;
+    
+  } catch (error) {
+    debugError(`[OpenRouter Endpoints] Error fetching ${modelId}:`, error);
+    return null;
+  }
+}
+
+/**
+ * Create a simple in-memory cache for model endpoints
+ */
+export function createEndpointsCache() {
+  const cache = new Map();
+  const DEFAULT_TTL = 24 * 60 * 60 * 1000; // 24 hours
+  const FAILED_TTL = 5 * 60 * 1000; // 5 minutes for failed requests
+  
+  return {
+    /**
+     * Get a cached value
+     * @param {string} key - Cache key
+     * @returns {{found: boolean, value: any}} Cache result
+     */
+    get(key) {
+      const entry = cache.get(key);
+      if (!entry) {
+        return { found: false, value: null };
+      }
+      
+      if (Date.now() > entry.expiry) {
+        cache.delete(key);
+        return { found: false, value: null };
+      }
+      
+      return { found: true, value: entry.value };
+    },
+    
+    /**
+     * Set a cached value
+     * @param {string} key - Cache key
+     * @param {Object|null} value - Value to cache
+     * @param {boolean} isFailure - Whether this is a failed request
+     */
+    set(key, value, isFailure = false) {
+      const ttl = isFailure ? FAILED_TTL : DEFAULT_TTL;
+      cache.set(key, {
+        value,
+        expiry: Date.now() + ttl
+      });
+    },
+    
+    /**
+     * Clear the entire cache
+     */
+    clear() {
+      cache.clear();
+    },
+    
+    /**
+     * Get cache size
+     * @returns {number} Number of cached entries
+     */
+    size() {
+      return cache.size;
+    }
+  };
+}
+
+// Create a singleton cache instance
+export const endpointsCache = createEndpointsCache();
+
+/**
+ * Fetch model endpoints with caching
+ * @param {string} modelId - Model ID in format "author/slug"
+ * @returns {Promise<Object|null>} Model configuration or null if not found
+ */
+export async function fetchModelEndpointsWithCache(modelId) {
+  // Check cache first
+  const cached = endpointsCache.get(modelId);
+  if (cached.found) {
+    debugLog(`[OpenRouter Endpoints] Using cached config for ${modelId}`);
+    return cached.value;
+  }
+  
+  // Fetch from API
+  const config = await fetchModelEndpoints(modelId);
+  
+  // Cache the result (including null for not found)
+  endpointsCache.set(modelId, config, config === null);
+  
+  return config;
+}

package/src/providers/openrouter.js

@@ -11,6 +11,7 @@
 import { createOpenAICompatibleProvider } from './openai-compatible.js';
 import { debugLog } from '../utils/console.js';
 import { ProviderError, ErrorCodes } from './interface.js';
+import { fetchModelEndpointsWithCache } from './openrouter-endpoints-client.js';
 
 // Define supported OpenRouter models with their capabilities
 // Only including the three specific models requested
@@ -54,6 +55,19 @@ const SUPPORTED_MODELS = {
     timeout: 300000,
     description: 'Moonshot AI Kimi K2 with extended context window',
     aliases: ['kimi-k2', 'moonshot-kimi', 'kimi k2', 'kimi', 'moonshot kimi', 'moonshot-k2', 'k2']
+  },
+  'openrouter/auto': {
+    modelName: 'openrouter/auto',
+    friendlyName: 'OpenRouter Auto (via NotDiamond)',
+    contextWindow: 128000, // Safe default for auto-routing
+    maxOutputTokens: 8192, // Safe default
+    supportsStreaming: true,
+    supportsImages: false, // Conservative default
+    supportsTemperature: true,
+    supportsWebSearch: false,
+    timeout: 300000,
+    description: 'Auto-selects the best model for your prompt using NotDiamond routing',
+    aliases: ['openrouter auto', 'auto router', 'auto-router', 'openrouter-auto']
   }
 };
 
@@ -84,12 +98,14 @@ function getCustomHeaders(config) {
   const headers = {};
 
   // REQUIRED: HTTP-Referer header for compliance
-  // Note: config keys are lowercase without underscores due to config.js transformation
-  const referer = config?.providers?.openrouterreferer || 'https://github.com/FallDownTheSystem/converse';
+  // Handle both camelCase (from tests) and lowercase (from config.js) keys
+  const referer = config?.providers?.openrouterreferer ||
+                  config?.providers?.openrouterReferer ||
+                  'https://github.com/FallDownTheSystem/converse';
   headers['HTTP-Referer'] = referer;
 
   // Optional: X-Title header for request tracking
-  const title = config?.providers?.openroutertitle;
+  const title = config?.providers?.openroutertitle || config?.providers?.openrouterTitle;
   if (title) {
     headers['X-Title'] = title;
   }
@@ -169,18 +185,150 @@ export const openrouterProvider = createOpenAICompatibleProvider({
   }
 });
 
-// Override the invoke method to add dynamic headers
+/**
+ * Check if a model string follows OpenRouter's provider/model format
+ */
+function isOpenRouterModelFormat(modelName) {
+  return typeof modelName === 'string' && modelName.includes('/');
+}
+
+/**
+ * Create a dynamic model configuration from minimal information
+ */
+function createDynamicModelConfig(modelName) {
+  return {
+    modelName,
+    friendlyName: `${modelName} (via OpenRouter)`,
+    contextWindow: 8192, // Safe default
+    maxOutputTokens: 4096, // Safe default
+    supportsStreaming: true,
+    supportsImages: false, // Conservative default
+    supportsTemperature: true,
+    supportsWebSearch: false,
+    timeout: 300000,
+    description: `Dynamic model: ${modelName}`,
+    isDynamic: true // Flag to identify dynamic models
+  };
+}
+
+// Store for dynamically discovered models
+const dynamicModels = new Map();
+
+// Override methods to support dynamic models
+const originalGetSupportedModels = openrouterProvider.getSupportedModels;
+openrouterProvider.getSupportedModels = function() {
+  const staticModels = originalGetSupportedModels.call(this);
+
+  // Merge dynamic models if any exist
+  if (dynamicModels.size > 0) {
+    const allModels = { ...staticModels };
+    for (const [modelName, config] of dynamicModels) {
+      allModels[modelName] = config;
+    }
+    return allModels;
+  }
+
+  return staticModels;
+};
+
+// Create an async version of getModelConfig for API fetching
+openrouterProvider.getModelConfigAsync = async function(modelName) {
+  // First check static models
+  const staticConfig = this.getModelConfig(modelName);
+  if (staticConfig && !staticConfig.isDynamic) {
+    return staticConfig;
+  }
+
+  // Check if already in dynamic models cache
+  if (dynamicModels.has(modelName)) {
+    return dynamicModels.get(modelName);
+  }
+
+  // If dynamic models are enabled and model follows format, fetch from API
+  const config = this._lastConfig || {};
+  const dynamicModelsEnabled = config?.providers?.openrouterdynamicmodels || 
+                               config?.providers?.openrouterDynamicModels;
+  if (dynamicModelsEnabled && isOpenRouterModelFormat(modelName)) {
+    debugLog(`[OpenRouter] Fetching dynamic model config for: ${modelName}`);
+    
+    // Fetch from API with caching
+    const apiConfig = await fetchModelEndpointsWithCache(modelName);
+    
+    if (apiConfig) {
+      // Store in dynamic models cache
+      dynamicModels.set(modelName, apiConfig);
+      return apiConfig;
+    } else {
+      // Model not found on API, create default config to avoid repeated lookups
+      const defaultConfig = createDynamicModelConfig(modelName);
+      defaultConfig.notFoundOnApi = true;
+      dynamicModels.set(modelName, defaultConfig);
+      return defaultConfig;
+    }
+  }
+
+  return null;
+};
+
+const originalGetModelConfig = openrouterProvider.getModelConfig;
+openrouterProvider.getModelConfig = function(modelName) {
+  // First check static models
+  const staticConfig = originalGetModelConfig.call(this, modelName);
+  if (staticConfig) {
+    return staticConfig;
+  }
+
+  // Check dynamic models
+  if (dynamicModels.has(modelName)) {
+    return dynamicModels.get(modelName);
+  }
+
+  // For synchronous calls, create default config if dynamic models enabled
+  const config = this._lastConfig || {};
+  const dynamicModelsEnabled = config?.providers?.openrouterdynamicmodels || 
+                               config?.providers?.openrouterDynamicModels;
+  if (dynamicModelsEnabled && isOpenRouterModelFormat(modelName)) {
+    // Note: This is a fallback for synchronous calls
+    // The async version should be preferred for accurate model info
+    const dynamicConfig = createDynamicModelConfig(modelName);
+    dynamicConfig.needsApiUpdate = true;
+    return dynamicConfig;
+  }
+
+  return null;
+};
+
+// Override the invoke method to add dynamic headers and model support
 const originalInvoke = openrouterProvider.invoke;
 openrouterProvider.invoke = async function(messages, options = {}) {
+  // Store config for use in getModelConfig
+  this._lastConfig = options.config;
+
   // Validate referer configuration
-  // Note: config keys are lowercase without underscores due to config.js transformation
-  if (!options.config?.providers?.openrouterreferer) {
+  // Handle both camelCase (from tests) and lowercase (from config.js) keys
+  if (!options.config?.providers?.openrouterreferer && !options.config?.providers?.openrouterReferer) {
     throw new OpenRouterProviderError(
       'OpenRouter requires HTTP-Referer header. Please set OPENROUTER_REFERER in your environment',
       ErrorCodes.INVALID_REQUEST
     );
   }
 
+  // Check if we need to fetch dynamic model config
+  const modelName = options.model;
+  if (modelName) {
+    const existingConfig = this.getModelConfig(modelName);
+    
+    // If the model needs API update, fetch it now
+    if (existingConfig?.needsApiUpdate) {
+      const dynamicModelsEnabled = options.config?.providers?.openrouterdynamicmodels || 
+                                  options.config?.providers?.openrouterDynamicModels;
+      if (dynamicModelsEnabled) {
+        debugLog(`[OpenRouter] Fetching API config for model: ${modelName}`);
+        await this.getModelConfigAsync(modelName);
+      }
+    }
+  }
+
   // Create a modified config with custom headers
   const modifiedOptions = {
     ...options,

package/src/tools/chat.js

@@ -159,7 +159,7 @@ export async function chatTool(args, dependencies) {
     } else {
       // Use specified provider/model
       // Try to map model to provider
-      providerName = mapModelToProvider(model);
+      providerName = mapModelToProvider(model, providers);
       selectedProvider = providers[providerName];
 
       if (!selectedProvider) {
@@ -282,7 +282,7 @@ function resolveAutoModel(model, providerName) {
   return defaults[providerName] || 'gpt-4o-mini';
 }
 
-function mapModelToProvider(model) {
+function mapModelToProvider(model, providers) {
   const modelLower = model.toLowerCase();
 
   // Handle "auto" - default to OpenAI
@@ -290,6 +290,30 @@ function mapModelToProvider(model) {
     return 'openai';
   }
 
+  // Check OpenRouter-specific patterns first
+  if (modelLower === 'openrouter auto' || modelLower === 'auto router' ||
+      modelLower === 'auto-router' || modelLower === 'openrouter-auto') {
+    return 'openrouter';
+  }
+
+  // If model contains "/", check if native provider supports it
+  if (modelLower.includes('/')) {
+    // Check each provider to see if they have this exact model
+    for (const [providerName, provider] of Object.entries(providers)) {
+      if (provider && provider.getModelConfig) {
+        const modelConfig = provider.getModelConfig(model);
+        if (modelConfig && !modelConfig.isDynamic && !modelConfig.needsApiUpdate) {
+          // Model exists in this provider's static list
+          return providerName;
+        }
+      }
+    }
+    // No native provider has this model, route to OpenRouter
+    return 'openrouter';
+  }
+
+  // For non-slash models, use keyword matching as before
+  
   // OpenAI models
   if (modelLower.includes('gpt') || modelLower.includes('o1') ||
       modelLower.includes('o3') || modelLower.includes('o4')) {
@@ -326,8 +350,7 @@ function mapModelToProvider(model) {
 
   // OpenRouter models (specific model patterns)
   if (modelLower.includes('qwen') || modelLower.includes('kimi') ||
-      modelLower.includes('moonshot') || modelLower === 'k2' ||
-      modelLower.includes('/')) {  // OpenRouter uses provider/model format
+      modelLower.includes('moonshot') || modelLower === 'k2') {
     return 'openrouter';
   }
 

package/src/tools/consensus.js

@@ -154,7 +154,7 @@ export async function consensusTool(args, dependencies) {
       }
 
       const modelName = modelSpec.model;
-      const providerName = mapModelToProvider(modelName);
+      const providerName = mapModelToProvider(modelName, providers);
       const resolvedModelName = resolveAutoModel(modelName, providerName);
       const provider = providers[providerName];
 
@@ -416,7 +416,7 @@ function resolveAutoModel(model, providerName) {
   return defaults[providerName] || 'o3';
 }
 
-function mapModelToProvider(model) {
+function mapModelToProvider(model, providers) {
   const modelLower = model.toLowerCase();
 
   // Handle "auto" - default to OpenAI
@@ -424,6 +424,30 @@ function mapModelToProvider(model) {
     return 'openai';
   }
 
+  // Check OpenRouter-specific patterns first
+  if (modelLower === 'openrouter auto' || modelLower === 'auto router' ||
+      modelLower === 'auto-router' || modelLower === 'openrouter-auto') {
+    return 'openrouter';
+  }
+
+  // If model contains "/", check if native provider supports it
+  if (modelLower.includes('/')) {
+    // Check each provider to see if they have this exact model
+    for (const [providerName, provider] of Object.entries(providers)) {
+      if (provider && provider.getModelConfig) {
+        const modelConfig = provider.getModelConfig(model);
+        if (modelConfig && !modelConfig.isDynamic && !modelConfig.needsApiUpdate) {
+          // Model exists in this provider's static list
+          return providerName;
+        }
+      }
+    }
+    // No native provider has this model, route to OpenRouter
+    return 'openrouter';
+  }
+
+  // For non-slash models, use keyword matching as before
+  
   // OpenAI models
   if (modelLower.includes('gpt') || modelLower.includes('o1') ||
       modelLower.includes('o3') || modelLower.includes('o4')) {
@@ -460,8 +484,7 @@ function mapModelToProvider(model) {
 
   // OpenRouter models (specific model patterns)
   if (modelLower.includes('qwen') || modelLower.includes('kimi') ||
-      modelLower.includes('moonshot') || modelLower === 'k2' ||
-      modelLower.includes('/')) {  // OpenRouter uses provider/model format
+      modelLower.includes('moonshot') || modelLower === 'k2') {
     return 'openrouter';
   }