~95% on SimpleQA (e.g. Qwen3.6-27B on a 3090). Supports all local and cloud LLMs (llama.cpp, Ollama, Google, ...). 10+ search engines - arXiv, PubMed, your private documents. Everything Local & Encrypted.
Python academiaanthropicarxivbravedeep-researchencryptionhome-automationhomeserverlocallocal-deep-researchlocal-llmmistralollamaopenaipubmedresearchresearch-toolretrieval-augmented-generationsearxngself-hosted
fix(security): extend redact_secrets() coverage across LLM/embedding/search-engine log sites (#4131) (#4426)
LearningCircuit56521a77290e
diff --git a/changelog.d/4426.security.md b/changelog.d/4426.security.mdnew file mode 100644index 0000000000..fe27530299--- /dev/null+++ b/changelog.d/4426.security.md@@ -0,0 +1 @@+Extended `redact_secrets()` coverage from the Google provider (#4070) to every credential-bearing exception-logging call site: the OpenAI-compatible provider base (`list_models`), the custom OpenAI endpoint provider, the OpenAI embedding provider, and the web search-engine subsystem (`BaseSearchEngine.run()` plus the main HTTP-call error paths in Tavily, Exa, Serper, Google PSE, Mojeek, PubMed, Semantic Scholar, Guardian, ScaleSerp, SerpAPI, and GitHub). API keys embedded in upstream SDK error messages or echoed-back URLs/headers no longer leak into logs. Guardian and ScaleSerp chain explicit-value redaction with their existing regex sanitizers for defense in depth. Consolidates #4168, #4175, and #4181. See #4131.diff --git a/src/local_deep_research/embeddings/providers/implementations/openai.py b/src/local_deep_research/embeddings/providers/implementations/openai.pyindex f95c125455..6511ce2549 100644--- a/src/local_deep_research/embeddings/providers/implementations/openai.py+++ b/src/local_deep_research/embeddings/providers/implementations/openai.py@@ -7,6 +7,7 @@ from langchain_core.embeddings import Embeddingsfrom loguru import loggerfrom ....config.thread_settings import get_setting_from_snapshot+from ....security.log_sanitizer import redact_secretsfrom ....utilities.url_utils import normalize_urlfrom ..base import BaseEmbeddingProvider@@ -160,6 +161,7 @@ class OpenAIEmbeddingsProvider(BaseEmbeddingProvider):installation still reports unavailable so the UI doesn't listthe provider on first launch."""+ api_key = Nonetry:api_key = get_setting_from_snapshot("embeddings.openai.api_key",@@ -174,9 +176,14 @@ class OpenAIEmbeddingsProvider(BaseEmbeddingProvider):settings_snapshot=settings_snapshot,)return bool(base_url and str(base_url).strip())- except Exception:+ except Exception as e:+ # Drop exc_info — the traceback would render the exception's+ # cause chain, which may embed the api_key value if a+ # settings-layer error message ever surfaces it. Interpolate a+ # redacted exception message so debugging is still possible.+ safe_msg = redact_secrets(str(e), api_key)logger.debug(- "Error checking OpenAI embedding availability", exc_info=True+ f"Error checking OpenAI embedding availability: {safe_msg}")return False@@ -196,6 +203,9 @@ class OpenAIEmbeddingsProvider(BaseEmbeddingProvider):model the endpoint returns so the user can pick the one theyactually loaded."""+ # Initialized before the try so the except block can redact it+ # even if an early statement (e.g. the openai import) raises.+ api_key = Nonetry:from openai import OpenAI@@ -242,6 +252,14 @@ class OpenAIEmbeddingsProvider(BaseEmbeddingProvider):)return models- except Exception:- logger.exception("Error fetching OpenAI embedding models")+ except Exception as e:+ # Use logger.warning rather than logger.exception so the+ # exception's cause chain (which may embed the api_key in a+ # URL or auth header echoed back in the error body) is not+ # written to log sinks. The api_key value is also redacted+ # from str(e) as defense-in-depth.+ safe_msg = redact_secrets(str(e), api_key)+ logger.warning(+ f"Error fetching OpenAI embedding models: {safe_msg}"+ )return []diff --git a/src/local_deep_research/llm/providers/implementations/custom_openai_endpoint.py b/src/local_deep_research/llm/providers/implementations/custom_openai_endpoint.pyindex da6ab0db9d..1e90bd5c4e 100644--- a/src/local_deep_research/llm/providers/implementations/custom_openai_endpoint.py+++ b/src/local_deep_research/llm/providers/implementations/custom_openai_endpoint.py@@ -3,6 +3,7 @@from loguru import loggerfrom ....config.thread_settings import get_setting_from_snapshot+from ....security.log_sanitizer import redact_secretsfrom ....utilities.url_utils import normalize_urlfrom ..openai_base import OpenAICompatibleProvider@@ -44,6 +45,7 @@ class CustomOpenAIEndpointProvider(OpenAICompatibleProvider):considered configured when the user has set either an API key or aURL that differs from the default OpenAI endpoint."""+ api_key = Nonetry:api_key = get_setting_from_snapshot(cls.api_key_setting,@@ -52,11 +54,12 @@ class CustomOpenAIEndpointProvider(OpenAICompatibleProvider):)if api_key and str(api_key).strip():return True- except Exception:- logger.debug(- "Error checking provider availability",- exc_info=True,- )+ except Exception as e:+ # Drop exc_info — the cause chain may embed the api_key value+ # if a settings-layer error message surfaces it. Interpolate+ # a redacted exception message instead.+ safe_msg = redact_secrets(str(e), api_key)+ logger.debug(f"Error checking provider availability: {safe_msg}")try:custom_url = get_setting_from_snapshot(diff --git a/src/local_deep_research/llm/providers/openai_base.py b/src/local_deep_research/llm/providers/openai_base.pyindex 72ea69ba62..959fc3522d 100644--- a/src/local_deep_research/llm/providers/openai_base.py+++ b/src/local_deep_research/llm/providers/openai_base.py@@ -7,6 +7,7 @@ from ...config.thread_settings import (get_setting_from_snapshot,NoSettingsContextError,)+from ...security.log_sanitizer import redact_secretsfrom ...utilities.url_utils import normalize_urlfrom .base import BaseLLMProvider@@ -345,6 +346,14 @@ class OpenAICompatibleProvider(BaseLLMProvider):return cls.list_models_for_api(api_key, base_url)- except Exception:- logger.exception(f"Error listing models from {cls.provider_name}")+ except Exception as e:+ # Upstream exception messages (e.g., requests.HTTPError, OpenAI+ # SDK errors from a subclass that builds the URL with the key in+ # a query parameter) can embed the api_key value. Use+ # logger.warning rather than logger.exception so the cause chain+ # (which may also carry the URL) is not written to log sinks.+ safe_msg = redact_secrets(str(e), api_key)+ logger.warning(+ f"Error listing models from {cls.provider_name}: {safe_msg}"+ )return []diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_exa.py b/src/local_deep_research/web_search_engines/engines/search_engine_exa.pyindex 7992c8fa04..84468c1f15 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_exa.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_exa.py@@ -5,6 +5,7 @@ import requestsfrom langchain_core.language_models import BaseLLMfrom loguru import logger+from ...security.log_sanitizer import redact_secretsfrom ...security.safe_requests import safe_postfrom ..rate_limiting import RateLimitErrorfrom ..search_engine_base import BaseSearchEngine@@ -212,9 +213,11 @@ class ExaSearchEngine(BaseSearchEngine):except RateLimitError:raise # Re-raise rate limit errorsexcept requests.exceptions.RequestException as e:- logger.exception("Error getting Exa results")+ safe_msg = redact_secrets(str(e), self.api_key)+ logger.warning(f"Error getting Exa results: {safe_msg}")self._raise_if_rate_limit(e)return []- except Exception:- logger.exception("Unexpected error getting Exa results")+ except Exception as e:+ safe_msg = redact_secrets(str(e), self.api_key)+ logger.warning(f"Unexpected error getting Exa results: {safe_msg}")return []diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_github.py b/src/local_deep_research/web_search_engines/engines/search_engine_github.pyindex b68445bab3..02456406a0 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_github.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_github.py@@ -8,6 +8,7 @@ from loguru import loggerfrom ...config import llm_config, search_configfrom ...constants import USER_AGENT+from ...security.log_sanitizer import redact_secretsfrom ...security.safe_requests import safe_getfrom ...utilities.json_utils import extract_json, get_llm_response_textfrom ..search_engine_base import BaseSearchEngine@@ -266,8 +267,9 @@ class GitHubSearchEngine(BaseSearchEngine):f"GitHub API error: {response.status_code} - {response.text}")- except Exception:- logger.exception("Error searching GitHub")+ except Exception as e:+ safe_msg = redact_secrets(str(e), getattr(self, "api_key", None))+ logger.warning(f"Error searching GitHub: {safe_msg}")return resultsdiff --git a/src/local_deep_research/web_search_engines/engines/search_engine_google_pse.py b/src/local_deep_research/web_search_engines/engines/search_engine_google_pse.pyindex eb000fb201..49894c3a44 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_google_pse.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_google_pse.py@@ -6,6 +6,7 @@ from typing import Any, Dict, List, Optionalfrom langchain_core.language_models import BaseLLMfrom requests.exceptions import RequestException+from ...security.log_sanitizer import redact_secretsfrom ...security.safe_requests import safe_getfrom ..rate_limiting import RateLimitErrorfrom ..search_engine_base import BaseSearchEngine@@ -162,9 +163,17 @@ class GooglePSESearchEngine(BaseSearchEngine):logger.info("Google PSE connection validated successfully")return True- except Exception:- # Log the error and re-raise- logger.exception("Error validating Google PSE connection")+ except Exception as e:+ # Log the error and re-raise. Use logger.warning with the+ # api_key redacted from str(e) so the upstream exception+ # message — which can embed the key in the URL — does not+ # leak. The traceback that propagates with `raise` may still+ # be logged by a higher-level handler; future work to scrub+ # `exc.args` is tracked in the #4131 follow-up issue.+ safe_msg = redact_secrets(str(e), self.api_key)+ logger.warning(+ f"Error validating Google PSE connection: {safe_msg}"+ )raisedef _respect_rate_limit(self):@@ -354,8 +363,9 @@ class GooglePSESearchEngine(BaseSearchEngine):# Update start index for next requeststart_index += len(items)- except Exception:- logger.exception("Error getting search results")+ except Exception as e:+ safe_msg = redact_secrets(str(e), self.api_key)+ logger.warning(f"Error getting search results: {safe_msg}")breaklogger.info(diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_guardian.py b/src/local_deep_research/web_search_engines/engines/search_engine_guardian.pyindex 1fb1e38e0f..07aee80b02 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_guardian.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_guardian.py@@ -5,6 +5,7 @@ from langchain_core.language_models import BaseLLMfrom loguru import loggerfrom ...utilities.search_utilities import remove_think_tags+from ...security.log_sanitizer import redact_secretsfrom ...security.safe_requests import safe_getfrom ..rate_limiting import RateLimitErrorfrom ..search_engine_base import BaseSearchEngine@@ -425,9 +426,15 @@ ONE WORD ONLY:"""except RateLimitError:raiseexcept Exception as e:+ # Chain both scrubbers: explicit-value redaction catches the+ # known api_key, regex-based _sanitize_error_message catches+ # unknown credential shapes (Bearer tokens, ?key= URLs) that+ # the upstream might echo back. Use logger.warning to drop+ # the traceback chain.sanitized = self._sanitize_error_message(str(e))- logger.exception(- "Error getting data from The Guardian API: {}", sanitized+ safe_msg = redact_secrets(sanitized, getattr(self, "api_key", None))+ logger.warning(+ f"Error getting data from The Guardian API: {safe_msg}")self._raise_if_rate_limit(e)return []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.pyindex 1d947093e9..602ea0475f 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@@ -4,6 +4,7 @@ from langchain_core.language_models import BaseLLMfrom loguru import loggerfrom ...config import search_config+from ...security.log_sanitizer import redact_secretsfrom ...security.safe_requests import safe_getfrom ..rate_limiting import RateLimitErrorfrom ..search_engine_base import BaseSearchEngine@@ -180,8 +181,9 @@ class MojeekSearchEngine(BaseSearchEngine):except RateLimitError:raise- except Exception:- logger.exception("Error when searching using Mojeek")+ except Exception as e:+ safe_msg = redact_secrets(str(e), getattr(self, "api_key", None))+ logger.warning(f"Error when searching using Mojeek: {safe_msg}")return []def _get_previews(self, query: str) -> List[Dict[str, Any]]:diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_pubmed.py b/src/local_deep_research/web_search_engines/engines/search_engine_pubmed.pyindex ed63a0a4bc..1c298d28cc 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_pubmed.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_pubmed.py@@ -8,6 +8,7 @@ from loguru import loggerfrom ...config import search_configfrom ...constants import SNIPPET_LENGTH_LONG+from ...security.log_sanitizer import redact_secretsfrom ...security.safe_requests import safe_getfrom ...advanced_search_system.filters.journal_reputation_filter import (JournalReputationFilter,@@ -166,8 +167,9 @@ class PubMedSearchEngine(BaseSearchEngine):)return count- except Exception:- logger.exception("Error getting result count")+ except Exception as e:+ safe_msg = redact_secrets(str(e), getattr(self, "api_key", None))+ logger.warning(f"Error getting result count: {safe_msg}")return 0def _extract_core_terms(self, query: str) -> str:@@ -672,8 +674,11 @@ The default assumption should be that medical and scientific queries want RECENTlogger.debug(f"First 5 PMIDs: {id_list[:5]}")return id_list- except Exception:- logger.exception(f"Error searching PubMed for query '{query}'")+ except Exception as e:+ safe_msg = redact_secrets(str(e), getattr(self, "api_key", None))+ logger.warning(+ f"Error searching PubMed for query '{query}': {safe_msg}"+ )return []def _get_article_summaries(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.pyindex 1e1cf8e6e9..9d8c6e480b 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@@ -8,6 +8,7 @@ from langchain_core.language_models import BaseLLMfrom ..search_engine_base import BaseSearchEnginefrom ..rate_limiting import RateLimitErrorfrom ...security import safe_get+from ...security.log_sanitizer import redact_secretsclass ScaleSerpSearchEngine(BaseSearchEngine):@@ -228,16 +229,18 @@ class ScaleSerpSearchEngine(BaseSearchEngine):raise # Re-raise rate limit errorsexcept requests.exceptions.RequestException as e:sanitized = self._sanitize_error_message(str(e))- logger.exception(- "Error getting ScaleSerp API results: {}. Check API docs: https://docs.scaleserp.com",- sanitized,+ safe_msg = redact_secrets(sanitized, getattr(self, "api_key", None))+ logger.warning(+ f"Error getting ScaleSerp API results: {safe_msg}. "+ "Check API docs: https://docs.scaleserp.com")self._raise_if_rate_limit(e)return []except Exception as e:sanitized = self._sanitize_error_message(str(e))- logger.exception(- "Unexpected error getting ScaleSerp API results: {}", sanitized+ safe_msg = redact_secrets(sanitized, getattr(self, "api_key", None))+ logger.warning(+ f"Unexpected error getting ScaleSerp API results: {safe_msg}")return []diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_semantic_scholar.py b/src/local_deep_research/web_search_engines/engines/search_engine_semantic_scholar.pyindex eb731aeb66..3b31b6a701 100644--- a/src/local_deep_research/web_search_engines/engines/search_engine_semantic_scholar.py+++ b/src/local_deep_research/web_search_engines/engines/search_engine_semantic_scholar.py@@ -11,6 +11,7 @@ from ...constants import SNIPPET_LENGTH_SHORTfrom ..rate_limiting import RateLimitErrorfrom ..search_engine_base import BaseSearchEnginefrom ...security import SafeSession+from ...security.log_sanitizer import redact_secretsclass SemanticScholarSearchEngine(BaseSearchEngine):@@ -254,8 +255,9 @@ class SemanticScholarSearchEngine(BaseSearchEngine):response.raise_for_status()return response.json() # type: ignore[no-any-return]- except requests.RequestException:- logger.exception("API request failed")+ except requests.RequestException as e:+ safe_msg = redact_secrets(str(e), getattr(self, "api_key", None))+ logger.warning(f"API request failed: {safe_msg}")return {}def _optimize_query(self, query: str) -> str:diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_serpapi.py b/src/local_deep_research/web_search_engines/engines/search_engine_serpapi.pyindex 54ae557265..8d4729b5bf 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@@ -6,6 +6,7 @@ from langchain_core.language_models import BaseLLMfrom ..rate_limiting import RateLimitErrorfrom ..search_engine_base import BaseSearchEngine+from ...security.log_sanitizer import redact_secretsclass SerpAPISearchEngine(BaseSearchEngine):@@ -150,6 +151,10 @@ class SerpAPISearchEngine(BaseSearchEngine):except RateLimitError:raiseexcept Exception as e:- logger.exception("Error getting SerpAPI results")+ # SerpAPI api_key is passed to SerpAPIWrapper but not stored+ # on self. Use getattr fallback so future code that does store+ # it (e.g. as self.api_key) gets covered automatically.+ safe_msg = redact_secrets(str(e), getattr(self, "api_key", None))+ logger.warning(f"Error getting SerpAPI results: {safe_msg}")self._raise_if_rate_limit(e)return []diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_serper.py b/src/local_deep_research/web_search_engines/engines/search_engine_serper.pyindex ff8c6e7eee..506b3032ad 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@@ -8,6 +8,7 @@ from langchain_core.language_models import BaseLLMfrom ..search_engine_base import BaseSearchEnginefrom ..rate_limiting import RateLimitErrorfrom ...security import safe_post+from ...security.log_sanitizer import redact_secretsclass SerperSearchEngine(BaseSearchEngine):@@ -223,11 +224,15 @@ class SerperSearchEngine(BaseSearchEngine):except RateLimitError:raise # Re-raise rate limit errorsexcept requests.exceptions.RequestException as e:- logger.exception("Error getting Serper API results")+ safe_msg = redact_secrets(str(e), self.api_key)+ logger.warning(f"Error getting Serper API results: {safe_msg}")self._raise_if_rate_limit(e)return []- except Exception:- logger.exception("Unexpected error getting Serper API results")+ except Exception as e:+ safe_msg = redact_secrets(str(e), self.api_key)+ logger.warning(+ f"Unexpected error getting Serper API results: {safe_msg}"+ )return []def _get_full_content(diff --git a/src/local_deep_research/web_search_engines/engines/search_engine_tavily.py b/src/local_deep_research/web_search_engines/engines/search_engine_tavily.pyindex f46df95024..c722d01919 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@@ -4,6 +4,7 @@ import requestsfrom langchain_core.language_models import BaseLLMfrom loguru import logger+from ...security.log_sanitizer import redact_secretsfrom ...security.safe_requests import safe_postfrom ..rate_limiting import RateLimitErrorfrom ..search_engine_base import BaseSearchEngine@@ -176,11 +177,15 @@ class TavilySearchEngine(BaseSearchEngine):except RateLimitError:raise # Re-raise rate limit errorsexcept requests.exceptions.RequestException as e:- logger.exception("Error getting Tavily results")+ safe_msg = redact_secrets(str(e), self.api_key)+ logger.warning(f"Error getting Tavily results: {safe_msg}")self._raise_if_rate_limit(e)return []- except Exception:- logger.exception("Unexpected error getting Tavily results")+ except Exception as e:+ safe_msg = redact_secrets(str(e), self.api_key)+ logger.warning(+ f"Unexpected error getting Tavily results: {safe_msg}"+ )return []def _get_full_content(diff --git a/src/local_deep_research/web_search_engines/search_engine_base.py b/src/local_deep_research/web_search_engines/search_engine_base.pyindex d5eb3d9e75..dd032829d9 100644--- a/src/local_deep_research/web_search_engines/search_engine_base.py+++ b/src/local_deep_research/web_search_engines/search_engine_base.py@@ -17,6 +17,7 @@ from tenacity.wait import wait_basefrom ..advanced_search_system.filters.base_filter import BaseFilterfrom ..config.constants import DEFAULT_MAX_FILTERED_RESULTSfrom ..config.thread_settings import get_setting_from_snapshot+from ..security.log_sanitizer import redact_secretsfrom ..utilities.thread_context import clear_search_context, set_search_contextfrom .rate_limiting import RateLimitError, get_tracker@@ -538,8 +539,15 @@ class BaseSearchEngine(ABC):# Other errors - don't retrysuccess = Falseerror_message = str(e)- logger.exception(- f"Search engine {self.__class__.__name__} failed"+ # Use logger.warning with redacted exception text instead of+ # logger.exception: the cause chain frequently carries the+ # request URL or auth header from upstream HTTP clients,+ # which may embed self.api_key (see #4131).+ safe_msg = redact_secrets(+ str(e), getattr(self, "api_key", None)+ )+ logger.warning(+ f"Search engine {self.__class__.__name__} failed: {safe_msg}")results_count = 0return []@@ -550,14 +558,18 @@ class BaseSearchEngine(ABC):# All retries exhaustedsuccess = Falseerror_message = f"Rate limited after all retries: {e}"- logger.exception(- f"{self.__class__.__name__} failed after all retries"+ safe_msg = redact_secrets(str(e), getattr(self, "api_key", None))+ logger.warning(+ f"{self.__class__.__name__} failed after all retries: {safe_msg}")return []except Exception as e:success = Falseerror_message = str(e)- logger.exception(f"Search engine {self.__class__.__name__} error")+ safe_msg = redact_secrets(str(e), getattr(self, "api_key", None))+ logger.warning(+ f"Search engine {self.__class__.__name__} error: {safe_msg}"+ )return []finally:try:diff --git a/tests/conftest.py b/tests/conftest.pyindex 636468bd09..e06d87c063 100644--- a/tests/conftest.py+++ b/tests/conftest.py@@ -664,3 +664,41 @@ def loguru_caplog(caplog):logger.remove(handler_id)# Re-disable logging to restore original statelogger.disable("local_deep_research")+++def loguru_caplog_full(caplog):+ """Like ``loguru_caplog`` but captures the exception block too.++ Use this in security tests that assert a credential never appears in+ log output. The default ``loguru_caplog`` fixture uses+ ``format="{message}"``, which excludes the rendered exception block+ that ``logger.exception()`` (and ``exc_info=True``) emit — so a leak+ that lives only in the traceback would false-pass.++ This fixture appends ``{exception}`` to the format and enables+ ``backtrace=True`` so the cause chain (``__cause__`` / ``__context__``)+ is rendered. ``diagnose`` stays off to match production+ (``utilities/log_utils.py`` runs ``diagnose=False`` unless+ ``LDR_APP_DEBUG`` is set).+ """+ import logging++ from loguru import logger++ class PropagateHandler(logging.Handler):+ def emit(self, record):+ logging.getLogger(record.name).handle(record)++ logger.enable("local_deep_research")++ handler_id = logger.add(+ PropagateHandler(),+ format="{message}\n{exception}",+ level="DEBUG",+ backtrace=True,+ diagnose=False,+ )+ yield caplog+ logger.remove(handler_id)+ logger.disable("local_deep_research")diff --git a/tests/security/test_api_key_leakage.py b/tests/security/test_api_key_leakage.pyindex abcf6a46b2..ba8a598e79 100644--- a/tests/security/test_api_key_leakage.py+++ b/tests/security/test_api_key_leakage.py@@ -12,17 +12,40 @@ The tests below pin no-leak behavior across a few representativeproviders, with the Google case being the one that previously failed."""+import base64from unittest.mock import patch+from urllib.parse import quote, quote_plusimport pytestimport requests# A recognizable sentinel that should never appear in any logged or-# returned text after these tests run.+# returned text after these tests run. Kept URL-safe so it can be+# embedded literally in test URLs without confusing `urllib.parse`; the+# encoding-matrix helper covers non-URL transformations (base64, repr,+# truncation) that *do* change shape._LEAKED_KEY = "sk-leaked-sentinel-DO-NOT-APPEAR-12345"+def _all_encodings_of(secret: str) -> list:+ """Return every encoding of *secret* a leak might appear under.++ Used by the leak tests to assert no form of the sentinel reaches the+ log output. New providers / engines that introduce different encoding+ paths (e.g., a SDK that wraps the key in a JWT) should extend this+ helper so the contract scales.+ """+ return [+ secret,+ quote(secret, safe=""), # %-encoded for ?key=+ quote_plus(secret), # +-encoded for form-urlencoded+ repr(secret)[1:-1], # f-string {x!r} leak shape+ base64.b64encode(secret.encode()).decode(),+ secret[:8], # partial-leak (mask formatters)+ ]++@pytest.fixturedef google_provider_module():"""Late-import the Google provider so the test's loguru_caplog@@ -198,3 +221,257 @@ class TestOpenAICompatErrorRedaction:"_strip_credentials must remove userinfo from base_url before ""the URL is embedded in the friendly message")+++class TestOpenAIBaseProviderKeyLeakage:+ """``OpenAICompatibleProvider.list_models`` wraps the inner+ ``list_models_for_api`` call. If a subclass override raises (or the+ settings-fetch path raises while the api_key is in scope), the+ upstream exception's ``str()`` may embed the key. The except block at+ ``openai_base.py`` redacts the key from the exception string and uses+ ``logger.warning`` (no traceback) to keep the cause chain off the log.++ These tests use ``loguru_caplog_full`` — the stricter fixture that+ captures the rendered exception block — so a leak that lives only in+ the traceback would be caught. The vanilla ``loguru_caplog`` fixture+ uses ``format='{message}'`` and would false-pass on a traceback leak.+ """++ def test_no_leak_when_inner_call_raises_with_url_in_message(+ self, loguru_caplog_full+ ):+ """A subclass override of ``list_models_for_api`` that constructs+ the auth URL with the key in a query parameter (the Google+ pattern) and then raises a ``requests`` exception embedding that+ URL must not leak the key.+ """+ from local_deep_research.llm.providers.openai_base import (+ OpenAICompatibleProvider,+ )++ exc = requests.exceptions.ConnectionError(+ "HTTPSConnectionPool: Max retries exceeded with url: "+ f"/v1/models?key={_LEAKED_KEY}"+ )++ with loguru_caplog_full.at_level("DEBUG"):+ with patch.object(+ OpenAICompatibleProvider,+ "list_models_for_api",+ side_effect=exc,+ ):+ with patch.object(+ OpenAICompatibleProvider,+ "requires_auth_for_models",+ return_value=False,+ ):+ with patch(+ "local_deep_research.llm.providers.openai_base."+ "get_setting_from_snapshot",+ return_value=_LEAKED_KEY,+ ):+ # Subclass override drives auth-required to True so+ # api_key flows through the settings path.+ OpenAICompatibleProvider.requires_auth_for_models = (+ classmethod(lambda cls: True)+ )+ try:+ result = OpenAICompatibleProvider.list_models()+ finally:+ del OpenAICompatibleProvider.requires_auth_for_models++ assert result == []+ for encoding in _all_encodings_of(_LEAKED_KEY):+ assert encoding not in loguru_caplog_full.text, (+ f"API key leaked into logs as encoding {encoding!r}. "+ f"The except handler must pass the key to redact_secrets "+ f"and use logger.warning (not logger.exception)."+ )+ # Sanity: we did exercise the except branch.+ assert "Error listing models" in loguru_caplog_full.text++ def test_no_leak_when_inner_call_raises_generic_runtime_error(+ self, loguru_caplog_full+ ):+ """Some upstream failures raise generic exceptions whose ``str()``+ embeds the URL. Redaction must handle that path too — not just+ ``requests`` exception subclasses.+ """+ from local_deep_research.llm.providers.openai_base import (+ OpenAICompatibleProvider,+ )++ exc = RuntimeError(+ f"call to /v1/models?key={_LEAKED_KEY} failed: connection reset"+ )++ with loguru_caplog_full.at_level("DEBUG"):+ with patch.object(+ OpenAICompatibleProvider,+ "list_models_for_api",+ side_effect=exc,+ ):+ with patch(+ "local_deep_research.llm.providers.openai_base."+ "get_setting_from_snapshot",+ return_value=_LEAKED_KEY,+ ):+ OpenAICompatibleProvider.requires_auth_for_models = (+ classmethod(lambda cls: True)+ )+ try:+ OpenAICompatibleProvider.list_models()+ finally:+ del OpenAICompatibleProvider.requires_auth_for_models++ for encoding in _all_encodings_of(_LEAKED_KEY):+ assert encoding not in loguru_caplog_full.text, (+ f"API key leaked as encoding {encoding!r}"+ )+++class TestOpenAIEmbeddingProviderKeyLeakage:+ """``OpenAIEmbeddingsProvider.get_available_models`` calls the OpenAI+ SDK's ``client.models.list()`` with the api_key in scope. If the SDK+ raises (e.g., the base_url points at a misconfigured proxy that+ echoes the bearer token in its error body), the except handler at+ ``embeddings/providers/implementations/openai.py`` must redact the+ key before logging.+ """++ def test_no_leak_when_models_list_raises_with_key_in_message(+ self, loguru_caplog_full+ ):+ from local_deep_research.embeddings.providers.implementations.openai import (+ OpenAIEmbeddingsProvider,+ )++ def _settings_lookup(key, default=None, settings_snapshot=None):+ if key == "embeddings.openai.api_key":+ return _LEAKED_KEY+ if key == "embeddings.openai.base_url":+ return None+ return default++ exc = RuntimeError(+ f"upstream proxy echoed Authorization: Bearer {_LEAKED_KEY}"+ )++ class _Models:+ def list(self_inner):+ raise exc++ class _FakeOpenAI:+ def __init__(self, **kwargs):+ self.models = _Models()++ with loguru_caplog_full.at_level("DEBUG"):+ with patch(+ "local_deep_research.embeddings.providers.implementations."+ "openai.get_setting_from_snapshot",+ side_effect=_settings_lookup,+ ):+ with patch("openai.OpenAI", _FakeOpenAI):+ result = OpenAIEmbeddingsProvider.get_available_models()++ assert result == []+ for encoding in _all_encodings_of(_LEAKED_KEY):+ assert encoding not in loguru_caplog_full.text, (+ f"API key leaked as encoding {encoding!r}. The except "+ f"handler at openai.py:218 must redact via "+ f"redact_secrets(str(e), api_key) and use logger.warning."+ )+ # Sanity: the except branch ran.+ assert (+ "Error fetching OpenAI embedding models" in loguru_caplog_full.text+ )+++class TestSearchEngineKeyLeakage:+ """Pin no-leak behavior across representative search engines whose+ HTTP-call error paths were wrapped in #4131. The base-class fix in+ ``search_engine_base.py`` covers the catch-all path, but engines+ that catch+swallow inside ``_get_previews`` need their own wrap —+ these tests cover those direct call sites.+ """++ def test_tavily_get_previews_does_not_leak_on_request_exception(+ self, loguru_caplog_full+ ):+ """Tavily's ``_get_previews`` catches+ ``requests.exceptions.RequestException`` and logs it. The except+ block must redact ``self.api_key`` from the rendered exception+ text. We drive this by patching ``safe_post`` to raise an+ exception whose ``str()`` embeds the sentinel in the URL.++ Tavily is the representative engine for this contract; the+ base-class fix in ``search_engine_base.py`` covers the+ catch-all path for all subclasses (see ``run()``). Other+ engines have engine-specific attribute requirements that make+ a parametrized test brittle without a fuller fixture suite —+ tracked as follow-up to #4131.+ """+ from local_deep_research.web_search_engines.engines import (+ search_engine_tavily as mod,+ )++ EngineCls = mod.TavilySearchEngine+ engine_class = "TavilySearchEngine"+ api_attr = "api_key"++ # Build an instance without going through normal __init__ — the+ # engines have settings-dependent __init__ paths that complicate+ # test setup. Provide every attribute referenced before safe_post+ # so the test actually reaches the leak-vector code path.+ engine = EngineCls.__new__(EngineCls)+ setattr(engine, api_attr, _LEAKED_KEY)+ engine.max_results = 10+ engine.search_depth = "basic"+ engine.include_full_content = False+ engine.include_domains = []+ engine.exclude_domains = []+ engine.base_url = "https://api.example.com"+ engine.engine_type = "test_engine"+ engine._search_results = None+ # Avoid the rate-limit-tracker dependency: stub apply_rate_limit+ # to return 0 and engine_type lookup to noop. Tavily/Exa each call+ # ``self.rate_tracker.apply_rate_limit(self.engine_type)`` before+ # the HTTP request.+ engine.rate_tracker = type(+ "_T",+ (),+ {+ "enabled": False,+ "record_event": lambda *a, **k: None,+ "apply_rate_limit": lambda *a, **k: 0,+ },+ )()+ # ``_raise_if_rate_limit`` is a base-class method that inspects+ # the response status code; with a non-HTTP exception passed in,+ # it must not itself raise. Stub it to a no-op for safety.+ engine._raise_if_rate_limit = lambda *a, **k: None++ exc = requests.exceptions.ConnectionError(+ f"HTTPSConnectionPool: Max retries exceeded with url: "+ f"/v1/search?api_key={_LEAKED_KEY}"+ )++ with loguru_caplog_full.at_level("DEBUG"):+ with patch.object(mod, "safe_post", side_effect=exc, create=True):+ try:+ engine._get_previews("test query")+ except Exception:+ pass++ for encoding in _all_encodings_of(_LEAKED_KEY):+ assert encoding not in loguru_caplog_full.text, (+ f"{engine_class} leaked api_key as encoding {encoding!r}. "+ f"The except block must call "+ f"redact_secrets(str(e), self.{api_attr}) before logging."+ )+ # Sanity: the except branch must have actually run — otherwise the+ # leak assertion passes trivially.+ assert "Error getting Tavily" in loguru_caplog_full.text, (+ f"{engine_class} test did not exercise the except branch. "+ f"Captured logs: {loguru_caplog_full.text!r}"+ )