~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
"""Invalid configured values must stop work at consumer fallback boundaries."""
import json
from contextlib import nullcontext
from threading import RLock
from types import SimpleNamespace
from unittest.mock import Mock
import pytest
from local_deep_research.settings.exceptions import SettingsValueError
@pytest.fixture
def settings_error():
return SettingsValueError(
"llm.temperature", source="environment", reason="expected a number"
)
@pytest.mark.parametrize("source", ["snapshot", "database"])
def test_search_config_does_not_replace_invalid_settings(
monkeypatch, settings_error, source
):
from local_deep_research.web_search_engines import search_engines_config
reader = Mock(side_effect=settings_error)
database_reader = Mock()
manager = SimpleNamespace(get_setting=database_reader)
manager_factory = Mock(return_value=manager)
monkeypatch.setattr(
search_engines_config, "get_setting_from_snapshot", reader
)
monkeypatch.setattr(
search_engines_config, "get_settings_manager", manager_factory
)
if source == "database":
database_reader.side_effect = settings_error
with pytest.raises(SettingsValueError) as raised:
search_engines_config._get_setting(
"llm.temperature",
default_value=0.7,
db_session=object(),
settings_snapshot={"present": True}
if source == "snapshot"
else None,
)
assert raised.value is settings_error
if source == "snapshot":
manager_factory.assert_not_called()
def test_availability_probe_does_not_treat_invalid_settings_as_available(
monkeypatch, settings_error
):
from local_deep_research.security import module_whitelist
from local_deep_research.web_search_engines import search_engines_config
from local_deep_research.web_search_engines.search_engine_base import (
BaseSearchEngine,
)
class InvalidSettingsEngine(BaseSearchEngine):
@classmethod
def is_available(cls, settings_snapshot=None):
raise settings_error
monkeypatch.setattr(
module_whitelist,
"get_safe_module_class",
lambda *args: InvalidSettingsEngine,
)
with pytest.raises(SettingsValueError) as raised:
search_engines_config._engine_class_is_available(
"probe",
{"module_path": ".probe", "class_name": "Probe"},
{"present": True},
)
assert raised.value is settings_error
def test_engine_constructor_error_does_not_become_a_default_engine(
monkeypatch, settings_error
):
from local_deep_research.security.egress import policy
from local_deep_research.web_search_engines import search_engine_factory
constructions = []
class InvalidSettingsEngine:
def __init__(self, settings_snapshot=None):
constructions.append(settings_snapshot)
raise settings_error
monkeypatch.setattr(
search_engine_factory.retriever_registry, "get", lambda *a, **k: None
)
monkeypatch.setattr(
search_engine_factory,
"search_config",
lambda **kwargs: {
"probe": {"module_path": ".probe", "class_name": "Probe"}
},
)
monkeypatch.setattr(
search_engine_factory,
"get_safe_module_class",
lambda *args: InvalidSettingsEngine,
)
monkeypatch.setattr(
policy,
"evaluate_engine",
lambda *args, **kwargs: policy.Decision(True, "test_allowed"),
)
with pytest.raises(SettingsValueError) as raised:
search_engine_factory.create_search_engine(
"probe", settings_snapshot={"search.tool": "probe"}
)
assert raised.value is settings_error
assert len(constructions) == 1
def test_full_search_constructor_error_does_not_return_the_base_engine(
monkeypatch, settings_error
):
from local_deep_research.web_search_engines import search_engine_factory
class InvalidSettingsWrapper:
def __init__(self, settings_snapshot=None):
raise settings_error
monkeypatch.setattr(
search_engine_factory,
"get_safe_module_class",
lambda *args: InvalidSettingsWrapper,
)
with pytest.raises(SettingsValueError) as raised:
search_engine_factory._create_full_search_wrapper(
"probe",
base_engine=object(),
engine_config={
"full_search_module": ".probe",
"full_search_class": "Probe",
},
llm=None,
params={},
settings_snapshot={"present": True},
)
assert raised.value is settings_error
@pytest.mark.parametrize(
"invalid_key",
[
"search.cross_engine_max_results",
"search.cross_engine_max_context_items",
],
)
def test_filter_does_not_replace_invalid_settings_with_limits(
monkeypatch, settings_error, invalid_key
):
from local_deep_research.advanced_search_system.filters.cross_engine_filter import (
CrossEngineFilter,
)
from local_deep_research.config import thread_settings
def read(key, default=None, **kwargs):
if key == invalid_key:
raise settings_error
return default
monkeypatch.setattr(thread_settings, "get_setting_from_snapshot", read)
with pytest.raises(SettingsValueError) as raised:
CrossEngineFilter(model=Mock(), settings_snapshot={"present": True})
assert raised.value is settings_error
@pytest.mark.parametrize("allow_default_settings", [False, True])
def test_api_default_opt_in_does_not_waive_invalid_configuration(
monkeypatch, settings_error, allow_default_settings
):
from local_deep_research.web.routers import api_v1
manager = Mock()
manager.get_settings_snapshot.side_effect = settings_error
monkeypatch.setattr(
api_v1, "get_user_db_session", lambda *args: nullcontext(object())
)
monkeypatch.setattr(api_v1, "get_settings_manager", lambda *args: manager)
params = {}
refused = api_v1._load_user_context_into_params(
params, "alice", allow_default_settings=allow_default_settings
)
# Refused with the repair diagnostic instead of the app-wide generic
# 500, and before the opt-in branch could run with an empty snapshot.
assert "settings_snapshot" not in params
assert refused is not None and refused.status_code == 503
body = json.loads(refused.body)
assert body["reason"] == "invalid_setting"
assert str(settings_error) in body["error"]
assert "allow_default_settings does not bypass" in body["how_to_fix"]
def test_benchmark_fails_without_launching_a_worker_for_invalid_settings(
monkeypatch, settings_error
):
from local_deep_research import settings
from local_deep_research.benchmarks.web_api import benchmark_service
from local_deep_research.database import session_context
run = SimpleNamespace(
id=1,
status=None,
error_message=None,
config_hash="test-config",
datasets_config={},
search_config={},
evaluation_config={},
)
session = Mock()
session.query.return_value.filter.return_value.first.return_value = run
monkeypatch.setattr(
session_context,
"get_user_db_session",
lambda *args: nullcontext(session),
)
manager = Mock()
manager.get_all_settings.side_effect = settings_error
monkeypatch.setattr(settings, "SettingsManager", lambda *args: manager)
monkeypatch.setattr(
"local_deep_research.utilities.request_context.get_current_session_id",
lambda: None,
)
thread = Mock()
monkeypatch.setattr(benchmark_service.threading, "Thread", thread)
service = benchmark_service.BenchmarkService(socket_service=Mock())
assert service.start_benchmark(1, username="alice") is False
assert run.status == benchmark_service.BenchmarkStatus.FAILED
assert run.error_message == str(settings_error)
assert service.active_runs == {}
thread.assert_not_called()
def test_scheduler_does_not_cache_or_return_default_configuration(
monkeypatch, settings_error
):
from local_deep_research.database import session_context
from local_deep_research.scheduler.background import BackgroundJobScheduler
from local_deep_research.settings import manager as settings_manager
scheduler = object.__new__(BackgroundJobScheduler)
scheduler._settings_cache_lock = RLock()
scheduler._settings_cache = {}
scheduler.user_sessions = {"alice": {"active": True}}
scheduler._credential_store = Mock()
scheduler._credential_store.retrieve.return_value = "test-password"
monkeypatch.setattr(
session_context,
"get_user_db_session",
lambda *args: nullcontext(object()),
)
manager = Mock()
manager.get_setting.side_effect = settings_error
monkeypatch.setattr(
settings_manager, "SettingsManager", lambda *args: manager
)
with pytest.raises(SettingsValueError) as raised:
scheduler._get_document_scheduler_settings("alice")
assert raised.value is settings_error
assert scheduler._settings_cache == {}
def test_stream_usage_error_does_not_use_model_capability(
monkeypatch, settings_error
):
from local_deep_research.config import thread_settings
from local_deep_research.config.llm_config import ProcessingLLMWrapper
reader = Mock(side_effect=settings_error)
monkeypatch.setattr(thread_settings, "get_setting_from_snapshot", reader)
wrapper = ProcessingLLMWrapper(
SimpleNamespace(disable_streaming=False, stream_usage=True),
provider="openai_endpoint",
settings_snapshot={"present": True},
)
with pytest.raises(SettingsValueError) as raised:
wrapper._stream_cancel_allowed()
assert raised.value is settings_error
def test_absent_optional_filter_settings_still_use_documented_defaults():
from local_deep_research.advanced_search_system.filters.cross_engine_filter import (
CrossEngineFilter,
)
filtering = CrossEngineFilter(model=Mock(), settings_snapshot={})
assert filtering.max_results == 100
assert filtering.max_context_items == 30