Skip to content

~95% on SimpleQA (e.g. Qwen3.6-27B on a 3090). Supports all local and cloud LLMs (llama.cpp, Ollama, Google, ...). 10+ search engines - arXiv, PubMed, your private documents. Everything Local & Encrypted.

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.md
new file mode 100644
index 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.py
index 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.py
index 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 codes
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 filtering
settings_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.py
index 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 search
llm: Language model for relevance filtering
language: 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 content
return relevant_items
diff --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.py
index 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 filtering
max_filtered_results: Maximum number of results to keep after filtering
settings_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_search
self.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_items
diff --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.py
index 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 search
api_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 filtering
settings_snapshot: Settings snapshot for thread context
enable_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.py
index 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-effort
return False
def __init__(
@@ -186,7 +186,8 @@ class SearXNGSearchEngine(BaseSearchEngine):
delay_between_requests: Seconds to wait between requests
llm: Language model for relevance filtering
max_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_items
def 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.py
index 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 codes
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 filtering
settings_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.py
index 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 filtering
settings_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.py
index 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 filtering
search_depth: "basic" or "advanced" - controls search quality vs speed
include_domains: List of domains to include in search
@@ -90,24 +91,10 @@ class TavilySearchEngine(BaseSearchEngine):
self.api_key = tavily_api_key
self.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.py
index 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_config
TIME_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 requirements
requires_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/locale
time_period: Time period for search results
safe_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 results
max_filtered_results: Maximum number of results to keep after filtering
programmatic_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 provided
if 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 parameters
if 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_search
if 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_only
if 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.
+ pass
if search_tool == "wikinews":
- params["search_snippets_only"] = search_snippets_only
params["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.
+ pass
if search_tool in TIME_PERIOD_ENGINES:
params["time_period"] = time_period
diff --git a/tests/search_engines/test_search_engine_brave.py b/tests/search_engines/test_search_engine_brave.py
index 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.py
index 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.py
index 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.py
index 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 error
assert results == items
diff --git a/tests/search_engines/test_search_engine_serpapi.py b/tests/search_engines/test_search_engine_serpapi.py
index 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 work
engine = 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.py
index 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.py
index 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.py
index 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.py
index 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.py
index 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.py
index 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.py
index 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.py
index 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.py
index 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