~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(search): route search settings from snapshot and fix citation fallback (#6489) (#6490)
S2a37bafafa65
diff --git a/changelog.d/6489.bugfix.md b/changelog.d/6489.bugfix.mdnew file mode 100644index 0000000000..ebd5f1e490--- /dev/null+++ b/changelog.d/6489.bugfix.md@@ -0,0 +1 @@+Fix propagation of `search.snippets_only`, `search.max_filtered_results`, `search.region`, `search.safe_search`, and `search.search_language` when search engines are instantiated directly via `create_search_engine` (such as in autonomous agent tools and MCP). Default `search_snippets_only` to `None` in `get_search()` so callers that omit it do not silently override engine defaults. Fix `BaseCitationHandler` document generation to fall back to snippet when `full_content` is `None`. Fix `SourceBasedSearchStrategy` to toggle `search_snippets_only` when toggling `include_text_content`, ensuring topic-organization sub-searches genuinely force snippets-only on unwrapped search engines.diff --git a/src/local_deep_research/advanced_search_system/strategies/source_based_strategy.py b/src/local_deep_research/advanced_search_system/strategies/source_based_strategy.pyindex d05d45cff2..182ed41429 100644--- a/src/local_deep_research/advanced_search_system/strategies/source_based_strategy.py+++ b/src/local_deep_research/advanced_search_system/strategies/source_based_strategy.py@@ -8,6 +8,7 @@ from ...citation_handler import CitationHandler# Removed get_db_setting import - using settings_snapshot insteadfrom ...security.log_sanitizer import sanitize_error_for_clientfrom ...security import scrub_error+from ...utilities.type_utils import resolve_snippets_onlyfrom ...utilities.thread_context import (preserve_research_context,get_search_context,@@ -67,7 +68,7 @@ class SourceBasedSearchStrategy(BaseSearchStrategy):search,model,citation_handler=None,- include_text_content: bool = True,+ include_text_content: bool | None = None,use_cross_engine_filter: bool = True,filter_reorder: bool = True,filter_reindex: bool = True,@@ -84,7 +85,8 @@ class SourceBasedSearchStrategy(BaseSearchStrategy):model: LLM instance for question generation, filtering, and synthesiscitation_handler: Handles citation formatting in synthesized content.If None, a default CitationHandler is created.- include_text_content: Whether to fetch full page content (not just snippets)+ include_text_content: Whether to fetch full page content (not just snippets).+ Defaults to None (defers to settings_snapshot or search engine default).use_cross_engine_filter: Whether to apply LLM-based relevance filteringafter all iterations. When True, the filter may reduce result countsignificantly (e.g. 60 → 10). When False, all accumulated results pass through.@@ -110,7 +112,22 @@ class SourceBasedSearchStrategy(BaseSearchStrategy):self.search = search# Note: progress_callback and questions_by_iteration are already set by parent class- self.include_text_content = include_text_content+ # Resolve include_text_content:+ # 1. Explicit caller argument wins (when not None).+ # 2. Defer to search.snippets_only in settings_snapshot if present (fail-closed).+ # 3. Defer to existing search engine snippet setting if present.+ # 4. Default to True.+ if include_text_content is not None:+ self.include_text_content = include_text_content+ elif (+ resolved_snippets := resolve_snippets_only(settings_snapshot)+ ) is not None:+ self.include_text_content = not resolved_snippets+ elif hasattr(self.search, "search_snippets_only"):+ self.include_text_content = not self.search.search_snippets_only+ else:+ self.include_text_content = True+self.use_cross_engine_filter = use_cross_engine_filterself.filter_reorder = filter_reorderself.filter_reindex = filter_reindex@@ -125,7 +142,9 @@ class SourceBasedSearchStrategy(BaseSearchStrategy):# Set include_full_content on the search engine if it supports itif hasattr(self.search, "include_full_content"):- self.search.include_full_content = include_text_content+ self.search.include_full_content = self.include_text_content+ if hasattr(self.search, "search_snippets_only"):+ self.search.search_snippets_only = not self.include_text_content# Use provided citation_handler or create defaultself.citation_handler = citation_handler or CitationHandler(diff --git a/src/local_deep_research/citation_handlers/base_citation_handler.py b/src/local_deep_research/citation_handlers/base_citation_handler.pyindex 3601953a95..90a0edc8e4 100644--- a/src/local_deep_research/citation_handlers/base_citation_handler.py+++ b/src/local_deep_research/citation_handlers/base_citation_handler.py@@ -354,7 +354,9 @@ class BaseCitationHandler(ABC):if "index" not in result:result["index"] = str(i + nr_of_links + 1)- content = result.get("full_content", result.get("snippet", ""))+ content = result.get("full_content")+ if not content:+ content = result.get("snippet", "")# Use the index from the result if it exists, otherwise calculate itdoc_index = int(result.get("index", i + nr_of_links + 1))documents.append(diff --git a/src/local_deep_research/mcp/server.py b/src/local_deep_research/mcp/server.pyindex 694440d9e3..c741daa7b3 100644--- a/src/local_deep_research/mcp/server.py+++ b/src/local_deep_research/mcp/server.py@@ -839,7 +839,6 @@ def _execute_search(settings_snapshot=settings,programmatic_mode=True,max_results=max_results,- search_snippets_only=True,)if search_engine is None:diff --git a/src/local_deep_research/search_system.py b/src/local_deep_research/search_system.pyindex 013bd0241a..2a94f0ed8c 100644--- a/src/local_deep_research/search_system.py+++ b/src/local_deep_research/search_system.py@@ -76,7 +76,7 @@ class AdvancedSearchSystem:llm: BaseChatModel,search: BaseSearchEngine,strategy_name: str = "source-based", # Default to comprehensive research strategy- include_text_content: bool = True,+ include_text_content: bool | None = None,use_cross_engine_filter: bool = True,max_iterations: int | None = None,questions_per_iteration: int | None = None,diff --git a/src/local_deep_research/search_system_factory.py b/src/local_deep_research/search_system_factory.pyindex 58d6e50ea5..3390f93b2f 100644--- a/src/local_deep_research/search_system_factory.py+++ b/src/local_deep_research/search_system_factory.py@@ -69,7 +69,7 @@ def create_strategy(return SourceBasedSearchStrategy(model=model,search=search,- include_text_content=kwargs.get("include_text_content", True),+ include_text_content=kwargs.get("include_text_content"),use_cross_engine_filter=kwargs.get("use_cross_engine_filter", True),all_links_of_system=all_links_of_system,use_atomic_facts=kwargs.get("use_atomic_facts", False),@@ -393,7 +393,7 @@ def create_strategy(return SourceBasedSearchStrategy(model=model,search=search,- include_text_content=True,+ include_text_content=kwargs.get("include_text_content", True),use_cross_engine_filter=True,all_links_of_system=all_links_of_system,use_atomic_facts=False,diff --git a/src/local_deep_research/utilities/type_utils.py b/src/local_deep_research/utilities/type_utils.pyindex 1869db286a..a4a18e60d9 100644--- a/src/local_deep_research/utilities/type_utils.py+++ b/src/local_deep_research/utilities/type_utils.py@@ -6,7 +6,7 @@ the codebase. It is intentionally kept free of internal dependencies toavoid circular import issues."""-from typing import Any+from typing import Any, Dict, Optionaldef to_bool(value: Any, default: bool = False) -> bool:@@ -78,3 +78,36 @@ def unwrap_setting(val: Any) -> Any:if isinstance(val, dict) and "value" in val:return val["value"]return val+++def resolve_snippets_only(+ settings_snapshot: Optional[Dict[str, Any]],+) -> Optional[bool]:+ """Resolve boolean ``search.snippets_only`` from settings snapshot.++ Handles boolean values, dictionary settings envelopes (``{"value": ...}``),+ string encodings ("true"/"false"/"1"/"0"/"yes"/"no"/"on"/"off"), and+ returns None when the setting is absent or unset.++ Fails closed: unrecognized or corrupt values resolve to True (snippets-only)+ so that network-fetching full content is never inadvertently enabled.+ """+ if not settings_snapshot or "search.snippets_only" not in settings_snapshot:+ return None+ raw = settings_snapshot["search.snippets_only"]+ if isinstance(raw, dict):+ raw = raw.get("value")+ if raw is None:+ return None+ if isinstance(raw, bool):+ return raw+ if isinstance(raw, str):+ val = raw.strip().lower()+ if val in ("false", "0", "off", "no"):+ return False+ if val in ("true", "1", "on", "yes"):+ return True+ return True+ if isinstance(raw, (int, float)):+ return bool(raw)+ return Truediff --git a/src/local_deep_research/web_search_engines/engines/search_engine_searxng.py b/src/local_deep_research/web_search_engines/engines/search_engine_searxng.pyindex 72557323b0..48c48a80f8 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_searxng.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_searxng.py@@ -167,6 +167,7 @@ class SearXNGSearchEngine(BaseSearchEngine):max_filtered_results: Optional[int] = None,include_full_content: bool = True,settings_snapshot: Optional[Dict[str, Any]] = None,+ search_snippets_only: bool = True,**kwargs,): # API key is actually the instance URL"""@@ -188,6 +189,7 @@ class SearXNGSearchEngine(BaseSearchEngine):max_filtered_results: Maximum number of results to keep after filteringinclude_full_content: Retained for backward compatibility; full-contentretrieval is handled via the factory wrapper.+ search_snippets_only: Whether to return only search snippets"""# Initialize the BaseSearchEngine with LLM, max_filtered_results, and max_results@@ -197,7 +199,8 @@ class SearXNGSearchEngine(BaseSearchEngine):max_results=max_results,include_full_content=include_full_content,settings_snapshot=settings_snapshot,- **kwargs, # Pass through all other kwargs including search_snippets_only+ search_snippets_only=search_snippets_only,+ **kwargs,)# Validate and normalize the instance URL if provideddiff --git a/src/local_deep_research/web_search_engines/search_engine_factory.py b/src/local_deep_research/web_search_engines/search_engine_factory.pyindex e4879f74ea..24f9096b32 100644--- a/src/local_deep_research/web_search_engines/search_engine_factory.py+++ b/src/local_deep_research/web_search_engines/search_engine_factory.py@@ -7,6 +7,8 @@ from ..security.module_whitelist import get_safe_module_classfrom ..security.secure_logging import loggerfrom .engine_groups import is_collection_enginefrom .retriever_registry import retriever_registry+from ..utilities.search_utilities import LANGUAGE_CODE_MAP+from ..utilities.type_utils import resolve_snippets_only, to_boolfrom .search_engine_base import BaseSearchEnginefrom .search_engines_config import search_config@@ -16,32 +18,115 @@ from .search_engines_config import search_config# (langgraph-agent strategy tools, MCP server) honor the setting too.TIME_PERIOD_ENGINES = ("serpapi", "tavily", "wikinews")+# Non-geographic region sentinels that should not be mapped to provider `location`+_NON_LOCATION_REGIONS = frozenset({"wt-wt", "all", "none", "worldwide", ""})++# Engines that accept a language code (ISO 639-1) in their ``language`` parameter.+# Engines like OpenLibrary (MARC code or None) or Wayback/DDG (language name+# for Justext) are excluded so that global language settings do not corrupt them.+LANGUAGE_CODE_ENGINES = frozenset(+ {"searxng", "mojeek", "wikipedia", "tinyfish", "scaleserp"}+)++# Engines that accept a language code (Google hl code) in their ``search_language`` parameter.+# Engines like Brave, Google PSE, SerpAPI, Wikinews expect the language name ("English").+SEARCH_LANGUAGE_CODE_ENGINES = frozenset({"serper"})++# Engines that accept an ISO country code in their ``location`` parameter.+# ScaleSerp expects a free-text place name ("United States") and is excluded.+LOCATION_CODE_ENGINES = frozenset({"tinyfish"})++# Parameters forwarded to BaseSearchEngine or accepted across multiple engines+_BASE_FORWARDED_PARAMS = frozenset(+ {+ "search_snippets_only",+ "max_filtered_results",+ "max_results",+ "safe_search",+ "region",+ "location",+ "search_language",+ "language",+ "time_period",+ "include_full_content",+ }+)+++def _resolve_setting(+ snapshot: Optional[Dict[str, Any]],+ key: str,+ default: Any = None,+) -> Any:+ """Safely extract a setting value from settings_snapshot (dict or scalar)."""+ if not snapshot or key not in snapshot:+ return default+ raw = snapshot[key]+ val = raw.get("value", default) if isinstance(raw, dict) else raw+ return default if val is None else val+++def _normalize_language_code(language: str) -> Optional[str]:+ """Normalize a language name or code to an ISO 639-1 code.++ Returns None if the language name is unknown and cannot be converted to a valid code.+ """+ if not language:+ return None+ lang_clean = language.strip().lower()+ if lang_clean in LANGUAGE_CODE_MAP:+ return LANGUAGE_CODE_MAP[lang_clean]+ # Pass through values that already look like ISO language codes (len <= 3 and alpha)+ if len(lang_clean) <= 3 and lang_clean.isalpha():+ return lang_clean+ return None-def _resolve_snippets_only(- settings_snapshot: Optional[Dict[str, Any]],-) -> Optional[bool]:- """Resolve boolean ``search.snippets_only`` from settings snapshot.- Handles boolean values, dictionary settings envelopes (``{"value": ...}``),- string encodings ("true"/"false"/"1"/"0"/"yes"/"no"/"on"/"off"), and- returns None when the setting is absent or unset.+def _to_extraction_language_name(value: Any) -> Optional[str]:+ """Convert a language name or ISO code to a justext stoplist name.++ ``justext.get_stoplist`` expects names like ``English`` / ``German``,+ not provider codes like ``en`` / ``de``."""- if not settings_snapshot or "search.snippets_only" not in settings_snapshot:+ if not isinstance(value, str):+ return None+ cleaned = value.strip()+ if not cleaned:return None- raw = settings_snapshot["search.snippets_only"]- if isinstance(raw, dict):- raw = raw.get("value")- if raw is None:+ lower = cleaned.lower()+ if lower in LANGUAGE_CODE_MAP:+ return lower.capitalize()+ for name, code in LANGUAGE_CODE_MAP.items():+ if code == lower:+ return name.capitalize()+ if len(cleaned) <= 3 and cleaned.isalpha():return None- if isinstance(raw, bool):- return raw- if isinstance(raw, str):- val = raw.strip().lower()- if val in ("false", "0", "off", "no"):- return False- if val in ("true", "1", "on", "yes"):- return True- return bool(raw)+ return cleaned+++def _resolve_extraction_language(+ params: Dict[str, Any],+ settings_snapshot: Optional[Dict[str, Any]],+) -> Optional[str]:+ """Resolve justext extraction language separately from provider codes."""+ candidates: list[Any] = []+ if "search_language" in params:+ candidates.append(params.get("search_language"))+ snapshot_lang = _resolve_setting(+ settings_snapshot, "search.search_language"+ )+ if snapshot_lang is not None:+ candidates.append(snapshot_lang)+ if "language" in params:+ candidates.append(params.get("language"))+ for candidate in candidates:+ converted = _to_extraction_language_name(candidate)+ if converted:+ return converted+ return None+++_resolve_snippets_only = resolve_snippets_onlydef create_search_engine(@@ -289,15 +374,18 @@ def create_search_engine(# Get engine configurationengine_config = config[engine_name]+ default_params = engine_config.get("default_params", {}) or {}# Set default max_results from config if not provided in kwargsif "max_results" not in kwargs:- if settings_snapshot and "search.max_results" in settings_snapshot:- max_results = (- settings_snapshot["search.max_results"].get("value", 20)- if isinstance(settings_snapshot["search.max_results"], dict)- else settings_snapshot["search.max_results"]+ if settings_snapshot:+ raw_mr = _resolve_setting(+ settings_snapshot, "search.max_results", 20)+ try:+ max_results = int(raw_mr)+ except (ValueError, TypeError):+ max_results = 20else:max_results = 20kwargs["max_results"] = max_results@@ -315,12 +403,11 @@ def create_search_engine(and settings_snapshotand "search.time_period" in settings_snapshot):- raw_time_period = settings_snapshot["search.time_period"]- kwargs["time_period"] = (- raw_time_period.get("value", "all")- if isinstance(raw_time_period, dict)- else raw_time_period+ raw_time_period = _resolve_setting(+ settings_snapshot, "search.time_period", "all")+ if raw_time_period is not None:+ kwargs["time_period"] = str(raw_time_period)# Route search.snippets_only to engines when the caller didn't pass one# explicitly. get_search() forwards it as a kwarg, but direct callers@@ -342,6 +429,100 @@ def create_search_engine(if "use_full_search" not in kwargs and "search_snippets_only" in kwargs:kwargs["use_full_search"] = not kwargs["search_snippets_only"]+ # Route search.max_filtered_results to engines when not explicitly passed.+ if "max_filtered_results" not in kwargs and settings_snapshot:+ raw_mfr = _resolve_setting(+ settings_snapshot, "search.max_filtered_results"+ )+ if raw_mfr is not None:+ try:+ kwargs["max_filtered_results"] = int(raw_mfr)+ except (ValueError, TypeError):+ pass++ # Route search.region to engines when not explicitly passed.+ if "region" not in kwargs and settings_snapshot:+ val_region = _resolve_setting(settings_snapshot, "search.region")+ if val_region is not None:+ kwargs["region"] = str(val_region)++ # Route region -> location alias when location is not explicitly passed.+ # Exclude non-country sentinels like 'wt-wt' / 'all' to avoid invalid location values.+ # Only alias for engines whose location parameter expects an ISO country code.+ if (+ "location" not in kwargs+ and "location" not in default_params+ and engine_name in LOCATION_CODE_ENGINES+ ):+ effective_region = kwargs.get("region")+ if (+ not effective_region+ and settings_snapshot+ and "search.region" in settings_snapshot+ ):+ effective_region = _resolve_setting(+ settings_snapshot, "search.region"+ )+ if (+ effective_region+ and isinstance(effective_region, str)+ and effective_region.lower() not in _NON_LOCATION_REGIONS+ and len(effective_region.strip()) == 2+ and effective_region.strip().isalpha()+ ):+ kwargs["location"] = effective_region.strip().upper()++ # Route search.safe_search to engines when not explicitly passed.+ # Do not override a key the engine's default_params defines (e.g. SearXNG).+ if (+ "safe_search" not in kwargs+ and "safe_search" not in default_params+ and settings_snapshot+ and "search.safe_search" in settings_snapshot+ ):+ raw_safe = _resolve_setting(settings_snapshot, "search.safe_search")+ if raw_safe is not None:+ kwargs["safe_search"] = to_bool(raw_safe, default=True)++ # Route search.search_language to engines when not explicitly passed.+ # Only inject when actually present in snapshot (no hardcoded default),+ # and do not override a key the engine's default_params defines.+ # For Serper, normalize to Google hl code; for other engines, pass language name.+ if (+ "search_language" not in kwargs+ and "search_language" not in default_params+ and settings_snapshot+ and "search.search_language" in settings_snapshot+ ):+ val_lang = _resolve_setting(settings_snapshot, "search.search_language")+ if val_lang is not None:+ if engine_name in SEARCH_LANGUAGE_CODE_ENGINES:+ norm_code = _normalize_language_code(str(val_lang))+ if norm_code:+ kwargs["search_language"] = norm_code+ else:+ kwargs["search_language"] = str(val_lang)++ # Route language code (ISO 639-1) for engines expecting code in 'language' param.+ # Only alias when not defined in default_params, and only for engines whose parameter is a code.+ if (+ "language" not in kwargs+ and "language" not in default_params+ and engine_name in LANGUAGE_CODE_ENGINES+ ):+ lang_source = kwargs.get("search_language")+ if (+ not lang_source+ and settings_snapshot+ and "search.search_language" in settings_snapshot+ ):+ lang_source = _resolve_setting(+ settings_snapshot, "search.search_language"+ )+ if lang_source and isinstance(lang_source, str):+ norm_code = _normalize_language_code(lang_source)+ if norm_code:+ kwargs["language"] = norm_code# Check for API key requirementsrequires_api_key = engine_config.get("requires_api_key", False)@@ -398,15 +579,25 @@ def create_search_engine(# Get the engine class's __init__ parameters to filter out unsupported onesengine_init_signature = inspect.signature(engine_class.__init__)engine_init_params = list(engine_init_signature.parameters.keys())+ has_var_keyword = any(+ p.kind == inspect.Parameter.VAR_KEYWORD+ for p in engine_init_signature.parameters.values()+ )# Combine default parameters with provided onesall_params = {**engine_config.get("default_params", {}), **kwargs}# Filter out parameters that aren't accepted by the engine class- # Note: 'self' is always the first parameter of instance methods, so we skip it+ # Note: 'self' is always the first parameter of instance methods, so we skip it.+ # If the class accepts **kwargs, parameters handled by BaseSearchEngine or+ # common wrappers are preserved.filtered_params = {k: v for k, v in all_params.items() if k in engine_init_params[1:]}+ if has_var_keyword:+ for k in _BASE_FORWARDED_PARAMS:+ if k in all_params and k not in filtered_params:+ filtered_params[k] = all_params[k]# Always pass settings_snapshot if the engine accepts itif "settings_snapshot" in engine_init_params[1:] and settings_snapshot:@@ -703,6 +894,18 @@ def _create_full_search_wrapper("moderate" if params["safe_search"] else "off")+ # FullSearchResults.language is a justext stoplist name, not a+ # provider ISO code. LANGUAGE_CODE_ENGINES share kwargs with the+ # wrapper, so remap (or drop) before construction.+ if "language" in wrapper_init_params:+ extraction_language = _resolve_extraction_language(+ params, settings_snapshot+ )+ if extraction_language:+ wrapper_params["language"] = extraction_language+ else:+ wrapper_params.pop("language", None)+# Always include llm if it's a parameterif "llm" in wrapper_init_params:wrapper_params["llm"] = llm@@ -814,8 +1017,16 @@ def get_search(params["search_language"] = search_languageif search_tool == "tinyfish":- params["location"] = region.upper()- params["language"] = search_language+ if (+ region+ and region.lower() not in _NON_LOCATION_REGIONS+ and len(region.strip()) == 2+ and region.strip().isalpha()+ ):+ params["location"] = region.strip().upper()+ norm_lang = _normalize_language_code(search_language)+ if norm_lang:+ params["language"] = norm_langif search_tool == "sofya":# Sofya derives its request depth from search_snippets_only: the paiddiff --git a/tests/citation_handlers/test_base_citation_handler.py b/tests/citation_handlers/test_base_citation_handler.pyindex 3993a64b24..0f07c00684 100644--- a/tests/citation_handlers/test_base_citation_handler.py+++ b/tests/citation_handlers/test_base_citation_handler.py@@ -354,6 +354,24 @@ class TestCreateDocuments:== "This is the full content which is much longer")+ def test_falls_back_to_snippet_when_full_content_is_none(self):+ """Test falls back to snippet when full_content is explicitly None (#6489)."""+ mock_llm = MagicMock()+ handler = ConcreteCitationHandler(mock_llm)++ search_results = [+ {+ "link": "https://example.com",+ "title": "Result",+ "snippet": "Fallback snippet",+ "full_content": None,+ }+ ]++ docs = handler._create_documents(search_results)++ assert docs[0].page_content == "Fallback snippet"+def test_handles_empty_list(self):"""Test handles empty search results list."""mock_llm = MagicMock()diff --git a/tests/strategies/test_langgraph_agent_strategy.py b/tests/strategies/test_langgraph_agent_strategy.pyindex 3876a89447..033ae76c8e 100644--- a/tests/strategies/test_langgraph_agent_strategy.py+++ b/tests/strategies/test_langgraph_agent_strategy.py@@ -1567,6 +1567,36 @@ class TestSearchToolMakers:assert collector.results[0]["index"] == "1"assert collector.results[0]["source_engine"] == "arxiv"+ def test_make_web_search_tool_forwards_settings_snapshot_to_create_search_engine(+ self,+ ):+ from unittest.mock import MagicMock, patch+ from local_deep_research.advanced_search_system.strategies.langgraph_agent_strategy import (+ SearchResultsCollector,+ _make_web_search_tool,+ )++ mock_engine = MagicMock()+ mock_engine.run.return_value = []+ collector = SearchResultsCollector()+ snapshot = {"search.snippets_only": {"value": False}}++ with patch(+ "local_deep_research.web_search_engines.search_engine_factory.create_search_engine",+ return_value=mock_engine,+ ) as mock_create:+ tool_fn = _make_web_search_tool(+ search_engine_name="duckduckgo",+ model=MagicMock(),+ settings_snapshot=snapshot,+ collector=collector,+ )+ tool_fn.invoke({"query": "test query"})++ mock_create.assert_called_once()+ _, call_kwargs = mock_create.call_args+ assert call_kwargs["settings_snapshot"] == snapshot+# ---------------------------------------------------------------------------# Format results helperdiff --git a/tests/strategies/test_strategy_instantiation.py b/tests/strategies/test_strategy_instantiation.pyindex 0333a5528c..903e240959 100644--- a/tests/strategies/test_strategy_instantiation.py+++ b/tests/strategies/test_strategy_instantiation.py@@ -329,3 +329,150 @@ class TestSharedLinksIsolation:assert (strategy1.all_links_of_system is not strategy2.all_links_of_system)+++class TestSourceBasedStrategySnippetsOnly:+ """Test SourceBasedSearchStrategy propagation of include_text_content to search_snippets_only (#6489)."""++ def test_include_text_content_updates_search_snippets_only(+ self, strategy_mock_llm, strategy_settings_snapshot+ ):+ from unittest.mock import MagicMock+ from local_deep_research.advanced_search_system.strategies.source_based_strategy import (+ SourceBasedSearchStrategy,+ )++ mock_search = MagicMock()+ mock_search.include_full_content = False+ mock_search.search_snippets_only = True++ SourceBasedSearchStrategy(+ model=strategy_mock_llm,+ search=mock_search,+ settings_snapshot=strategy_settings_snapshot,+ include_text_content=True,+ )++ assert mock_search.include_full_content is True+ assert mock_search.search_snippets_only is False++ def test_exclude_text_content_keeps_search_snippets_only(+ self, strategy_mock_llm, strategy_settings_snapshot+ ):+ from unittest.mock import MagicMock+ from local_deep_research.advanced_search_system.strategies.source_based_strategy import (+ SourceBasedSearchStrategy,+ )++ mock_search = MagicMock()+ mock_search.include_full_content = True+ mock_search.search_snippets_only = False++ SourceBasedSearchStrategy(+ model=strategy_mock_llm,+ search=mock_search,+ settings_snapshot=strategy_settings_snapshot,+ include_text_content=False,+ )++ assert mock_search.include_full_content is False+ assert mock_search.search_snippets_only is True++ def test_omitted_include_text_content_defers_to_snapshot_snippets_only(+ self, strategy_mock_llm+ ):+ """When include_text_content is omitted, settings_snapshot search.snippets_only is respected."""+ from unittest.mock import MagicMock+ from local_deep_research.advanced_search_system.strategies.source_based_strategy import (+ SourceBasedSearchStrategy,+ )++ mock_search = MagicMock()+ mock_search.include_full_content = True+ mock_search.search_snippets_only = False++ snapshot = {"search.snippets_only": {"value": True}}++ strat = SourceBasedSearchStrategy(+ model=strategy_mock_llm,+ search=mock_search,+ settings_snapshot=snapshot,+ )++ assert strat.include_text_content is False+ assert mock_search.include_full_content is False+ assert mock_search.search_snippets_only is True++ def test_omitted_include_text_content_defers_to_engine_snippets_only(+ self, strategy_mock_llm+ ):+ """When include_text_content and snapshot key are omitted, existing engine setting is preserved."""+ from unittest.mock import MagicMock+ from local_deep_research.advanced_search_system.strategies.source_based_strategy import (+ SourceBasedSearchStrategy,+ )++ mock_search = MagicMock()+ mock_search.include_full_content = False+ mock_search.search_snippets_only = True++ strat = SourceBasedSearchStrategy(+ model=strategy_mock_llm,+ search=mock_search,+ settings_snapshot={},+ )++ assert strat.include_text_content is False+ assert mock_search.include_full_content is False+ assert mock_search.search_snippets_only is True++ @pytest.mark.parametrize("corrupt_value", ["maybe", "", "invalid", 123])+ def test_unrecognized_snapshot_snippets_only_fails_closed(+ self, strategy_mock_llm, corrupt_value+ ):+ """Unrecognized or corrupt search.snippets_only in snapshot fails closed to snippets-only."""+ from unittest.mock import MagicMock+ from local_deep_research.advanced_search_system.strategies.source_based_strategy import (+ SourceBasedSearchStrategy,+ )++ mock_search = MagicMock()+ mock_search.include_full_content = True+ mock_search.search_snippets_only = False++ snapshot = {"search.snippets_only": corrupt_value}++ strat = SourceBasedSearchStrategy(+ model=strategy_mock_llm,+ search=mock_search,+ settings_snapshot=snapshot,+ )++ assert strat.include_text_content is False+ assert mock_search.include_full_content is False+ assert mock_search.search_snippets_only is True++ def test_envelope_unrecognized_snapshot_snippets_only_fails_closed(+ self, strategy_mock_llm+ ):+ """Envelope with unrecognized value fails closed to snippets-only."""+ from unittest.mock import MagicMock+ from local_deep_research.advanced_search_system.strategies.source_based_strategy import (+ SourceBasedSearchStrategy,+ )++ mock_search = MagicMock()+ mock_search.include_full_content = True+ mock_search.search_snippets_only = False++ snapshot = {"search.snippets_only": {"value": "maybe"}}++ strat = SourceBasedSearchStrategy(+ model=strategy_mock_llm,+ search=mock_search,+ settings_snapshot=snapshot,+ )++ assert strat.include_text_content is False+ assert mock_search.include_full_content is False+ assert mock_search.search_snippets_only is Truediff --git a/tests/utilities/test_type_utils.py b/tests/utilities/test_type_utils.pyindex 2b8825c1ea..e276d50f16 100644--- a/tests/utilities/test_type_utils.py+++ b/tests/utilities/test_type_utils.py@@ -492,3 +492,74 @@ class TestToBoolEnvironmentVariableSimulation:# If someone accidentally includes quotes in the env var valueassert to_bool('"true"') is Falseassert to_bool("'true'") is False+++class TestResolveSnippetsOnly:+ """Tests for resolve_snippets_only in type_utils."""++ def test_direct_values(self):+ from local_deep_research.utilities.type_utils import (+ resolve_snippets_only,+ )++ assert resolve_snippets_only({"search.snippets_only": True}) is True+ assert resolve_snippets_only({"search.snippets_only": False}) is False+ assert resolve_snippets_only({"search.snippets_only": "true"}) is True+ assert resolve_snippets_only({"search.snippets_only": "false"}) is False+ assert resolve_snippets_only({"search.snippets_only": "1"}) is True+ assert resolve_snippets_only({"search.snippets_only": "0"}) is False+ assert resolve_snippets_only({"search.snippets_only": "yes"}) is True+ assert resolve_snippets_only({"search.snippets_only": "no"}) is False+ assert resolve_snippets_only({"search.snippets_only": "on"}) is True+ assert resolve_snippets_only({"search.snippets_only": "off"}) is False++ def test_envelope_values(self):+ from local_deep_research.utilities.type_utils import (+ resolve_snippets_only,+ )++ assert (+ resolve_snippets_only({"search.snippets_only": {"value": True}})+ is True+ )+ assert (+ resolve_snippets_only({"search.snippets_only": {"value": False}})+ is False+ )+ assert (+ resolve_snippets_only({"search.snippets_only": {"value": "false"}})+ is False+ )++ def test_none_or_missing(self):+ from local_deep_research.utilities.type_utils import (+ resolve_snippets_only,+ )++ assert resolve_snippets_only(None) is None+ assert resolve_snippets_only({}) is None+ assert resolve_snippets_only({"other": True}) is None+ assert resolve_snippets_only({"search.snippets_only": None}) is None+ assert (+ resolve_snippets_only({"search.snippets_only": {"value": None}})+ is None+ )++ def test_unrecognized_values_fail_closed_to_true(self):+ from local_deep_research.utilities.type_utils import (+ resolve_snippets_only,+ )++ # Unrecognized strings fail closed to snippets-only (True)+ assert resolve_snippets_only({"search.snippets_only": "maybe"}) is True+ assert resolve_snippets_only({"search.snippets_only": ""}) is True+ assert (+ resolve_snippets_only({"search.snippets_only": "invalid"}) is True+ )+ assert (+ resolve_snippets_only({"search.snippets_only": {"value": "maybe"}})+ is True+ )+ assert (+ resolve_snippets_only({"search.snippets_only": [1, 2, 3]}) is True+ )diff --git a/tests/web_search_engines/test_factory_full_search_wrapper.py b/tests/web_search_engines/test_factory_full_search_wrapper.pyindex 3cb08baa0e..5e175e3541 100644--- a/tests/web_search_engines/test_factory_full_search_wrapper.py+++ b/tests/web_search_engines/test_factory_full_search_wrapper.py@@ -221,6 +221,71 @@ class TestApiKeyExtraction:assert result.api_key is None+class TestWrapperExtractionLanguage:+ """Provider ISO codes must not be forwarded as justext language names."""++ def test_wrapper_uses_language_name_not_provider_code(+ self, base_engine, mock_llm+ ):+ engine_config = {+ "full_search_module": ".engines.full_search",+ "full_search_class": "FullSearchResults",+ }+ params = {+ "language": "de",+ "search_language": "German",+ "max_results": 10,+ }++ result = _create_full_search_wrapper(+ "searxng",+ base_engine,+ engine_config,+ mock_llm,+ params,+ settings_snapshot={"search.search_language": {"value": "German"}},+ )++ assert isinstance(result, FullSearchResults)+ assert result.language == "German"++ def test_wrapper_reverse_maps_iso_code_when_name_absent(+ self, base_engine, mock_llm+ ):+ engine_config = {+ "full_search_module": ".engines.full_search",+ "full_search_class": "FullSearchResults",+ }++ result = _create_full_search_wrapper(+ "searxng",+ base_engine,+ engine_config,+ mock_llm,+ {"language": "de", "max_results": 10},+ )++ assert isinstance(result, FullSearchResults)+ assert result.language == "German"++ def test_wrapper_drops_unknown_iso_code(self, base_engine, mock_llm):+ engine_config = {+ "full_search_module": ".engines.full_search",+ "full_search_class": "FullSearchResults",+ }++ result = _create_full_search_wrapper(+ "searxng",+ base_engine,+ engine_config,+ mock_llm,+ {"language": "xx", "max_results": 10},+ )++ assert isinstance(result, FullSearchResults)+ assert result.language == "English"++# ---------------------------------------------------------------------------# Tests: End-to-end get_search() FullSearchResults wrapper coverage (#5883)# ---------------------------------------------------------------------------@@ -236,6 +301,7 @@ class _MockBaseEngine(BaseSearchEngine):"""Mock search engine for testing factory routing without network calls."""def __init__(self, *args, **kwargs):+ self.language = kwargs.get("language")super().__init__(*args, **kwargs)def _get_previews(self, query: str):@@ -445,3 +511,25 @@ class TestRegistryFullSearchWrapperEndToEnd:)assert not isinstance(result, FullSearchResults)++ def test_searxng_keeps_provider_code_off_wrapper_language(self, mock_llm):+ settings_snapshot = {+ "search.tool": {"value": "searxng"},+ "search.snippets_only": {"value": False},+ "search.search_language": {"value": "German"},+ "search.engine.web.searxng.supports_full_search": {+ "value": True,+ "ui_element": "checkbox",+ },+ }++ result = create_search_engine(+ "searxng",+ llm=mock_llm,+ settings_snapshot=settings_snapshot,+ programmatic_mode=True,+ )++ assert isinstance(result, FullSearchResults)+ assert result.language == "German"+ assert result.web_search.language == "de"diff --git a/tests/web_search_engines/test_search_engine_factory.py b/tests/web_search_engines/test_search_engine_factory.pyindex b321d55894..fb3d0fc554 100644--- a/tests/web_search_engines/test_search_engine_factory.py+++ b/tests/web_search_engines/test_search_engine_factory.py@@ -265,6 +265,9 @@ class TestResolveSnippetsOnly:("0", False),("no", False),("off", False),+ ("maybe", True),+ ("", True),+ ("invalid", True),],)def test_direct_values(self, raw_value, expected):@@ -290,6 +293,7 @@ class TestResolveSnippetsOnly:("no", False),("on", True),("off", False),+ ("maybe", True),],)def test_envelope_values(self, raw_value, expected):@@ -1158,3 +1162,626 @@ class TestCreateEngineInstantiation:with pytest.raises(ValueError, match="search.tool='none'"):create_search_engine("none", settings_snapshot={"x": 1})++ def test_extracts_search_snippets_only_dict_from_settings_snapshot(self):+ """create_search_engine extracts search_snippets_only from dict settings snapshot."""+ from local_deep_research.web_search_engines.search_engine_factory import (+ create_search_engine,+ )++ EngCls = _make_engine_class("search_snippets_only")+ snapshot = {"search.snippets_only": {"value": False}}++ with (+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.retriever_registry"+ ) as mock_reg,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.search_config"+ ) as mock_sc,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.get_safe_module_class"+ ) as mock_gsmc,+ ):+ mock_reg.get.return_value = None+ mock_sc.return_value = {"eng": self._make_engine_config()}+ mock_gsmc.return_value = EngCls++ create_search_engine("eng", settings_snapshot=snapshot)++ assert EngCls._call_kwargs.get("search_snippets_only") is False++ def test_extracts_search_snippets_only_scalar_from_settings_snapshot(self):+ """create_search_engine extracts search_snippets_only from scalar bool settings snapshot."""+ from local_deep_research.web_search_engines.search_engine_factory import (+ create_search_engine,+ )++ EngCls = _make_engine_class("search_snippets_only")+ snapshot = {"search.snippets_only": False}++ with (+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.retriever_registry"+ ) as mock_reg,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.search_config"+ ) as mock_sc,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.get_safe_module_class"+ ) as mock_gsmc,+ ):+ mock_reg.get.return_value = None+ mock_sc.return_value = {"eng": self._make_engine_config()}+ mock_gsmc.return_value = EngCls++ create_search_engine("eng", settings_snapshot=snapshot)++ assert EngCls._call_kwargs.get("search_snippets_only") is False++ def test_explicit_search_snippets_only_overrides_snapshot(self):+ """Explicit kwarg search_snippets_only overrides settings_snapshot."""+ from local_deep_research.web_search_engines.search_engine_factory import (+ create_search_engine,+ )++ EngCls = _make_engine_class("search_snippets_only")+ snapshot = {"search.snippets_only": False}++ with (+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.retriever_registry"+ ) as mock_reg,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.search_config"+ ) as mock_sc,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.get_safe_module_class"+ ) as mock_gsmc,+ ):+ mock_reg.get.return_value = None+ mock_sc.return_value = {"eng": self._make_engine_config()}+ mock_gsmc.return_value = EngCls++ create_search_engine(+ "eng", settings_snapshot=snapshot, search_snippets_only=True+ )++ assert EngCls._call_kwargs.get("search_snippets_only") is True++ def test_extracts_max_filtered_results_from_settings_snapshot(self):+ """create_search_engine extracts max_filtered_results from settings snapshot."""+ from local_deep_research.web_search_engines.search_engine_factory import (+ create_search_engine,+ )++ EngCls = _make_engine_class("max_filtered_results")+ snapshot = {"search.max_filtered_results": {"value": 7}}++ with (+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.retriever_registry"+ ) as mock_reg,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.search_config"+ ) as mock_sc,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.get_safe_module_class"+ ) as mock_gsmc,+ ):+ mock_reg.get.return_value = None+ mock_sc.return_value = {"eng": self._make_engine_config()}+ mock_gsmc.return_value = EngCls++ create_search_engine("eng", settings_snapshot=snapshot)++ assert EngCls._call_kwargs.get("max_filtered_results") == 7++ def test_var_keyword_engine_receives_search_snippets_only(self):+ """Engines with **kwargs in __init__ preserve search_snippets_only."""+ import inspect as _inspect+ from local_deep_research.web_search_engines.search_engine_factory import (+ create_search_engine,+ )++ params = [+ _inspect.Parameter(+ "self", _inspect.Parameter.POSITIONAL_OR_KEYWORD+ ),+ _inspect.Parameter("kwargs", _inspect.Parameter.VAR_KEYWORD),+ ]++ class _VarKwEng:+ _call_kwargs = None++ def __init__(self, **kwargs):+ _VarKwEng._call_kwargs = kwargs++ _VarKwEng.__init__.__signature__ = _inspect.Signature(params)++ snapshot = {"search.snippets_only": False}++ with (+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.retriever_registry"+ ) as mock_reg,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.search_config"+ ) as mock_sc,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.get_safe_module_class"+ ) as mock_gsmc,+ ):+ mock_reg.get.return_value = None+ mock_sc.return_value = {"eng": self._make_engine_config()}+ mock_gsmc.return_value = _VarKwEng++ create_search_engine("eng", settings_snapshot=snapshot)++ assert _VarKwEng._call_kwargs.get("search_snippets_only") is False++ def test_extracts_region_and_location_from_settings_snapshot(self):+ """create_search_engine extracts region and maps to location for snapshot (#6489)."""+ from local_deep_research.web_search_engines.search_engine_factory import (+ create_search_engine,+ )++ EngRegion = _make_engine_class("region")+ EngLocation = _make_engine_class("location")+ snapshot = {"search.region": {"value": "fr"}}++ with (+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.retriever_registry"+ ) as mock_reg,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.search_config"+ ) as mock_sc,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.get_safe_module_class"+ ) as mock_gsmc,+ ):+ mock_reg.get.return_value = None+ mock_sc.return_value = {+ "eng": self._make_engine_config(),+ "tinyfish": self._make_engine_config(),+ "scaleserp": self._make_engine_config(),+ }++ mock_gsmc.return_value = EngRegion+ create_search_engine("eng", settings_snapshot=snapshot)+ assert EngRegion._call_kwargs.get("region") == "fr"++ # Engines expecting country code in location (tinyfish) receive the uppercase code+ mock_gsmc.return_value = EngLocation+ create_search_engine("tinyfish", settings_snapshot=snapshot)+ assert EngLocation._call_kwargs.get("location") == "FR"++ # Engines expecting place name in location (scaleserp) do NOT receive the alias+ create_search_engine("scaleserp", settings_snapshot=snapshot)+ assert "location" not in EngLocation._call_kwargs++ def test_extracts_safe_search_from_settings_snapshot(self):+ """create_search_engine extracts safe_search from snapshot (#6489)."""+ from local_deep_research.web_search_engines.search_engine_factory import (+ create_search_engine,+ )++ EngCls = _make_engine_class("safe_search")+ snapshot = {"search.safe_search": {"value": False}}++ with (+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.retriever_registry"+ ) as mock_reg,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.search_config"+ ) as mock_sc,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.get_safe_module_class"+ ) as mock_gsmc,+ ):+ mock_reg.get.return_value = None+ mock_sc.return_value = {"eng": self._make_engine_config()}+ mock_gsmc.return_value = EngCls++ create_search_engine("eng", settings_snapshot=snapshot)+ assert EngCls._call_kwargs.get("safe_search") is False++ def test_extracts_language_from_settings_snapshot(self):+ """create_search_engine extracts search_language and language from snapshot (#6489)."""+ from local_deep_research.web_search_engines.search_engine_factory import (+ create_search_engine,+ )++ EngSearchLang = _make_engine_class("search_language")+ EngLang = _make_engine_class("language")+ snapshot = {"search.search_language": {"value": "German"}}++ with (+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.retriever_registry"+ ) as mock_reg,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.search_config"+ ) as mock_sc,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.get_safe_module_class"+ ) as mock_gsmc,+ ):+ mock_reg.get.return_value = None+ mock_sc.return_value = {+ "eng": self._make_engine_config(),+ "wikipedia": self._make_engine_config(),+ "openlibrary": self._make_engine_config(),+ "serper": self._make_engine_config(),+ }++ mock_gsmc.return_value = EngSearchLang+ create_search_engine("eng", settings_snapshot=snapshot)+ assert EngSearchLang._call_kwargs.get("search_language") == "German"++ # Serper expects Google hl code, so search_language is normalized to code+ create_search_engine("serper", settings_snapshot=snapshot)+ assert EngSearchLang._call_kwargs.get("search_language") == "de"++ # Engine in LANGUAGE_CODE_ENGINES receives normalized language code+ mock_gsmc.return_value = EngLang+ create_search_engine("wikipedia", settings_snapshot=snapshot)+ assert EngLang._call_kwargs.get("language") == "de"++ # Engine NOT in LANGUAGE_CODE_ENGINES (e.g. OpenLibrary) does NOT receive language code+ create_search_engine("openlibrary", settings_snapshot=snapshot)+ assert "language" not in EngLang._call_kwargs++ def test_region_dict_without_value_key_does_not_inject_sentinel(self):+ """A dict-form search.region without 'value' key does not inject 'wt-wt' into kwargs."""+ from local_deep_research.web_search_engines.search_engine_factory import (+ create_search_engine,+ )++ EngRegion = _make_engine_class("region", "location")+ snapshot = {"search.region": {"invalid": "dict"}}++ with (+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.retriever_registry"+ ) as mock_reg,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.search_config"+ ) as mock_sc,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.get_safe_module_class"+ ) as mock_gsmc,+ ):+ mock_reg.get.return_value = None+ mock_sc.return_value = {"eng": self._make_engine_config()}+ mock_gsmc.return_value = EngRegion++ create_search_engine("eng", settings_snapshot=snapshot)+ assert "region" not in EngRegion._call_kwargs+ assert "location" not in EngRegion._call_kwargs++ def test_region_wt_wt_does_not_inject_invalid_location(self):+ """DuckDuckGo's 'wt-wt' sentinel does not inject location='WT-WT' into location engines."""+ from local_deep_research.web_search_engines.search_engine_factory import (+ create_search_engine,+ )++ EngRegion = _make_engine_class("region")+ EngLocation = _make_engine_class("location")+ snapshot = {"search.region": {"value": "wt-wt"}}++ with (+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.retriever_registry"+ ) as mock_reg,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.search_config"+ ) as mock_sc,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.get_safe_module_class"+ ) as mock_gsmc,+ ):+ mock_reg.get.return_value = None+ mock_sc.return_value = {"eng": self._make_engine_config()}++ mock_gsmc.return_value = EngRegion+ create_search_engine("eng", settings_snapshot=snapshot)+ assert EngRegion._call_kwargs.get("region") == "wt-wt"++ mock_gsmc.return_value = EngLocation+ create_search_engine("eng", settings_snapshot=snapshot)+ assert "location" not in EngLocation._call_kwargs++ def test_var_keyword_engine_preserves_base_forwarded_params(self):+ """Engines accepting **kwargs preserve all base parameters, not just snippets_only."""+ import inspect as _inspect+ from local_deep_research.web_search_engines.search_engine_factory import (+ create_search_engine,+ )++ params = [+ _inspect.Parameter(+ "self", _inspect.Parameter.POSITIONAL_OR_KEYWORD+ ),+ _inspect.Parameter("kwargs", _inspect.Parameter.VAR_KEYWORD),+ ]++ class _VarKwEng:+ _call_kwargs = None++ def __init__(self, **kwargs):+ _VarKwEng._call_kwargs = kwargs++ _VarKwEng.__init__.__signature__ = _inspect.Signature(params)++ snapshot = {+ "search.snippets_only": False,+ "search.max_filtered_results": {"value": 15},+ "search.safe_search": {"value": False},+ "search.region": {"value": "fr"},+ "search.search_language": {"value": "French"},+ }++ with (+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.retriever_registry"+ ) as mock_reg,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.search_config"+ ) as mock_sc,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.get_safe_module_class"+ ) as mock_gsmc,+ ):+ mock_reg.get.return_value = None+ mock_sc.return_value = {"tinyfish": self._make_engine_config()}+ mock_gsmc.return_value = _VarKwEng++ create_search_engine("tinyfish", settings_snapshot=snapshot)++ assert _VarKwEng._call_kwargs.get("search_snippets_only") is False+ assert _VarKwEng._call_kwargs.get("max_filtered_results") == 15+ assert _VarKwEng._call_kwargs.get("safe_search") is False+ assert _VarKwEng._call_kwargs.get("region") == "fr"+ assert _VarKwEng._call_kwargs.get("location") == "FR"+ assert _VarKwEng._call_kwargs.get("language") == "fr"+ assert _VarKwEng._call_kwargs.get("search_language") == "French"++ def test_max_filtered_results_coercion_and_none_handling(self):+ """max_filtered_results coerces numeric strings and ignores None values."""+ from local_deep_research.web_search_engines.search_engine_factory import (+ create_search_engine,+ )++ EngCls = _make_engine_class("max_filtered_results")++ with (+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.retriever_registry"+ ) as mock_reg,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.search_config"+ ) as mock_sc,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.get_safe_module_class"+ ) as mock_gsmc,+ ):+ mock_reg.get.return_value = None+ cfg = self._make_engine_config()+ cfg["default_params"] = {"max_filtered_results": 25}+ mock_sc.return_value = {"eng": cfg}+ mock_gsmc.return_value = EngCls++ # When None in snapshot, default_params is preserved+ create_search_engine(+ "eng",+ settings_snapshot={+ "search.max_filtered_results": {"value": None}+ },+ )+ assert EngCls._call_kwargs.get("max_filtered_results") == 25++ # When numeric string in snapshot, coerced to int+ create_search_engine(+ "eng",+ settings_snapshot={+ "search.max_filtered_results": {"value": "12"}+ },+ )+ assert EngCls._call_kwargs.get("max_filtered_results") == 12++ def test_safe_search_coercion_from_string(self):+ """safe_search properly coerces string boolean representations."""+ from local_deep_research.web_search_engines.search_engine_factory import (+ create_search_engine,+ )++ EngCls = _make_engine_class("safe_search")++ with (+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.retriever_registry"+ ) as mock_reg,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.search_config"+ ) as mock_sc,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.get_safe_module_class"+ ) as mock_gsmc,+ ):+ mock_reg.get.return_value = None+ mock_sc.return_value = {"eng": self._make_engine_config()}+ mock_gsmc.return_value = EngCls++ create_search_engine(+ "eng",+ settings_snapshot={"search.safe_search": {"value": "false"}},+ )+ assert EngCls._call_kwargs.get("safe_search") is False++ create_search_engine(+ "eng", settings_snapshot={"search.safe_search": "true"}+ )+ assert EngCls._call_kwargs.get("safe_search") is True++ def test_searxng_safe_search_preserves_default_params(self):+ """Global search.safe_search does not override SearXNG default_params.safe_search."""+ from local_deep_research.web_search_engines.search_engine_factory import (+ create_search_engine,+ )++ EngCls = _make_engine_class("safe_search")+ cfg_off = self._make_engine_config()+ cfg_off["default_params"] = {"safe_search": "OFF"}+ cfg_strict = self._make_engine_config()+ cfg_strict["default_params"] = {"safe_search": "STRICT"}++ with (+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.retriever_registry"+ ) as mock_reg,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.search_config"+ ) as mock_sc,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.get_safe_module_class"+ ) as mock_gsmc,+ ):+ mock_reg.get.return_value = None+ mock_gsmc.return_value = EngCls++ # Default OFF in default_params is preserved even when search.safe_search=True+ mock_sc.return_value = {"searxng": cfg_off}+ create_search_engine(+ "searxng",+ settings_snapshot={"search.safe_search": {"value": True}},+ )+ assert EngCls._call_kwargs.get("safe_search") == "OFF"++ # STRICT in default_params is preserved+ mock_sc.return_value = {"searxng": cfg_strict}+ create_search_engine(+ "searxng",+ settings_snapshot={"search.safe_search": {"value": True}},+ )+ assert EngCls._call_kwargs.get("safe_search") == "STRICT"++ # Explicit caller kwarg still overrides default_params+ create_search_engine(+ "searxng",+ safe_search=False,+ settings_snapshot={"search.safe_search": {"value": True}},+ )+ assert EngCls._call_kwargs.get("safe_search") is False++ def test_wayback_and_openlibrary_language_preserved(self):+ """Wayback default language and OpenLibrary None language are preserved from snapshot injection."""+ from local_deep_research.web_search_engines.search_engine_factory import (+ create_search_engine,+ )++ EngCls = _make_engine_class("language")+ wb_cfg = self._make_engine_config()+ wb_cfg["default_params"] = {"language": "English"}+ ol_cfg = self._make_engine_config()+ ol_cfg["default_params"] = {}++ with (+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.retriever_registry"+ ) as mock_reg,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.search_config"+ ) as mock_sc,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.get_safe_module_class"+ ) as mock_gsmc,+ ):+ mock_reg.get.return_value = None+ mock_gsmc.return_value = EngCls++ # Wayback preserves default_params language='English'+ mock_sc.return_value = {"wayback": wb_cfg}+ create_search_engine(+ "wayback",+ settings_snapshot={+ "search.search_language": {"value": "English"}+ },+ )+ assert EngCls._call_kwargs.get("language") == "English"++ # OpenLibrary does not receive language code (kept None for no filter)+ mock_sc.return_value = {"openlibrary": ol_cfg}+ create_search_engine(+ "openlibrary",+ settings_snapshot={+ "search.search_language": {"value": "English"}+ },+ )+ assert "language" not in EngCls._call_kwargs++ def test_openalex_preview_filters_no_duplicate_keyword_error(self):+ """OpenAlexSearchEngine instantiates cleanly without duplicate preview_filters error."""+ from local_deep_research.web_search_engines.search_engine_factory import (+ create_search_engine,+ )+ from local_deep_research.web_search_engines.engines.search_engine_openalex import (+ OpenAlexSearchEngine,+ )++ with (+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.retriever_registry"+ ) as mock_reg,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.search_config"+ ) as mock_sc,+ patch(+ "local_deep_research.web_search_engines.search_engine_factory.get_safe_module_class"+ ) as mock_gsmc,+ ):+ mock_reg.get.return_value = None+ mock_sc.return_value = {+ "openalex": {+ "module_path": ".engines.search_engine_openalex",+ "class_name": "OpenAlexSearchEngine",+ "default_params": {},+ }+ }+ mock_gsmc.return_value = OpenAlexSearchEngine++ engine = create_search_engine(+ "openalex",+ llm=Mock(),+ preview_filters=[],+ settings_snapshot={"search.tool": "openalex"},+ )+ assert engine is not None+ assert isinstance(engine, OpenAlexSearchEngine)++ def test_normalize_language_code_unmapped_returns_none(self):+ """_normalize_language_code returns None for unmapped or invalid language strings."""+ from local_deep_research.web_search_engines.search_engine_factory import (+ _normalize_language_code,+ )++ assert _normalize_language_code("English") == "en"+ assert _normalize_language_code("french") == "fr"+ assert _normalize_language_code("de") == "de"+ assert _normalize_language_code("swiss german") is None+ assert _normalize_language_code("") is None+ assert _normalize_language_code(None) is None++ def test_to_extraction_language_name_separates_codes_from_names(self):+ from local_deep_research.web_search_engines.search_engine_factory import (+ _to_extraction_language_name,+ )++ assert _to_extraction_language_name("German") == "German"+ assert _to_extraction_language_name("de") == "German"+ assert _to_extraction_language_name("EN") == "English"+ assert _to_extraction_language_name("xx") is None+ assert _to_extraction_language_name("swiss german") == "swiss german"+ assert _to_extraction_language_name(None) is None