~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
refactor(search): unify full-content retrieval in search engine factory wrapper (#6492)
Sa7cb610993ef
diff --git a/changelog.d/+unified-full-search-wrapper.misc.md b/changelog.d/+unified-full-search-wrapper.misc.mdnew file mode 100644index 0000000000..65f290ad34--- /dev/null+++ b/changelog.d/+unified-full-search-wrapper.misc.md@@ -0,0 +1 @@+Unify full-content retrieval on a single path. Eight engines (DDG, SearXNG, Brave, Tavily, Serper, SerpAPI, ScaleSERP, Mojeek) used to attach their own internal `FullSearchResults` in `__init__`; now the factory `FullSearchResults` wrapper is the only fetcher for engines that declare `full_search_module` in the registry or `supports_full_search` in their config. Engines emit snippets from `_get_previews` and return items unchanged from `_get_full_content`; the wrapper populates `full_content` after the inner engine runs. An explicit `supports_full_search=False` in settings is honoured as a per-engine opt-out that wins over the registry default. No user-visible behaviour change beyond the snippets_only fix and the fetch-count reduction.diff --git a/src/local_deep_research/web_search_engines/engine_registry.py b/src/local_deep_research/web_search_engines/engine_registry.pyindex 75e5351d6f..9eb8fb6e34 100644--- a/src/local_deep_research/web_search_engines/engine_registry.py+++ b/src/local_deep_research/web_search_engines/engine_registry.py@@ -75,6 +75,8 @@ ENGINE_REGISTRY: Dict[str, EngineEntry] = {"tavily": EngineEntry(module_path=".engines.search_engine_tavily",class_name="TavilySearchEngine",+ full_search_module=".engines.full_search",+ full_search_class="FullSearchResults",),"tinyfish": EngineEntry(module_path=".engines.search_engine_tinyfish",@@ -104,10 +106,14 @@ ENGINE_REGISTRY: Dict[str, EngineEntry] = {"scaleserp": EngineEntry(module_path=".engines.search_engine_scaleserp",class_name="ScaleSerpSearchEngine",+ full_search_module=".engines.full_search",+ full_search_class="FullSearchResults",),"serper": EngineEntry(module_path=".engines.search_engine_serper",class_name="SerperSearchEngine",+ full_search_module=".engines.full_search",+ full_search_class="FullSearchResults",),"serply": EngineEntry(module_path=".engines.search_engine_serply",@@ -155,6 +161,8 @@ ENGINE_REGISTRY: Dict[str, EngineEntry] = {"ddg": EngineEntry(module_path=".engines.search_engine_ddg",class_name="DuckDuckGoSearchEngine",+ full_search_module=".engines.full_search",+ full_search_class="FullSearchResults",),"guardian": EngineEntry(module_path=".engines.search_engine_guardian",diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_brave.py b/src/local_deep_research/web_search_engines/engines/search_engine_brave.pyindex 6d64fd261e..d4aa1f1ad8 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_brave.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_brave.py@@ -55,7 +55,8 @@ class BraveSearchEngine(BaseSearchEngine):api_key: Brave Search API key (can also be set via LDR_SEARCH_ENGINE_WEB_BRAVE_API_KEY env var or in UI settings)language_code_mapping: Mapping from language names to codesllm: Language model for relevance filtering- include_full_content: Whether to include full webpage content in results+ include_full_content: Retained for backward compatibility; full-content+ retrieval is handled via the factory wrapper.max_filtered_results: Maximum number of results to keep after filteringsettings_snapshot: Settings snapshot for thread context**kwargs: Additional parameters (ignored but accepted for compatibility)@@ -112,15 +113,10 @@ class BraveSearchEngine(BaseSearchEngine):# User agent is not needed for Brave Search API- # If full content is requested, initialize FullSearchResults- self._init_full_search(- web_search=self.engine,- language=search_language,- max_results=max_results,- region=region,- time_period=time_period,- safe_search=brave_safe_search,- )+ # Full-content retrieval is the factory wrapper's job — the+ # wrapper fetches pages via ``batch_fetch_and_extract`` and+ # populates ``full_content`` on each result; the inner engine+ # only emits snippets from ``_get_previews``.def _get_previews(self, query: str) -> List[Dict[str, Any]]:"""diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_ddg.py b/src/local_deep_research/web_search_engines/engines/search_engine_ddg.pyindex 6b31ec3fd7..6b5a9db132 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_ddg.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_ddg.py@@ -38,7 +38,8 @@ class DuckDuckGoSearchEngine(BaseSearchEngine):safe_search: Whether to enable safe searchllm: Language model for relevance filteringlanguage: Language for content processing- include_full_content: Whether to include full webpage content in results+ include_full_content: Retained for backward compatibility; full-content+ retrieval is handled via the factory wrapper."""max_results = min(max_results, 50)# Initialize the BaseSearchEngine with LLM, max_filtered_results, and max_results@@ -60,15 +61,10 @@ class DuckDuckGoSearchEngine(BaseSearchEngine):safesearch="moderate" if safe_search else "off",)- # Initialize FullSearchResults if full content is requested- self._init_full_search(- web_search=self.engine,- language=language,- max_results=max_results,- region=region,- time_period="y",- safe_search="Moderate" if safe_search else "Off",- )+ # Note: full-content retrieval is the factory wrapper's job.+ # The wrapper fetches pages via ``batch_fetch_and_extract`` and+ # populates ``full_content`` on each result; the inner engine+ # only emits snippets from ``_get_previews``.def _get_previews(self, query: str) -> List[Dict[str, Any]]:"""@@ -129,18 +125,9 @@ class DuckDuckGoSearchEngine(BaseSearchEngine):def _get_full_content(self, relevant_items: List[Dict[str, Any]]) -> List[Dict[str, Any]]:- """- Get full content for the relevant items by using FullSearchResults.+ """Return items unchanged.- Args:- relevant_items: List of relevant preview dictionaries-- Returns:- List of result dictionaries with full content+ The factory wrapper populates ``full_content`` after running the+ engine; the inner engine never fetches pages itself."""- # If we have FullSearchResults, use it to get full content- if hasattr(self, "full_search"):- return self.full_search._get_full_content(relevant_items)-- # Otherwise, just return the relevant items without full contentreturn relevant_itemsdiff --git a/src/local_deep_research/web_search_engines/engines/search_engine_mojeek.py b/src/local_deep_research/web_search_engines/engines/search_engine_mojeek.pyindex 26c1f1f797..c6fd53ed6f 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_mojeek.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_mojeek.py@@ -60,7 +60,8 @@ class MojeekSearchEngine(BaseSearchEngine):llm: Language model for relevance filteringmax_filtered_results: Maximum number of results to keep after filteringsettings_snapshot: Settings snapshot for thread context- include_full_content: Whether to include full webpage content+ include_full_content: Retained for backward compatibility; full-content+ retrieval is handled via the factory wrapper."""super().__init__(llm=llm,@@ -86,15 +87,10 @@ class MojeekSearchEngine(BaseSearchEngine):self.safe_search = safe_searchself.api_key = mojeek_api_key- # If full content is requested, initialize FullSearchResults- self._init_full_search(- web_search=self,- language=language,- max_results=max_results,- region=region,- safe_search=safe_search,- time_period="y",- )+ # Full-content retrieval is the factory wrapper's job — the+ # wrapper fetches pages via ``batch_fetch_and_extract`` and+ # populates ``full_content`` on each result; the inner engine+ # only emits snippets from ``_get_previews``.def _get_search_results(self, query: str) -> List[Dict[str, Any]]:"""@@ -223,23 +219,11 @@ class MojeekSearchEngine(BaseSearchEngine):def _get_full_content(self, relevant_items: List[Dict[str, Any]]) -> List[Dict[str, Any]]:- """- Get full content for the relevant search results.-- Args:- relevant_items: List of relevant preview dictionaries+ """Return items unchanged.- Returns:- List of result dictionaries with full content+ Full-content retrieval is the factory wrapper's job. The wrapper+ fetches pages via ``batch_fetch_and_extract`` and populates+ ``full_content`` on each result; the inner engine never fetches+ pages itself."""- if self.include_full_content and hasattr(self, "full_search"):- logger.info("Retrieving full webpage content")- try:- return self.full_search._get_full_content(relevant_items)- except Exception as e:- safe_msg = self._scrub_error(e)- logger.exception(- f"Error retrieving full content ({type(e).__name__}): {safe_msg}"- )-return relevant_itemsdiff --git a/src/local_deep_research/web_search_engines/engines/search_engine_scaleserp.py b/src/local_deep_research/web_search_engines/engines/search_engine_scaleserp.pyindex f71b0efa95..873c18af17 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_scaleserp.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_scaleserp.py@@ -45,7 +45,8 @@ class ScaleSerpSearchEngine(BaseSearchEngine):safe_search: Whether to enable safe searchapi_key: ScaleSerp API key (can also be set in settings)llm: Language model for relevance filtering- include_full_content: Whether to include full webpage content in results+ include_full_content: Retained for backward compatibility; full-content+ retrieval is handled via the factory wrapper.max_filtered_results: Maximum number of results to keep after filteringsettings_snapshot: Settings snapshot for thread contextenable_cache: Whether to use ScaleSerp's 1-hour caching (saves costs for repeated searches)@@ -79,15 +80,10 @@ class ScaleSerpSearchEngine(BaseSearchEngine):# Initialize per-query attributes (reset in _get_previews per search)self._knowledge_graph = None- # If full content is requested, initialize FullSearchResults- self._init_full_search(- web_search=None, # We'll handle the search ourselves- language=language,- max_results=max_results,- region=location,- time_period=None,- safe_search="Moderate" if safe_search else "Off",- )+ # Full-content retrieval is the factory wrapper's job — the+ # wrapper fetches pages via ``batch_fetch_and_extract`` and+ # populates ``full_content`` on each result; the inner engine+ # only emits snippets from ``_get_previews``.def _get_previews(self, query: str) -> List[Dict[str, Any]]:"""diff --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 2deceeb8b5..66df83ae99 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@@ -149,7 +149,7 @@ class SearXNGSearchEngine(BaseSearchEngine):return not validate_url(self.instance_url, allow_private_ips=False) and validate_url(self.instance_url, allow_private_ips=True)- except Exception: # noqa: silent-exception - hint detection is best-effort+ except Exception: # noqa: BLE001 - hint detection is best-effortreturn Falsedef __init__(@@ -186,7 +186,8 @@ class SearXNGSearchEngine(BaseSearchEngine):delay_between_requests: Seconds to wait between requestsllm: Language model for relevance filteringmax_filtered_results: Maximum number of results to keep after filtering- include_full_content: Whether to include full webpage content in results+ include_full_content: Retained for backward compatibility; full-content+ retrieval is handled via the factory wrapper."""# Initialize the BaseSearchEngine with LLM, max_filtered_results, and max_results@@ -312,14 +313,11 @@ class SearXNGSearchEngine(BaseSearchEngine):f"Rate limiting set to {self.delay_between_requests} seconds between requests")- self._init_full_search(- web_search=self,- language=language,- max_results=max_results,- region="wt-wt",- time_period="y",- safe_search=self.safe_search.value,- )+ # Full-content retrieval is the factory wrapper's job — see+ # ``search_engine_factory._create_full_search_wrapper``. The+ # wrapper fetches pages via ``batch_fetch_and_extract`` and+ # populates ``full_content`` on each result; the inner engine+ # only emits snippets from ``_get_previews``.def _respect_rate_limit(self):"""Apply self-imposed rate limiting between requests.@@ -688,32 +686,14 @@ class SearXNGSearchEngine(BaseSearchEngine):def _get_full_content(self, relevant_items: List[Dict[str, Any]]) -> List[Dict[str, Any]]:- """- Get full content for the relevant search results.-- Args:- relevant_items: List of relevant preview dictionaries+ """Return items unchanged.- Returns:- List of result dictionaries with full content+ Full-content retrieval is the factory wrapper's job. The wrapper+ fetches pages via ``batch_fetch_and_extract`` and populates+ ``full_content`` on each result; the inner engine never fetches+ pages itself."""- if not self._is_available:- return relevant_items-- if not hasattr(self, "full_search"):- return relevant_items-- logger.info("Retrieving full webpage content")-- try:- return self.full_search._get_full_content(relevant_items)-- except Exception as e:- safe_msg = self._scrub_error(e)- logger.exception(- f"Error retrieving full content ({type(e).__name__}): {safe_msg}"- )- return relevant_items+ return relevant_itemsdef invoke(self, query: str) -> List[Dict[str, Any]]:"""Compatibility method for LangChain tools"""diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_serpapi.py b/src/local_deep_research/web_search_engines/engines/search_engine_serpapi.pyindex 3dcbc168f1..c64a40c138 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_serpapi.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_serpapi.py@@ -52,7 +52,8 @@ class SerpAPISearchEngine(BaseSearchEngine):api_key: SerpAPI API key (can also be set via LDR_SEARCH_ENGINE_WEB_SERPAPI_API_KEY env var or in UI settings)language_code_mapping: Mapping from language names to codesllm: Language model for relevance filtering- include_full_content: Whether to include full webpage content in results+ include_full_content: Retained for backward compatibility; full-content+ retrieval is handled via the factory wrapper.max_filtered_results: Maximum number of results to keep after filteringsettings_snapshot: Settings snapshot for thread context**kwargs: Additional parameters (ignored but accepted for compatibility)@@ -113,15 +114,10 @@ class SerpAPISearchEngine(BaseSearchEngine):params=params,)- # If full content is requested, initialize FullSearchResults- self._init_full_search(- web_search=self.engine,- language=search_language,- max_results=max_results,- region=region,- time_period=time_period,- safe_search="Moderate" if safe_search else "Off",- )+ # Full-content retrieval is the factory wrapper's job — the+ # wrapper fetches pages via ``batch_fetch_and_extract`` and+ # populates ``full_content`` on each result; the inner engine+ # only emits snippets from ``_get_previews``.def _get_previews(self, query: str) -> List[Dict[str, Any]]:"""diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_serper.py b/src/local_deep_research/web_search_engines/engines/search_engine_serper.pyindex 1b2b83bfb1..83e817024c 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_serper.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_serper.py@@ -50,7 +50,8 @@ class SerperSearchEngine(BaseSearchEngine):search_language: Language code for results (e.g., 'en', 'es', 'fr')api_key: Serper API key (can also be set in settings)llm: Language model for relevance filtering- include_full_content: Whether to include full webpage content in results+ include_full_content: Retained for backward compatibility; full-content+ retrieval is handled via the factory wrapper.max_filtered_results: Maximum number of results to keep after filteringsettings_snapshot: Settings snapshot for thread context**kwargs: Additional parameters (ignored but accepted for compatibility)@@ -83,15 +84,10 @@ class SerperSearchEngine(BaseSearchEngine):# Initialize per-query attributes (reset in _get_previews per search)self._knowledge_graph = None- # If full content is requested, initialize FullSearchResults- self._init_full_search(- web_search=None, # We'll handle the search ourselves- language=search_language,- max_results=max_results,- region=region,- time_period=time_period,- safe_search="Moderate" if safe_search else "Off",- )+ # Full-content retrieval is the factory wrapper's job — the+ # wrapper fetches pages via ``batch_fetch_and_extract`` and+ # populates ``full_content`` on each result; the inner engine+ # only emits snippets from ``_get_previews``.def _get_previews(self, query: str) -> List[Dict[str, Any]]:"""diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_tavily.py b/src/local_deep_research/web_search_engines/engines/search_engine_tavily.pyindex d4a136d9db..60cf50b614 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_tavily.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_tavily.py@@ -58,7 +58,8 @@ class TavilySearchEngine(BaseSearchEngine):search_language: Language for search results (not used by Tavily currently)api_key: Tavily API key (can also be set via LDR_SEARCH_ENGINE_WEB_TAVILY_API_KEY env var or in UI settings)llm: Language model for relevance filtering- include_full_content: Whether to include full webpage content in results+ include_full_content: Retained for backward compatibility; full-content+ retrieval is handled via the factory wrapper.max_filtered_results: Maximum number of results to keep after filteringsearch_depth: "basic" or "advanced" - controls search quality vs speedinclude_domains: List of domains to include in search@@ -90,24 +91,10 @@ class TavilySearchEngine(BaseSearchEngine):self.api_key = tavily_api_keyself.base_url = "https://api.tavily.com"- # If full content is requested, initialize FullSearchResults- if include_full_content:- # Create a simple wrapper for Tavily API calls- class TavilyWrapper:- def __init__(self, parent):- self.parent = parent-- def run(self, query):- return self.parent._get_previews(query)-- self._init_full_search(- web_search=TavilyWrapper(self),- language=search_language,- max_results=max_results,- region=region,- time_period=time_period,- safe_search="moderate" if safe_search else "off",- )+ # Full-content retrieval is the factory wrapper's job — the+ # wrapper fetches pages via ``batch_fetch_and_extract`` and+ # populates ``full_content`` on each result; the inner engine+ # only emits snippets from ``_get_previews``.def _get_previews(self, query: str) -> List[Dict[str, Any]]:"""diff --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 1b89d98f57..e4879f74ea 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@@ -17,6 +17,33 @@ from .search_engines_config import search_configTIME_PERIOD_ENGINES = ("serpapi", "tavily", "wikinews")+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.+ """+ 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 bool(raw)++def create_search_engine(engine_name: str,llm=None,@@ -295,6 +322,26 @@ def create_search_engine(else 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+ # (langgraph-agent strategy tools, MCP server) only pass a settings_snapshot+ # — without this fallback the user's Settings → Search → Snippets Only choice+ # is silently ignored on those paths and defaults to True. Placed in kwargs+ # so it takes precedence over per-engine default_params.+ if "search_snippets_only" not in kwargs and settings_snapshot:+ resolved_snippets = _resolve_snippets_only(settings_snapshot)+ if resolved_snippets is not None:+ kwargs["search_snippets_only"] = resolved_snippets++ # Mirror get_search(): wrap FullSearchResults when snippets-only is off+ # and the caller did not pass use_full_search. Direct callers (langgraph+ # tools, MCP) never set that flag, so without this the engine fetches+ # full content (search_snippets_only=False) but the wrapper path that+ # actually hydrates ``full_content`` for searxng/ddg/serpapi/etc. never+ # runs.+ if "use_full_search" not in kwargs and "search_snippets_only" in kwargs:+ kwargs["use_full_search"] = not kwargs["search_snippets_only"]+# Check for API key requirementsrequires_api_key = engine_config.get("requires_api_key", False)@@ -415,6 +462,18 @@ def create_search_engine():engine._configure_programmatic_mode(programmatic_mode)+ # Same swallow: Wikipedia (and others) accept **kwargs but do not+ # forward ``search_snippets_only`` to BaseSearchEngine, so run()+ # would keep the True default and skip _get_full_content. Stamp it+ # after construction whenever the factory resolved a value.+ if (+ isinstance(engine, BaseSearchEngine)+ and "search_snippets_only" in all_params+ ):+ engine.search_snippets_only = bool(+ all_params["search_snippets_only"]+ )+# Determine if this engine should use LLM relevance filtering# Priority: per-engine setting > needs_llm_relevance_filter > global setting#@@ -484,19 +543,34 @@ def create_search_engine(else:logger.debug(f"LLM relevance filtering disabled for {engine_name}")- # Check if we need to wrap with full search capabilities- if kwargs.get("use_full_search", False) and engine_config.get(- "supports_full_search", False- ):- return _create_full_search_wrapper(- engine_name,- engine,- engine_config,- llm,- kwargs,- username,- settings_snapshot,+ # Check if we need to wrap with full search capabilities. Two+ # config flags identify engines that participate in the unified+ # full-search pipeline:+ # * ``supports_full_search`` — runtime-registered engines+ # (retrievers, set in ``search_engines_config.py``)+ # * ``full_search_module`` — registry engines, populated from+ # ``engine_registry.EngineEntry.full_search_module``+ # An explicit ``supports_full_search=False`` wins as a per-engine+ # opt-out, letting users disable wrapping for any engine via+ # settings even when the registry marks it as wrap-eligible.+ if kwargs.get("use_full_search", False):+ explicit_opt_out = (+ "supports_full_search" in engine_config+ and not engine_config["supports_full_search"])+ if not explicit_opt_out and (+ engine_config.get("supports_full_search", False)+ or engine_config.get("full_search_module")+ ):+ return _create_full_search_wrapper(+ engine_name,+ engine,+ engine_config,+ llm,+ kwargs,+ username,+ settings_snapshot,+ )return engine # type: ignore[no-any-return]@@ -667,7 +741,7 @@ def get_search(region: str = "us",time_period: str = "all",safe_search: bool = True,- search_snippets_only: bool = False,+ search_snippets_only: Optional[bool] = None,search_language: str = "English",max_filtered_results: Optional[int] = None,settings_snapshot: Dict[str, Any] | None = None,@@ -683,7 +757,8 @@ def get_search(region: Search region/localetime_period: Time period for search resultssafe_search: Whether to enable safe search- search_snippets_only: Whether to return just snippets (vs. full content)+ search_snippets_only: Whether to return just snippets (vs. full content).+ Defaults to None (defers to settings_snapshot or engine default).search_language: Language for search resultsmax_filtered_results: Maximum number of results to keep after filteringprogrammatic_mode: If True, disables database operations and metrics tracking@@ -697,10 +772,25 @@ def get_search("llm": llm_instance, # Only used by engines that need it}+ # Add search_snippets_only if provided+ if search_snippets_only is not None:+ params["search_snippets_only"] = search_snippets_only+# Add max_filtered_results if providedif max_filtered_results is not None:params["max_filtered_results"] = max_filtered_results+ # Resolve use_full_search for engines that support full search wrapping.+ # When search_snippets_only is not explicitly passed, defer to settings_snapshot+ # if present; otherwise default to False (matching BaseSearchEngine's snippet-only default).+ if search_snippets_only is not None:+ use_full_search = not search_snippets_only+ else:+ resolved_snippets = _resolve_snippets_only(settings_snapshot)+ use_full_search = (+ (not resolved_snippets) if resolved_snippets is not None else False+ )+# Add engine-specific parametersif search_tool in ["duckduckgo",@@ -713,12 +803,12 @@ def get_search({"region": region,"safe_search": safe_search,- "use_full_search": not search_snippets_only,+ "use_full_search": use_full_search,})if search_tool == "searxng":- params["use_full_search"] = not search_snippets_only+ params["use_full_search"] = use_full_searchif search_tool in ["serpapi", "brave", "google_pse", "wikinews"]:params["search_language"] = search_language@@ -726,15 +816,14 @@ def get_search(if search_tool == "tinyfish":params["location"] = region.upper()params["language"] = search_language- params["search_snippets_only"] = search_snippets_onlyif search_tool == "sofya":- # Sofya derives its request depth from this: the paid "basic" depth- # (inline page content) is only requested when full content is used.- params["search_snippets_only"] = search_snippets_only+ # Sofya derives its request depth from search_snippets_only: the paid+ # "basic" depth (inline page content) is only requested when full+ # content is used. Handled via common params / snapshot fallback.+ passif search_tool == "wikinews":- params["search_snippets_only"] = search_snippets_onlyparams["adaptive_search"] = bool((settings_snapshot or {}).get("search.engine.web.wikinews.adaptive_search", {})@@ -743,8 +832,8 @@ def get_search(if is_collection_engine(search_tool):# BaseSearchEngine defaults this to True, so the RAG engines stay- # snippet-only unless the setting is forwarded here.- params["search_snippets_only"] = search_snippets_only+ # snippet-only unless the setting is forwarded in params or snapshot.+ passif search_tool in TIME_PERIOD_ENGINES:params["time_period"] = time_perioddiff --git a/tests/search_engines/test_search_engine_brave.py b/tests/search_engines/test_search_engine_brave.pyindex 1221d06c2f..3c2c707621 100644--- a/tests/search_engines/test_search_engine_brave.py+++ b/tests/search_engines/test_search_engine_brave.py@@ -323,8 +323,10 @@ class TestBraveFullContent:api_key="test_key", include_full_content=True)assert engine_with.include_full_content is True+ assert not hasattr(engine_with, "full_search")engine_without = BraveSearchEngine(api_key="test_key", include_full_content=False)assert engine_without.include_full_content is False+ assert not hasattr(engine_without, "full_search")diff --git a/tests/search_engines/test_search_engine_ddg.py b/tests/search_engines/test_search_engine_ddg.pyindex 5dc77b98f0..645744e324 100644--- a/tests/search_engines/test_search_engine_ddg.py+++ b/tests/search_engines/test_search_engine_ddg.py@@ -302,36 +302,16 @@ class TestDuckDuckGoGetFullContent:include_full_content=False,)- def test_get_full_content_without_full_search(- self, ddg_engine_snippets_only- ):- """Test that _get_full_content returns items as-is when no full_search."""- items = [- {"title": "Test", "snippet": "Snippet"},- ]-- result = ddg_engine_snippets_only._get_full_content(items)-- assert result == items-- def test_get_full_content_with_full_search_delegates(+ def test_get_full_content_passes_through(self, ddg_engine_with_full_content):- """Test that _get_full_content delegates to full_search when available."""+ """DDG no longer self-wraps, so ``_get_full_content`` is a+ pass-through. The factory wrapper populates ``full_content``+ after the inner engine runs.+ """items = [{"title": "Test", "snippet": "Snippet"}]-- # Mock the full_search._get_full_content method- with patch.object(- ddg_engine_with_full_content.full_search, "_get_full_content"- ) as mock_full:- mock_full.return_value = [- {"title": "Test", "content": "Full content"}- ]-- result = ddg_engine_with_full_content._get_full_content(items)-- mock_full.assert_called_once_with(items)- assert result[0]["content"] == "Full content"+ assert not hasattr(ddg_engine_with_full_content, "full_search")+ assert ddg_engine_with_full_content._get_full_content(items) is items@pytest.mark.skipif(not DDGS_AVAILABLE, reason="ddgs package not installed")diff --git a/tests/search_engines/test_search_engine_scaleserp.py b/tests/search_engines/test_search_engine_scaleserp.pyindex 795ee170ce..42cc2b9632 100644--- a/tests/search_engines/test_search_engine_scaleserp.py+++ b/tests/search_engines/test_search_engine_scaleserp.py@@ -101,6 +101,18 @@ class TestScaleSerpSearchEngineInit:engine = ScaleSerpSearchEngine(api_key="test_key", safe_search=False)assert engine.safe_search is False+ def test_engine_does_not_self_wrap(self):+ """The engine must not carry a ``full_search`` attribute; the+ factory wrapper handles full-content retrieval."""+ from local_deep_research.web_search_engines.engines.search_engine_scaleserp import (+ ScaleSerpSearchEngine,+ )++ engine = ScaleSerpSearchEngine(+ api_key="test_key", include_full_content=True+ )+ assert not hasattr(engine, "full_search")+def test_base_url_set(self):"""Test that base URL is correctly set."""from local_deep_research.web_search_engines.engines.search_engine_scaleserp import (diff --git a/tests/search_engines/test_search_engine_searxng.py b/tests/search_engines/test_search_engine_searxng.pyindex 5f25c7ffd7..24ea3a6746 100644--- a/tests/search_engines/test_search_engine_searxng.py+++ b/tests/search_engines/test_search_engine_searxng.py@@ -762,24 +762,21 @@ class TestSearXNGGetFullContent:assert results == items- def test_get_full_content_exception(self, monkeypatch):- """Test _get_full_content handles exceptions."""+ def test_get_full_content_pass_through(self):+ """SearXNG no longer self-wraps, so ``_get_full_content`` is a+ pass-through and the engine does not carry a ``full_search`` attribute.+ The factory wrapper populates ``full_content`` after the inner engine runs.+ """from local_deep_research.web_search_engines.engines.search_engine_searxng import (SearXNGSearchEngine,)engine = SearXNGSearchEngine()-- # Mock full_search to raise exception- engine.full_search = Mock()- engine.full_search._get_full_content = Mock(- side_effect=Exception("Error")- )+ assert not hasattr(engine, "full_search")items = [{"title": "Test", "snippet": "Content"}]results = engine._get_full_content(items)- # Should return original items on errorassert results == itemsdiff --git a/tests/search_engines/test_search_engine_serpapi.py b/tests/search_engines/test_search_engine_serpapi.pyindex a816291ef6..fab081022f 100644--- a/tests/search_engines/test_search_engine_serpapi.py+++ b/tests/search_engines/test_search_engine_serpapi.py@@ -338,38 +338,33 @@ class TestSerpAPIRun:class TestSerpAPIFullContentRetrieval:"""Tests for SerpAPI full content retrieval feature."""- def test_init_with_full_content_enabled(- self, mock_serpapi_wrapper, monkeypatch- ):- """Test initialization with full content retrieval enabled."""+ def test_init_with_full_content_enabled(self, mock_serpapi_wrapper):+ """SerpAPI no longer self-wraps, so ``_get_full_content`` is a+ pass-through and the engine does not carry a ``full_search`` attribute.+ The factory wrapper populates ``full_content`` after the inner engine runs.+ """from local_deep_research.web_search_engines.engines.search_engine_serpapi import (SerpAPISearchEngine,)- # Mock FullSearchResults import- mock_full_search = Mock()- monkeypatch.setattr(- "local_deep_research.web_search_engines.engines.full_search.FullSearchResults",- mock_full_search,- )-engine = SerpAPISearchEngine(api_key="test_key", include_full_content=True, llm=Mock())assert engine.include_full_content is True- assert hasattr(engine, "full_search")- mock_full_search.assert_called_once()+ assert not hasattr(engine, "full_search")++ items = [{"title": "Test", "snippet": "Snippet"}]+ assert engine._get_full_content(items) == items- def test_init_full_content_disabled_on_import_error(- self, mock_serpapi_wrapper, monkeypatch- ):- """Test that full content is disabled if FullSearchResults import fails."""+ def test_engine_does_not_self_wrap(self, mock_serpapi_wrapper):+ """SerpAPI must not carry a ``full_search`` attribute; the factory+ wrapper handles full-content retrieval."""from local_deep_research.web_search_engines.engines.search_engine_serpapi import (SerpAPISearchEngine,)- # The default behavior without FullSearchResults should workengine = SerpAPISearchEngine(api_key="test_key", include_full_content=False)assert engine.include_full_content is False+ assert not hasattr(engine, "full_search")diff --git a/tests/search_engines/test_search_engine_serper.py b/tests/search_engines/test_search_engine_serper.pyindex e0b25f8736..8d90321dbe 100644--- a/tests/search_engines/test_search_engine_serper.py+++ b/tests/search_engines/test_search_engine_serper.py@@ -97,6 +97,18 @@ class TestSerperSearchEngineInit:engine = SerperSearchEngine(api_key="test_key", search_language="es")assert engine.search_language == "es"+ def test_engine_does_not_self_wrap(self):+ """The engine must not carry a ``full_search`` attribute; the+ factory wrapper handles full-content retrieval."""+ from local_deep_research.web_search_engines.engines.search_engine_serper import (+ SerperSearchEngine,+ )++ engine = SerperSearchEngine(+ api_key="test_key", include_full_content=True+ )+ assert not hasattr(engine, "full_search")+def test_base_url_set(self):"""Test that base URL is correctly set."""from local_deep_research.web_search_engines.engines.search_engine_serper import (diff --git a/tests/search_engines/test_search_engine_tavily.py b/tests/search_engines/test_search_engine_tavily.pyindex 4401b30f14..2b8bded8ba 100644--- a/tests/search_engines/test_search_engine_tavily.py+++ b/tests/search_engines/test_search_engine_tavily.py@@ -323,6 +323,7 @@ class TestTavilyFullContent:api_key="test_key", include_full_content=True)assert engine.include_full_content is True+ assert not hasattr(engine, "full_search")def test_include_full_content_flag_false(self):"""Test include_full_content flag is set correctly when False."""@@ -334,6 +335,7 @@ class TestTavilyFullContent:api_key="test_key", include_full_content=False)assert engine.include_full_content is False+ assert not hasattr(engine, "full_search")def test_get_full_content_returns_results(self):"""Test that full content returns processed results."""diff --git a/tests/web_search_engines/engines/test_search_engine_ddg.py b/tests/web_search_engines/engines/test_search_engine_ddg.pyindex 6636ee57f3..d382f059fb 100644--- a/tests/web_search_engines/engines/test_search_engine_ddg.py+++ b/tests/web_search_engines/engines/test_search_engine_ddg.py@@ -93,8 +93,9 @@ class TestDuckDuckGoSearchEngineInit:assert engine.llm is mock_llm- def test_init_with_include_full_content(self):- """Initialize with include_full_content creates FullSearchResults."""+ def test_init_does_not_create_full_search(self):+ """DDG no longer self-wraps in ``__init__``. The factory wrapper+ is the canonical fetcher; the inner engine only emits snippets."""from local_deep_research.web_search_engines.engines.search_engine_ddg import (DuckDuckGoSearchEngine,)@@ -110,23 +111,7 @@ class TestDuckDuckGoSearchEngineInit:llm=mock_llm, include_full_content=True)- assert engine.include_full_content is True- mock_full_search.assert_called_once()-- def test_init_without_full_content_no_full_search(self):- """Initialize with include_full_content=False doesn't create FullSearchResults."""- from local_deep_research.web_search_engines.engines.search_engine_ddg import (- DuckDuckGoSearchEngine,- )-- with patch(- "local_deep_research.web_search_engines.engines.search_engine_ddg.DuckDuckGoSearchAPIWrapper"- ):- with patch(- "local_deep_research.web_search_engines.engines.full_search.FullSearchResults"- ) as mock_full_search:- DuckDuckGoSearchEngine(include_full_content=False)-+ assert not hasattr(engine, "full_search")mock_full_search.assert_not_called()@@ -289,41 +274,29 @@ class TestGetPreviews:class TestGetFullContent:- """Tests for _get_full_content method."""+ """Tests for _get_full_content method.++ Engines no longer self-wrap, so ``_get_full_content`` is a+ pass-through. The factory wrapper populates ``full_content`` after+ the inner engine runs.+ """- def test_get_full_content_with_full_search(self):- """Get full content uses FullSearchResults when available."""+ def test_get_full_content_passes_through(self):from local_deep_research.web_search_engines.engines.search_engine_ddg import (DuckDuckGoSearchEngine,)- mock_llm = Mock()with patch("local_deep_research.web_search_engines.engines.search_engine_ddg.DuckDuckGoSearchAPIWrapper"):- with patch(- "local_deep_research.web_search_engines.engines.full_search.FullSearchResults"- ) as mock_full_search_class:- mock_full_search = Mock()- mock_full_search._get_full_content.return_value = [- {"title": "Result", "full_content": "Full content here"}- ]- mock_full_search_class.return_value = mock_full_search-- engine = DuckDuckGoSearchEngine(- llm=mock_llm, include_full_content=True- )-- items = [{"title": "Result", "link": "https://example.com"}]- results = engine._get_full_content(items)+ engine = DuckDuckGoSearchEngine()- mock_full_search._get_full_content.assert_called_once_with(- items- )- assert results[0]["full_content"] == "Full content here"+ items = [{"title": "Result", "link": "https://example.com"}]+ assert engine._get_full_content(items) is items- def test_get_full_content_without_full_search(self):- """Get full content returns items as-is without FullSearchResults."""+ def test_engine_does_not_self_wrap(self):+ """DDG must not carry a ``full_search`` attribute; the factory+ wrapper handles full-content retrieval."""from local_deep_research.web_search_engines.engines.search_engine_ddg import (DuckDuckGoSearchEngine,)@@ -331,12 +304,9 @@ class TestGetFullContent:with patch("local_deep_research.web_search_engines.engines.search_engine_ddg.DuckDuckGoSearchAPIWrapper"):- engine = DuckDuckGoSearchEngine()-- items = [{"title": "Result", "link": "https://example.com"}]- results = engine._get_full_content(items)+ engine = DuckDuckGoSearchEngine(include_full_content=True)- assert results == items+ assert not hasattr(engine, "full_search")class TestRun:diff --git a/tests/web_search_engines/engines/test_search_engine_mojeek.py b/tests/web_search_engines/engines/test_search_engine_mojeek.pyindex 324ffb9113..d9a2d0a7e0 100644--- a/tests/web_search_engines/engines/test_search_engine_mojeek.py+++ b/tests/web_search_engines/engines/test_search_engine_mojeek.py@@ -546,44 +546,32 @@ class TestGetPreviews:class TestGetFullContent:- """Tests for _get_full_content method."""+ """Tests for _get_full_content method.- def test_with_full_search_attr(self):- """Test delegation to full_search._get_full_content."""+ Engines no longer self-wrap, so ``_get_full_content`` is a+ pass-through. The factory wrapper populates ``full_content`` after+ the inner engine runs.+ """++ def test_passes_through_items(self):from local_deep_research.web_search_engines.engines.search_engine_mojeek import (MojeekSearchEngine,)- engine = MojeekSearchEngine(- api_key="test-key", include_full_content=False- )- engine.include_full_content = True- engine.full_search = Mock()- engine.full_search._get_full_content.return_value = [- {"link": "https://example.com", "content": "Full content"}- ]-- items = [{"link": "https://example.com"}]- results = engine._get_full_content(items)+ engine = MojeekSearchEngine(api_key="test-key")- assert len(results) == 1- assert results[0]["content"] == "Full content"- engine.full_search._get_full_content.assert_called_once_with(items)+ items = [{"link": "https://example.com", "snippet": "test"}]+ assert engine._get_full_content(items) is items- def test_without_full_search_attr(self):- """Test returns items as-is when no full_search."""+ def test_engine_does_not_self_wrap(self):+ """The engine must not carry a ``full_search`` attribute; the+ factory wrapper handles full-content retrieval."""from local_deep_research.web_search_engines.engines.search_engine_mojeek import (MojeekSearchEngine,)- engine = MojeekSearchEngine(- api_key="test-key", include_full_content=False- )-- items = [{"link": "https://example.com", "snippet": "test"}]- results = engine._get_full_content(items)-- assert results == items+ engine = MojeekSearchEngine(api_key="test-key")+ assert not hasattr(engine, "full_search")class TestClassAttributes:diff --git a/tests/web_search_engines/engines/test_search_engine_searxng_coverage.py b/tests/web_search_engines/engines/test_search_engine_searxng_coverage.pyindex d1349ecc88..d101ec1ba5 100644--- a/tests/web_search_engines/engines/test_search_engine_searxng_coverage.py+++ b/tests/web_search_engines/engines/test_search_engine_searxng_coverage.py@@ -352,20 +352,15 @@ class TestGetSearchResultsURLFromTitleHref:# ----------------------------------------------------------------------------class TestGetFullContentException:- """_get_full_content returns original items on exception."""+class TestGetFullContentPassThrough:+ """_get_full_content returns original items."""- def test_exception_returns_original_items(self):+ def test_returns_original_items(self):+ # Engines no longer self-wrap, so _get_full_content is a pass-through.engine = _make_engine()items = [{"title": "T", "link": "https://example.com", "snippet": "S"}]- # Make full_search._get_full_content raise- engine.full_search = Mock()- engine.full_search._get_full_content.side_effect = RuntimeError("boom")-- result = engine._get_full_content(items)-- assert result is items+ assert engine._get_full_content(items) is items# ---------------------------------------------------------------------------diff --git a/tests/web_search_engines/engines/test_search_engine_serper_coverage.py b/tests/web_search_engines/engines/test_search_engine_serper_coverage.pyindex faabf247b6..d9f6e812a2 100644--- a/tests/web_search_engines/engines/test_search_engine_serper_coverage.py+++ b/tests/web_search_engines/engines/test_search_engine_serper_coverage.py@@ -169,49 +169,5 @@ class TestRateLimitFromRequestException:engine._get_previews("query")-# ----------------------------------------------------------------------------# Init -- full_search creation-# ------------------------------------------------------------------------------class TestInitFullSearchCreation:- """When include_full_content=True the engine creates a FullSearchResults."""-- def test_full_search_created_on_include_full_content(self):- mock_full_cls = Mock()- mock_full_instance = Mock()- mock_full_cls.return_value = mock_full_instance-- with patch(- "local_deep_research.web_search_engines.engines.full_search.FullSearchResults",- mock_full_cls,- ):- engine = _make_engine(include_full_content=True, llm=Mock())-- assert engine.include_full_content is True- assert engine.full_search is mock_full_instance- mock_full_cls.assert_called_once()- call_kwargs = mock_full_cls.call_args[1]- assert call_kwargs["web_search"] is None- assert call_kwargs["language"] == "en"---# ----------------------------------------------------------------------------# Init -- ImportError fallback-# ------------------------------------------------------------------------------class TestInitImportErrorFallback:- """When FullSearchResults cannot be imported, full content is disabled."""-- def test_import_error_disables_full_content(self):- with patch.dict(- "sys.modules",- {- "local_deep_research.web_search_engines.engines.full_search": None,- },- ):- engine = _make_engine(include_full_content=True, llm=Mock())-- # Should have been flipped to False due to ImportError- assert engine.include_full_content is False+# Note: TestInitFullSearchCreation and TestInitImportErrorFallback were removed+# because Serper no longer self-wraps; the factory wrapper handles full content.diff --git a/tests/web_search_engines/test_factory_full_search_wrapper.py b/tests/web_search_engines/test_factory_full_search_wrapper.pyindex fc96b6e629..3cb08baa0e 100644--- a/tests/web_search_engines/test_factory_full_search_wrapper.py+++ b/tests/web_search_engines/test_factory_full_search_wrapper.py@@ -20,6 +20,7 @@ from local_deep_research.web_search_engines.search_engine_base import ()from local_deep_research.web_search_engines.search_engine_factory import (_create_full_search_wrapper,+ create_search_engine,get_search,)@@ -357,3 +358,90 @@ class TestRegistryFullSearchWrapperEndToEnd:f"Expected {engine_name} to NOT be wrapped in FullSearchResults when supports_full_search=False")assert isinstance(result, _MockBaseEngine)++ @pytest.mark.parametrize("engine_name", FULL_SEARCH_ENGINES)+ def test_create_search_engine_snapshot_snippets_only_false_wraps(+ self, engine_name, mock_llm+ ):+ """Direct create_search_engine callers (langgraph tools) wrap when+ the snapshot says search.snippets_only=False, matching get_search."""+ settings_snapshot = {+ "search.tool": {"value": engine_name},+ "search.snippets_only": {"value": False},+ f"search.engine.web.{engine_name}.supports_full_search": {+ "value": True,+ "ui_element": "checkbox",+ },+ f"search.engine.web.{engine_name}.api_key": {+ "value": "mock-api-key"+ },+ }++ result = create_search_engine(+ engine_name,+ llm=mock_llm,+ settings_snapshot=settings_snapshot,+ programmatic_mode=True,+ )++ assert isinstance(result, FullSearchResults), (+ f"Expected {engine_name} to be wrapped in FullSearchResults when "+ "search.snippets_only=False via settings_snapshot"+ )+ assert isinstance(result.web_search, _MockBaseEngine)++ @pytest.mark.parametrize("engine_name", FULL_SEARCH_ENGINES)+ def test_create_search_engine_snapshot_snippets_only_true_bare(+ self, engine_name, mock_llm+ ):+ """Direct create_search_engine callers stay unwrapped when snippets_only=True."""+ settings_snapshot = {+ "search.tool": {"value": engine_name},+ "search.snippets_only": {"value": True},+ f"search.engine.web.{engine_name}.supports_full_search": {+ "value": True,+ "ui_element": "checkbox",+ },+ f"search.engine.web.{engine_name}.api_key": {+ "value": "mock-api-key"+ },+ }++ result = create_search_engine(+ engine_name,+ llm=mock_llm,+ settings_snapshot=settings_snapshot,+ programmatic_mode=True,+ )++ assert not isinstance(result, FullSearchResults), (+ f"Expected {engine_name} to stay unwrapped when search.snippets_only=True"+ )+ assert isinstance(result, _MockBaseEngine)++ @pytest.mark.parametrize("engine_name", FULL_SEARCH_ENGINES)+ def test_create_search_engine_explicit_use_full_search_false_wins(+ self, engine_name, mock_llm+ ):+ """Explicit use_full_search=False is not overridden by snippets_only=False."""+ settings_snapshot = {+ "search.tool": {"value": engine_name},+ "search.snippets_only": {"value": False},+ f"search.engine.web.{engine_name}.supports_full_search": {+ "value": True,+ "ui_element": "checkbox",+ },+ f"search.engine.web.{engine_name}.api_key": {+ "value": "mock-api-key"+ },+ }++ result = create_search_engine(+ engine_name,+ llm=mock_llm,+ settings_snapshot=settings_snapshot,+ programmatic_mode=True,+ use_full_search=False,+ )++ assert not isinstance(result, FullSearchResults)diff --git a/tests/web_search_engines/test_search_engine_factory.py b/tests/web_search_engines/test_search_engine_factory.pyindex cbab03d724..b321d55894 100644--- a/tests/web_search_engines/test_search_engine_factory.py+++ b/tests/web_search_engines/test_search_engine_factory.py@@ -245,6 +245,80 @@ class TestMaxResultsDefault:assert kwargs["max_results"] == 20+class TestResolveSnippetsOnly:+ """Tests for _resolve_snippets_only helper function."""++ @pytest.mark.parametrize(+ "raw_value,expected",+ [+ (True, True),+ (False, False),+ ("true", True),+ ("True", True),+ ("TRUE", True),+ ("1", True),+ ("yes", True),+ ("on", True),+ ("false", False),+ ("False", False),+ ("FALSE", False),+ ("0", False),+ ("no", False),+ ("off", False),+ ],+ )+ def test_direct_values(self, raw_value, expected):+ from local_deep_research.web_search_engines.search_engine_factory import (+ _resolve_snippets_only,+ )++ assert (+ _resolve_snippets_only({"search.snippets_only": raw_value})+ is expected+ )++ @pytest.mark.parametrize(+ "raw_value,expected",+ [+ (True, True),+ (False, False),+ ("true", True),+ ("false", False),+ ("1", True),+ ("0", False),+ ("yes", True),+ ("no", False),+ ("on", True),+ ("off", False),+ ],+ )+ def test_envelope_values(self, raw_value, expected):+ from local_deep_research.web_search_engines.search_engine_factory import (+ _resolve_snippets_only,+ )++ assert (+ _resolve_snippets_only(+ {"search.snippets_only": {"value": raw_value}}+ )+ is expected+ )++ def test_none_or_missing(self):+ from local_deep_research.web_search_engines.search_engine_factory import (+ _resolve_snippets_only,+ )++ assert _resolve_snippets_only(None) is None+ assert _resolve_snippets_only({}) is None+ assert _resolve_snippets_only({"other.key": True}) is None+ assert _resolve_snippets_only({"search.snippets_only": None}) is None+ assert (+ _resolve_snippets_only({"search.snippets_only": {"value": None}})+ is None+ )++class TestGetSearch:"""Tests for get_search function."""@@ -416,6 +490,85 @@ class TestGetSearch:call_kwargs = mock_create.call_args[1]assert call_kwargs["search_snippets_only"] is False+ def test_get_search_snippets_only_omitted_not_in_call_kwargs(self):+ """When search_snippets_only is omitted, get_search defaults to None+ and does not inject search_snippets_only into create_search_engine kwargs,+ avoiding overriding engine defaults."""+ mock_llm = Mock()++ with patch(+ "local_deep_research.web_search_engines.search_engine_factory.create_search_engine"+ ) as mock_create:+ mock_create.return_value = Mock()++ from local_deep_research.web_search_engines.search_engine_factory import (+ get_search,+ )++ get_search(+ search_tool="arxiv",+ llm_instance=mock_llm,+ max_results=10,+ settings_snapshot={"test": "value"},+ )++ call_kwargs = mock_create.call_args[1]+ assert "search_snippets_only" not in call_kwargs++ def test_get_search_use_full_search_routes_from_snapshot_when_omitted(self):+ """When search_snippets_only is omitted, engines supporting full search+ derive use_full_search from settings_snapshot."""+ mock_llm = Mock()++ with patch(+ "local_deep_research.web_search_engines.search_engine_factory.create_search_engine"+ ) as mock_create:+ mock_create.return_value = Mock()++ from local_deep_research.web_search_engines.search_engine_factory import (+ get_search,+ )++ # Snapshot has snippets_only=False -> use_full_search should be True+ get_search(+ search_tool="searxng",+ llm_instance=mock_llm,+ settings_snapshot={"search.snippets_only": {"value": False}},+ )+ assert mock_create.call_args[1]["use_full_search"] is True++ # Snapshot has snippets_only=True -> use_full_search should be False+ get_search(+ search_tool="searxng",+ llm_instance=mock_llm,+ settings_snapshot={"search.snippets_only": {"value": True}},+ )+ assert mock_create.call_args[1]["use_full_search"] is False++ # Snapshot has string "false" -> use_full_search should be True+ get_search(+ search_tool="searxng",+ llm_instance=mock_llm,+ settings_snapshot={"search.snippets_only": "false"},+ )+ assert mock_create.call_args[1]["use_full_search"] is True++ # Snapshot has dict string "false" -> use_full_search should be True+ get_search(+ search_tool="searxng",+ llm_instance=mock_llm,+ settings_snapshot={"search.snippets_only": {"value": "false"}},+ )+ assert mock_create.call_args[1]["use_full_search"] is True++ # Snapshot has no snippets_only setting -> use_full_search defaults to False+ get_search(+ search_tool="searxng",+ llm_instance=mock_llm,+ settings_snapshot={"test": "value"},+ )+ assert mock_create.call_args[1]["use_full_search"] is False+@pytest.mark.parametrize("snippets_only", [False, True])@pytest.mark.parametrize("search_tool,module_path,class_name,default_params",diff --git a/tests/web_search_engines/test_search_engine_factory_coverage.py b/tests/web_search_engines/test_search_engine_factory_coverage.pyindex dc27531933..13d7a64a70 100644--- a/tests/web_search_engines/test_search_engine_factory_coverage.py+++ b/tests/web_search_engines/test_search_engine_factory_coverage.py@@ -730,6 +730,173 @@ class TestUseFullSearchWrapper:assert not mock_wrapper.called+ def test_snippets_only_false_from_snapshot_derives_use_full_search(self):+ """settings_snapshot search.snippets_only=False wraps like get_search."""+ from local_deep_research.web_search_engines.search_engine_factory import (+ create_search_engine,+ )++ EngCls = _make_engine_class("max_results", "search_snippets_only")+ mock_wrapper_result = Mock()++ with _patches(+ config_return={"eng": _engine_config(supports_full_search=True)},+ class_return=EngCls,+ ):+ with patch(+ "local_deep_research.web_search_engines.search_engine_factory._create_full_search_wrapper"+ ) as mock_wrapper:+ mock_wrapper.return_value = mock_wrapper_result+ result = create_search_engine(+ "eng",+ settings_snapshot={+ "search.snippets_only": {"value": False}+ },+ )++ assert mock_wrapper.called+ assert result is mock_wrapper_result++ def test_snippets_only_true_from_snapshot_does_not_wrap(self):+ """settings_snapshot search.snippets_only=True does not wrap."""+ from local_deep_research.web_search_engines.search_engine_factory import (+ create_search_engine,+ )++ EngCls = _make_engine_class("max_results", "search_snippets_only")++ with _patches(+ config_return={"eng": _engine_config(supports_full_search=True)},+ class_return=EngCls,+ ):+ with patch(+ "local_deep_research.web_search_engines.search_engine_factory._create_full_search_wrapper"+ ) as mock_wrapper:+ create_search_engine(+ "eng",+ settings_snapshot={"search.snippets_only": True},+ )++ assert not mock_wrapper.called++ def test_explicit_use_full_search_false_overrides_snippets_only_false(self):+ """Explicit use_full_search=False wins over derived wrap."""+ from local_deep_research.web_search_engines.search_engine_factory import (+ create_search_engine,+ )++ EngCls = _make_engine_class("max_results", "search_snippets_only")++ with _patches(+ config_return={"eng": _engine_config(supports_full_search=True)},+ class_return=EngCls,+ ):+ with patch(+ "local_deep_research.web_search_engines.search_engine_factory._create_full_search_wrapper"+ ) as mock_wrapper:+ create_search_engine(+ "eng",+ settings_snapshot={"search.snippets_only": False},+ use_full_search=False,+ )++ assert not mock_wrapper.called++ def test_full_search_module_triggers_wrap(self):+ """Engines declaring ``full_search_module`` (registry engines) get+ wrapped the same way as engines declaring ``supports_full_search``+ (runtime engines) — the factory wrapper is the canonical fetcher.+ """+ from local_deep_research.web_search_engines.search_engine_factory import (+ create_search_engine,+ )++ EngCls = _make_engine_class("max_results", "search_snippets_only")+ mock_wrapper_result = Mock()++ with _patches(+ config_return={+ "eng": _engine_config(+ full_search_module=".engines.full_search"+ ),+ },+ class_return=EngCls,+ ):+ with patch(+ "local_deep_research.web_search_engines.search_engine_factory._create_full_search_wrapper"+ ) as mock_wrapper:+ mock_wrapper.return_value = mock_wrapper_result+ result = create_search_engine(+ "eng",+ settings_snapshot={"search.snippets_only": False},+ )++ assert mock_wrapper.called+ assert result is mock_wrapper_result++ def test_posts_search_snippets_only_when_engine_swallows_kwargs(self):+ """Engines that accept **kwargs but do not forward search_snippets_only+ still get the flag stamped on the BaseSearchEngine instance."""+ from local_deep_research.web_search_engines.search_engine_base import (+ BaseSearchEngine,+ )+ from local_deep_research.web_search_engines.search_engine_factory import (+ create_search_engine,+ )++ class SwallowEngine(BaseSearchEngine):+ def __init__(self, llm=None, settings_snapshot=None, **kwargs):+ super().__init__(llm=llm, settings_snapshot=settings_snapshot)++ def _get_previews(self, query):+ return []++ def _get_full_content(self, items):+ return items++ with _patches(+ config_return={"eng": _engine_config()},+ class_return=SwallowEngine,+ ):+ engine = create_search_engine(+ "eng",+ settings_snapshot={"search.snippets_only": False},+ programmatic_mode=True,+ )++ assert engine.search_snippets_only is False++ def test_no_wrap_keeps_inner_snippets_only_false(self):+ """Without wrap, engines that asked for full content keep it."""+ from local_deep_research.web_search_engines.search_engine_base import (+ BaseSearchEngine,+ )+ from local_deep_research.web_search_engines.search_engine_factory import (+ create_search_engine,+ )++ class SwallowEngine(BaseSearchEngine):+ def __init__(self, llm=None, settings_snapshot=None, **kwargs):+ super().__init__(llm=llm, settings_snapshot=settings_snapshot)++ def _get_previews(self, query):+ return []++ def _get_full_content(self, items):+ return items++ with _patches(+ config_return={"eng": _engine_config(supports_full_search=False)},+ class_return=SwallowEngine,+ ):+ engine = create_search_engine(+ "eng",+ settings_snapshot={"search.snippets_only": False},+ programmatic_mode=True,+ )++ assert engine.search_snippets_only is False+# ---------------------------------------------------------------------------# Tests: LLM relevance filter