Skip to content

~95% on SimpleQA (e.g. Qwen3.6-27B on a 3090). Supports all local and cloud LLMs (llama.cpp, Ollama, Google, ...). 10+ search engines - arXiv, PubMed, your private documents. Everything Local & Encrypted.

fix(settings): source the provider dropdown from auto-discovery (not a hardcoded list) (#4622)

LearningCircuitf66404db182b
diff --git a/src/local_deep_research/web/static/js/components/settings.js b/src/local_deep_research/web/static/js/components/settings.js
index 746484751e..40b0282249 100644
--- a/src/local_deep_research/web/static/js/components/settings.js
+++ b/src/local_deep_research/web/static/js/components/settings.js
@@ -13,6 +13,10 @@
formatValueForDisplay,
} = window.LdrValueHelpers;
+ // Provider-dropdown option resolution, extracted to utils/provider-options.js
+ // for testability (see resolveProviderOptions there).
+ const { resolveProviderOptions } = window.LdrProviderOptions;
+
// DOM elements and global variables
let settingsForm;
let settingsContent;
@@ -31,6 +35,11 @@
// Model and search engine dropdown variables
let modelOptions = [];
let searchEngineOptions = [];
+ // Provider options surfaced by the backend auto-discovery endpoint
+ // (/settings/api/available-models). Preferred over the static fallback
+ // lists below so the provider dropdown stays in sync with the registry and
+ // can't drift (e.g. silently miss xai/ionos/deepseek/google/openrouter).
+ let discoveredProviderOptions = [];
// Store save timers for each setting key
let saveTimers = {};
@@ -3441,9 +3450,21 @@
// Create a new array to store all formatted models
const formattedModels = [];
- // Process provider options first
- if (data.provider_options) {
- SafeLogger.log('Found provider options:', data.provider_options.length);
+ // Process provider options first. Capture the auto-discovered list so
+ // the provider dropdown is sourced from the backend registry rather
+ // than a hardcoded fallback (keeps it in sync with auto-discovery).
+ if (
+ Array.isArray(data.provider_options) &&
+ data.provider_options.length > 0
+ ) {
+ SafeLogger.log(
+ 'Found provider options:',
+ data.provider_options.length,
+ );
+ discoveredProviderOptions = data.provider_options.map(opt => ({
+ value: opt.value,
+ label: opt.label,
+ }));
}
// Lift every <provider>_models array the backend returned. Each
@@ -3573,7 +3594,12 @@
const providerDropdown = window.setupCustomDropdown(
settingsProviderInput,
providerList,
- () => MODEL_PROVIDERS,
+ () =>
+ resolveProviderOptions(
+ discoveredProviderOptions,
+ allSettings,
+ MODEL_PROVIDERS,
+ ),
(value) => {
SafeLogger.log('Provider selected:', value);
@@ -4224,25 +4250,13 @@
}
} else if (settingKey === 'llm.provider') {
// Special handling for provider dropdown
- const MODEL_PROVIDERS = [
- { value: 'ollama', label: 'Ollama (Local)' },
- { value: 'openai', label: 'OpenAI (Cloud)' },
- { value: 'anthropic', label: 'Anthropic (Cloud)' },
- { value: 'openai_endpoint', label: 'OpenAI-Compatible Endpoint (llama.cpp, vLLM, etc.)' }
- ];
-
- optionsSource = MODEL_PROVIDERS;
-
- // Try to get options from settings if available
- if (typeof allSettings !== 'undefined' && Array.isArray(allSettings)) {
- const availableProviders = allSettings.find(s => s.key === 'llm.provider');
- if (availableProviders && availableProviders.options && availableProviders.options.length > 0) {
- optionsSource = availableProviders.options.map(opt => ({
- value: opt.value,
- label: opt.label
- }));
- }
- }
+ // Single source of truth for the provider list (see
+ // resolveProviderOptions): auto-discovery → settings → static.
+ optionsSource = resolveProviderOptions(
+ discoveredProviderOptions,
+ allSettings,
+ MODEL_PROVIDERS,
+ );
} else if (settingKey === 'search.tool') {
optionsSource = typeof searchEngineOptions !== 'undefined' && searchEngineOptions.length > 0 ?
searchEngineOptions : [
diff --git a/src/local_deep_research/web/static/js/utils/provider-options.js b/src/local_deep_research/web/static/js/utils/provider-options.js
new file mode 100644
index 0000000000..ab3f97799c
--- /dev/null
+++ b/src/local_deep_research/web/static/js/utils/provider-options.js
@@ -0,0 +1,65 @@
+/**
+ * Provider-dropdown option resolution.
+ *
+ * Extracted from components/settings.js so the fallback logic can be
+ * unit-tested (the settings.js IIFE is otherwise unreachable from tests).
+ *
+ * Exposes window.LdrProviderOptions. Consumers destructure at the top of
+ * their IIFE, e.g.
+ * const { resolveProviderOptions } = window.LdrProviderOptions;
+ */
+(function() {
+ 'use strict';
+
+ /**
+ * Resolve the model-provider dropdown options with a single, explicit
+ * fallback chain:
+ * 1. the backend's auto-discovered list (/settings/api/available-models),
+ * 2. the llm.provider setting's own options, then
+ * 3. the static fallback list (offline).
+ * Pure function — callers pass the current state so it stays testable and
+ * can be re-evaluated lazily (on dropdown open) regardless of fetch/setup
+ * ordering.
+ *
+ * @param {Array<{value: string, label: string}>} discoveredProviderOptions
+ * Options from the auto-discovery endpoint (preferred).
+ * @param {Array<{key: string, options?: Array}>} allSettings
+ * The loaded settings list; the llm.provider entry's options are the
+ * secondary fallback.
+ * @param {Array<{value: string, label: string}>} staticProviders
+ * Hardcoded last-resort list used when the page is offline.
+ * @returns {Array<{value: string, label: string}>}
+ */
+ function resolveProviderOptions(
+ discoveredProviderOptions,
+ allSettings,
+ staticProviders,
+ ) {
+ if (
+ Array.isArray(discoveredProviderOptions) &&
+ discoveredProviderOptions.length > 0
+ ) {
+ return discoveredProviderOptions;
+ }
+ if (Array.isArray(allSettings)) {
+ const providerSetting = allSettings.find(
+ s => s && s.key === 'llm.provider',
+ );
+ if (
+ providerSetting &&
+ Array.isArray(providerSetting.options) &&
+ providerSetting.options.length > 0
+ ) {
+ return providerSetting.options.map(opt => ({
+ value: opt.value,
+ label: opt.label,
+ }));
+ }
+ }
+ return staticProviders;
+ }
+
+ window.LdrProviderOptions = {
+ resolveProviderOptions,
+ };
+})();
diff --git a/src/local_deep_research/web/templates/base.html b/src/local_deep_research/web/templates/base.html
index ac4ec200ee..7ccdb92ad8 100644
--- a/src/local_deep_research/web/templates/base.html
+++ b/src/local_deep_research/web/templates/base.html
@@ -261,6 +261,7 @@
<script defer src="/static/js/utils/form-validation.js"></script>
<script defer src="/static/js/utils/sse-completion.js"></script>
<script defer src="/static/js/utils/value-helpers.js"></script>
+ <script defer src="/static/js/utils/provider-options.js"></script>
<script defer src="/static/js/utils/alert-helpers.js"></script>
<script defer src="/static/js/utils/format-bytes.js"></script>
diff --git a/tests/js/utils/provider-options.test.js b/tests/js/utils/provider-options.test.js
new file mode 100644
index 0000000000..29dc0f4b40
--- /dev/null
+++ b/tests/js/utils/provider-options.test.js
@@ -0,0 +1,66 @@
+/**
+ * Tests for utils/provider-options.js
+ *
+ * resolveProviderOptions backs the settings-page model-provider dropdown.
+ * It must prefer the backend's auto-discovered list so the dropdown can't
+ * drift from the provider registry (#4622), while falling back safely when
+ * the API list is unavailable (offline / fetch failure).
+ */
+
+import '@js/utils/provider-options.js';
+
+const { resolveProviderOptions } = window.LdrProviderOptions;
+
+const STATIC = [
+ { value: 'OLLAMA', label: 'Ollama (Local)' },
+ { value: 'OPENAI', label: 'OpenAI (Cloud)' },
+];
+
+describe('resolveProviderOptions', () => {
+ it('prefers the auto-discovered list when it has entries', () => {
+ const discovered = [
+ { value: 'OPENAI', label: 'OpenAI ☁️ Cloud' },
+ { value: 'XAI', label: 'xAI ☁️ Cloud' },
+ ];
+ // Returned as-is (same reference) so the full discovered set is shown.
+ expect(resolveProviderOptions(discovered, [], STATIC)).toBe(discovered);
+ });
+
+ it('falls back to the llm.provider settings options when discovery is empty', () => {
+ const allSettings = [
+ { key: 'something.else', options: [{ value: 'X', label: 'X' }] },
+ {
+ key: 'llm.provider',
+ options: [
+ { value: 'GOOGLE', label: 'Google', extra: 'ignored' },
+ ],
+ },
+ ];
+ const result = resolveProviderOptions([], allSettings, STATIC);
+ // Projected to {value, label} only (drops arbitrary backend props).
+ expect(result).toEqual([{ value: 'GOOGLE', label: 'Google' }]);
+ });
+
+ it('falls back to the static list when neither discovery nor settings have options', () => {
+ expect(resolveProviderOptions([], [], STATIC)).toBe(STATIC);
+ expect(
+ resolveProviderOptions([], [{ key: 'llm.provider', options: [] }], STATIC),
+ ).toBe(STATIC);
+ expect(
+ resolveProviderOptions([], [{ key: 'other', options: [{ value: 'a', label: 'a' }] }], STATIC),
+ ).toBe(STATIC);
+ });
+
+ it('is defensive against non-array discovered / settings input', () => {
+ expect(resolveProviderOptions(undefined, undefined, STATIC)).toBe(STATIC);
+ expect(resolveProviderOptions(null, null, STATIC)).toBe(STATIC);
+ expect(resolveProviderOptions('nope', 42, STATIC)).toBe(STATIC);
+ });
+
+ it('does not mutate its inputs', () => {
+ const discovered = [{ value: 'A', label: 'A' }];
+ const snapshot = JSON.parse(JSON.stringify(discovered));
+ resolveProviderOptions(discovered, [], STATIC);
+ expect(discovered).toEqual(snapshot);
+ });
+});