~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.
Python academiaanthropicarxivbravedeep-researchencryptionhome-automationhomeserverlocallocal-deep-researchlocal-llmmistralollamaopenaipubmedresearchresearch-toolretrieval-augmented-generationsearxngself-hosted
fix(settings): skip the type probe for an unknown ui_element on import (#5714)
Ehsan3fea2861039c
diff --git a/changelog.d/5674.bugfix.md b/changelog.d/5674.bugfix.mdnew file mode 100644index 0000000000..9e6ccbda1c--- /dev/null+++ b/changelog.d/5674.bugfix.md@@ -0,0 +1,12 @@+Importing settings no longer logs a "returning default value" warning from+the validation path for a setting whose `ui_element` is not one the current+build knows about. Nothing was substituted there, so the message described+something that never happened, and it repeated for every affected key on+every import. It still fires from the read path, where it is accurate, so an+import made from a browser session can still produce it once per changed key+while building the `settings_changed` payload.++Those payload reads now happen after the check for a recipient rather than+before it, restoring the pre-migration order. An import outside a request+context, which is every fresh-install seeding, no longer reads back each+setting it just wrote for an emit that is then skipped.diff --git a/src/local_deep_research/settings/manager.py b/src/local_deep_research/settings/manager.pyindex a1f06d5244..de6b7fe7b8 100644--- a/src/local_deep_research/settings/manager.py+++ b/src/local_deep_research/settings/manager.py@@ -182,10 +182,17 @@ def _validate_imported_setting_value(reason string when it is not."""ui_element = default_meta.get("ui_element")- if not isinstance(ui_element, str):- # Unknown UI element (e.g. a future ui_element from a newer export)- # has no constraints to enforce here; the read path's type coercion- # handles it.+ if (+ not isinstance(ui_element, str)+ or ui_element not in UI_ELEMENT_TO_SETTING_TYPE+ ):+ # An unknown ui_element comes from the shipped defaults, not from the+ # imported file: default_meta is self.default_settings. There is+ # nothing to enforce for one, and probing get_typed_setting_value+ # would log a default-substitution warning about a value this path+ # stores verbatim. That value is then dead on read: the same helper+ # substitutes the default for an element the type map lacks, so the+ # imported value never comes back out.return Noneif value == default_meta.get("value"):@@ -1681,14 +1688,6 @@ class SettingsManager(ISettingsManager):# Import here to avoid circular importsfrom ..web.services.socketio_asgi import emit_to_user- # Get the changed settings- settings_data = {}- if changed_keys:- for key in changed_keys:- setting_value = self.get_setting(key)- if setting_value is not None:- settings_data[key] = {"value": setting_value}-# settings_changed carries raw setting values (including plaintext# API keys), so it must reach only the owning user's own browser# tabs — never every connected client on this shared, single-user-@@ -1709,6 +1708,16 @@ class SettingsManager(ISettingsManager):)return+ # Read the changed values only after the recipient check: each+ # read types the stored row, so an unknown ui_element logs a+ # default-substitution warning for an emit that never happens.+ settings_data = {}+ if changed_keys:+ for key in changed_keys:+ setting_value = self.get_setting(key)+ if setting_value is not None:+ settings_data[key] = {"value": setting_value}+emit_to_user("settings_changed",username,diff --git a/tests/settings/test_import_settings_validation.py b/tests/settings/test_import_settings_validation.pyindex df6abcb6a0..facecaf489 100644--- a/tests/settings/test_import_settings_validation.py+++ b/tests/settings/test_import_settings_validation.py@@ -394,3 +394,124 @@ class TestDynamicSettingsSingleSource:assert (settings_service.DYNAMIC_SETTINGS is manager_module.DYNAMIC_SETTINGS)+++class TestUnknownUiElementImport:+ """#5674: an unknown ``ui_element`` must not log a default-substitution+ warning on a value the import accepts and stores verbatim.++ ``_validate_imported_setting_value`` reads ``ui_element`` from the+ current-defaults metadata and uses ``get_typed_setting_value`` only as a+ validity probe, discarding its return. That helper's "returning default+ value" message is therefore false on this path.+ """++ UNKNOWN_KEY = "app.future_knob"+ UNKNOWN_META = {+ "value": "shipped_default",+ "type": "APP",+ "name": "Future Knob",+ "ui_element": "future_widget",+ }++ @pytest.fixture+ def session(self):+ from sqlalchemy import create_engine+ from sqlalchemy.orm import sessionmaker++ from local_deep_research.database.models import Base++ engine = create_engine("sqlite:///:memory:")+ Base.metadata.create_all(engine)+ Session = sessionmaker(bind=engine)+ session = Session()+ yield session+ session.close()+ engine.dispose()++ def test_unknown_ui_element_probe_logs_no_default_warning(+ self, loguru_caplog+ ):+ """The helper under repair, driven directly."""+ from local_deep_research.settings.manager import (+ _validate_imported_setting_value,+ )++ with loguru_caplog.at_level("WARNING"):+ reason = _validate_imported_setting_value(+ self.UNKNOWN_KEY, "user_choice", dict(self.UNKNOWN_META)+ )++ assert reason is None+ assert "Got unknown type" not in loguru_caplog.text++ def test_import_of_unknown_ui_element_default_logs_no_warning(+ self, session, loguru_caplog+ ):+ """The same path through ``import_settings``.++ The branch is reachable only when the *current defaults* carry a+ ui_element absent from ``UI_ELEMENT_TO_SETTING_TYPE``, since that is+ where ``default_meta`` comes from. Every shipped default uses a known+ element today, so the extra key models a defaults file that has grown+ one ahead of the type map.+ """+ from local_deep_research.database.models import Setting+ from local_deep_research.settings.manager import SettingsManager++ manager = SettingsManager(db_session=session)+ # default_settings is a cached_property; seeding the instance cache+ # adds the key without touching the shipped defaults on disk.+ manager.default_settings = {+ **manager.default_settings,+ self.UNKNOWN_KEY: dict(self.UNKNOWN_META),+ }++ with loguru_caplog.at_level("WARNING"):+ manager.import_settings(+ {+ self.UNKNOWN_KEY: {+ **self.UNKNOWN_META,+ "value": "user_choice",+ }+ },+ overwrite=True,+ )++ assert "Got unknown type" not in loguru_caplog.text+ stored = (+ session.query(Setting)+ .filter(Setting.key == self.UNKNOWN_KEY)+ .first()+ )+ assert stored is not None and stored.value == "user_choice"++ # Stored verbatim and dead on read: get_typed_setting_value has no+ # type for this element, so every read substitutes the default. The+ # message was false about the import, and dropping it does not make+ # the imported value reachable.+ assert manager.get_setting(self.UNKNOWN_KEY) is None++ def test_get_typed_setting_value_still_warns(self, loguru_caplog):+ """Positive control for the capture path and for the read path.++ ``local_deep_research/__init__.py`` disables loguru for the package+ at import time, so a bare negative assertion passes even with the fix+ absent. This also pins that the warning is intact where it is true:+ ``get_typed_setting_value`` really does return the default there.+ """+ from local_deep_research.settings.manager import (+ get_typed_setting_value,+ )++ with loguru_caplog.at_level("WARNING"):+ returned = get_typed_setting_value(+ key=self.UNKNOWN_KEY,+ value="user_choice",+ ui_element="future_widget",+ default="the_default",+ check_env=False,+ )++ assert returned == "the_default"+ assert "Got unknown type" in loguru_caplog.text