Skip to content

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

fix(search): route search settings from snapshot and fix citation fallback (#6489) (#6490)

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