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): 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.md
new file mode 100644
index 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.py
index 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 None
if value == default_meta.get("value"):
@@ -1681,14 +1688,6 @@ class SettingsManager(ISettingsManager):
# Import here to avoid circular imports
from ..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.py
index 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