Fix: Load models dynamically for all OpenAI-compatible endpoints

Fixes #93

- Remove isLocal logic that only loaded models for localhost/127.0.0.1
- Always attempt to fetch models dynamically from any OpenAI-compatible endpoint
- Fall back to static OpenAI model list only when fetch fails
- Simplify code by removing conditional logic (~50 lines removed)

Tested with:
- LM Studio (localhost)
- Remote Ollama server with OpenAI-compatible endpoint
- Graceful fallback when endpoint unavailable

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: hydropix

src/api/blueprints/config_routes.py

@@ -220,8 +220,8 @@ def _get_openrouter_models(provided_api_key=None):
     def _get_openai_models(provided_api_key=None, api_endpoint=None):
         """Get available models from OpenAI-compatible API
 
-        For local servers (llama.cpp, LM Studio, vLLM, etc.), fetches models dynamically.
-        For official OpenAI API, returns a static list of common models.
+        Always tries to fetch models dynamically from any OpenAI-compatible endpoint.
+        Falls back to static list if dynamic fetch fails.
         """
         api_key = _resolve_api_key(provided_api_key, 'OPENAI_API_KEY', OPENAI_API_KEY)
 
@@ -232,10 +232,7 @@ def _get_openai_models(provided_api_key=None, api_endpoint=None):
         else:
             base_url = 'https://api.openai.com/v1'
 
-        # Check if this is a local server (llama.cpp, LM Studio, vLLM, etc.)
-        is_local = 'localhost' in base_url or '127.0.0.1' in base_url
-
-        # Static list of OpenAI models (fallback for official API)
+        # Static list of OpenAI models (fallback)
         openai_static_models = [
             {'id': 'gpt-4o', 'name': 'GPT-4o (Latest)'},
             {'id': 'gpt-4o-mini', 'name': 'GPT-4o Mini'},
@@ -251,7 +248,7 @@ def _get_openai_models(provided_api_key=None, api_endpoint=None):
                 headers['Authorization'] = f'Bearer {api_key}'
 
             if DEBUG_MODE:
-                logger.debug(f"📥 Fetching models from OpenAI-compatible server: {models_url}")
+                logger.debug(f"📥 Fetching models from OpenAI-compatible endpoint: {models_url}")
 
             response = requests.get(models_url, headers=headers, timeout=10)
 
@@ -285,91 +282,32 @@ def _get_openai_models(provided_api_key=None, api_endpoint=None):
                             "model_names": model_ids,
                             "default": default_model,
                             "status": "openai_connected",
-                            "count": len(models),
-                            "is_local": is_local
+                            "count": len(models)
                         })
 
             # If we get here, either request failed or no models returned
-            # For local servers, return error; for OpenAI, return static list
-            if is_local:
-                error_msg = f"Could not connect to local server at {base_url}. Make sure your OpenAI-compatible server (llama.cpp, LM Studio, vLLM, etc.) is running."
-                return jsonify({
-                    "models": [],
-                    "model_names": [],
-                    "default": "",
-                    "status": "openai_error",
-                    "count": 0,
-                    "error": error_msg,
-                    "is_local": True
-                })
-            else:
-                # Return static OpenAI models
-                model_ids = [m['id'] for m in openai_static_models]
-                return jsonify({
-                    "models": openai_static_models,
-                    "model_names": model_ids,
-                    "default": "gpt-4o",
-                    "status": "openai_static",
-                    "count": len(openai_static_models),
-                    "is_local": False
-                })
-
-        except requests.exceptions.ConnectionError:
-            if is_local:
-                error_msg = f"Connection refused to {base_url}. Is your OpenAI-compatible server running?"
-            else:
-                error_msg = f"Connection error to OpenAI API"
-
+            # Fall back to static list
             if DEBUG_MODE:
-                logger.debug(f"❌ OpenAI-compatible server connection error: {error_msg}")
+                logger.debug(f"⚠️ No models returned from {base_url}, using fallback list")
 
-            # For official OpenAI, return static list even on error
-            if not is_local:
-                model_ids = [m['id'] for m in openai_static_models]
-                return jsonify({
-                    "models": openai_static_models,
-                    "model_names": model_ids,
-                    "default": "gpt-4o",
-                    "status": "openai_static",
-                    "count": len(openai_static_models),
-                    "is_local": False
-                })
-
-            return jsonify({
-                "models": [],
-                "model_names": [],
-                "default": "",
-                "status": "openai_error",
-                "count": 0,
-                "error": error_msg,
-                "is_local": True
-            })
+        except requests.exceptions.ConnectionError as e:
+            error_msg = f"Connection error to {base_url}"
+            if DEBUG_MODE:
+                logger.debug(f"❌ OpenAI-compatible endpoint connection error: {error_msg}")
 
         except Exception as e:
             if DEBUG_MODE:
-                logger.debug(f"❌ OpenAI-compatible server error: {e}")
-
-            # For official OpenAI, return static list even on error
-            if not is_local:
-                model_ids = [m['id'] for m in openai_static_models]
-                return jsonify({
-                    "models": openai_static_models,
-                    "model_names": model_ids,
-                    "default": "gpt-4o",
-                    "status": "openai_static",
-                    "count": len(openai_static_models),
-                    "is_local": False
-                })
+                logger.debug(f"❌ OpenAI-compatible endpoint error: {e}")
 
-            return jsonify({
-                "models": [],
-                "model_names": [],
-                "default": "",
-                "status": "openai_error",
-                "count": 0,
-                "error": str(e),
-                "is_local": True
-            })
+        # Fallback: return static OpenAI models
+        model_ids = [m['id'] for m in openai_static_models]
+        return jsonify({
+            "models": openai_static_models,
+            "model_names": model_ids,
+            "default": "gpt-4o",
+            "status": "openai_static",
+            "count": len(openai_static_models)
+        })
 
     def _get_gemini_models(provided_api_key=None):
         """Get available models from Gemini API"""

src/web/static/js/providers/provider-manager.js

@@ -427,59 +427,53 @@ export const ProviderManager = {
 
     /**
      * Load OpenAI-compatible models dynamically
-     * For local servers (llama.cpp, LM Studio, vLLM, etc.): fetches models from the local server
-     * For OpenAI: uses static list (dynamic fetch requires valid API key)
+     * Always tries to fetch models dynamically from any OpenAI-compatible endpoint.
+     * Falls back to static list if dynamic fetch fails.
      */
     async loadOpenAIModels() {
         const modelSelect = DomHelpers.getElement('model');
         if (!modelSelect) return;
 
-        // Get API endpoint to determine if it's a local server or OpenAI cloud
         const apiEndpoint = DomHelpers.getValue('openaiEndpoint') || 'https://api.openai.com/v1/chat/completions';
-        const isLocal = apiEndpoint.includes('localhost') || apiEndpoint.includes('127.0.0.1');
 
+        modelSelect.innerHTML = '<option value="">Loading models...</option>';
         StatusManager.setChecking();
 
-        if (isLocal) {
-            // Local server (llama.cpp, LM Studio, vLLM, etc.): try to fetch models dynamically
-            modelSelect.innerHTML = '<option value="">Loading models from local server...</option>';
+        try {
+            const apiKey = ApiKeyUtils.getValue('openaiApiKey');
+            const data = await ApiClient.getModels('openai', { apiKey, apiEndpoint });
 
-            try {
-                const apiKey = ApiKeyUtils.getValue('openaiApiKey');
-                const data = await ApiClient.getModels('openai', { apiKey, apiEndpoint });
+            if (data.models && data.models.length > 0) {
+                MessageLogger.showMessage('', '');
 
-                if (data.models && data.models.length > 0) {
-                    MessageLogger.showMessage('', '');
+                // Format models for the dropdown
+                const formattedModels = data.models.map(m => ({
+                    value: m.id,
+                    label: m.name || m.id
+                }));
 
-                    // Format models for the dropdown
-                    const formattedModels = data.models.map(m => ({
-                        value: m.id,
-                        label: m.name || m.id
-                    }));
+                const envModelApplied = populateModelSelect(formattedModels, data.default, 'openai');
+                MessageLogger.addLog(`✅ ${data.count} model(s) loaded from OpenAI-compatible endpoint`);
 
-                    const envModelApplied = populateModelSelect(formattedModels, data.default, 'openai');
-                    MessageLogger.addLog(`✅ ${data.count} model(s) loaded from local server`);
+                if (envModelApplied && data.default) {
+                    SettingsManager.markEnvModelApplied();
+                }
 
-                    if (envModelApplied && data.default) {
-                        SettingsManager.markEnvModelApplied();
-                    }
+                SettingsManager.applyPendingModelSelection();
+                ModelDetector.checkAndShowRecommendation();
 
-                    SettingsManager.applyPendingModelSelection();
-                    ModelDetector.checkAndShowRecommendation();
-
-                    StateManager.setState('models.availableModels', formattedModels.map(m => m.value));
-                    StatusManager.setConnected('openai', data.count);
-                    return;
-                } else {
-                    // Local server not running or no models
-                    const errorMsg = data.error || 'Local server not accessible';
-                    MessageLogger.showMessage(`⚠️ ${errorMsg}`, 'warning');
-                    MessageLogger.addLog(`⚠️ ${errorMsg}. Using fallback OpenAI models.`);
-                }
-            } catch (error) {
-                MessageLogger.showMessage(`⚠️ Could not connect to local server. Using fallback models.`, 'warning');
-                MessageLogger.addLog(`⚠️ Local server connection error: ${error.message}`);
+                StateManager.setState('models.availableModels', formattedModels.map(m => m.value));
+                StatusManager.setConnected('openai', data.count);
+                return;
+            } else {
+                // No models returned from endpoint
+                const errorMsg = data.error || 'No models available from endpoint';
+                MessageLogger.showMessage(`⚠️ ${errorMsg}. Using fallback OpenAI models.`, 'warning');
+                MessageLogger.addLog(`⚠️ ${errorMsg}. Using fallback list.`);
             }
+        } catch (error) {
+            MessageLogger.showMessage(`⚠️ Could not connect to endpoint. Using fallback OpenAI models.`, 'warning');
+            MessageLogger.addLog(`⚠️ Connection error: ${error.message}. Using fallback list.`);
         }
 
         // Fallback: use static OpenAI models list