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(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.md
new file mode 100644
index 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.py
index 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 Embeddings
from loguru import logger
from ....config.thread_settings import get_setting_from_snapshot
+from ....security.log_sanitizer import redact_secrets
from ....utilities.url_utils import normalize_url
from ..base import BaseEmbeddingProvider
@@ -160,6 +161,7 @@ class OpenAIEmbeddingsProvider(BaseEmbeddingProvider):
installation still reports unavailable so the UI doesn't list
the provider on first launch.
"""
+ api_key = None
try:
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 they
actually 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 = None
try:
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.py
index 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 logger
from ....config.thread_settings import get_setting_from_snapshot
+from ....security.log_sanitizer import redact_secrets
from ....utilities.url_utils import normalize_url
from ..openai_base import OpenAICompatibleProvider
@@ -44,6 +45,7 @@ class CustomOpenAIEndpointProvider(OpenAICompatibleProvider):
considered configured when the user has set either an API key or a
URL that differs from the default OpenAI endpoint.
"""
+ api_key = None
try:
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.py
index 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_secrets
from ...utilities.url_utils import normalize_url
from .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.py
index 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 requests
from langchain_core.language_models import BaseLLM
from loguru import logger
+from ...security.log_sanitizer import redact_secrets
from ...security.safe_requests import safe_post
from ..rate_limiting import RateLimitError
from ..search_engine_base import BaseSearchEngine
@@ -212,9 +213,11 @@ class ExaSearchEngine(BaseSearchEngine):
except RateLimitError:
raise # Re-raise rate limit errors
except 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.py
index 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 logger
from ...config import llm_config, search_config
from ...constants import USER_AGENT
+from ...security.log_sanitizer import redact_secrets
from ...security.safe_requests import safe_get
from ...utilities.json_utils import extract_json, get_llm_response_text
from ..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 results
diff --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.py
index 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, Optional
from langchain_core.language_models import BaseLLM
from requests.exceptions import RequestException
+from ...security.log_sanitizer import redact_secrets
from ...security.safe_requests import safe_get
from ..rate_limiting import RateLimitError
from ..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}"
+ )
raise
def _respect_rate_limit(self):
@@ -354,8 +363,9 @@ class GooglePSESearchEngine(BaseSearchEngine):
# Update start index for next request
start_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}")
break
logger.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.py
index 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 BaseLLM
from loguru import logger
from ...utilities.search_utilities import remove_think_tags
+from ...security.log_sanitizer import redact_secrets
from ...security.safe_requests import safe_get
from ..rate_limiting import RateLimitError
from ..search_engine_base import BaseSearchEngine
@@ -425,9 +426,15 @@ ONE WORD ONLY:"""
except RateLimitError:
raise
except 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.py
index 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 BaseLLM
from loguru import logger
from ...config import search_config
+from ...security.log_sanitizer import redact_secrets
from ...security.safe_requests import safe_get
from ..rate_limiting import RateLimitError
from ..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.py
index 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 logger
from ...config import search_config
from ...constants import SNIPPET_LENGTH_LONG
+from ...security.log_sanitizer import redact_secrets
from ...security.safe_requests import safe_get
from ...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 0
def _extract_core_terms(self, query: str) -> str:
@@ -672,8 +674,11 @@ The default assumption should be that medical and scientific queries want RECENT
logger.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.py
index 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 BaseLLM
from ..search_engine_base import BaseSearchEngine
from ..rate_limiting import RateLimitError
from ...security import safe_get
+from ...security.log_sanitizer import redact_secrets
class ScaleSerpSearchEngine(BaseSearchEngine):
@@ -228,16 +229,18 @@ class ScaleSerpSearchEngine(BaseSearchEngine):
raise # Re-raise rate limit errors
except 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.py
index 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_SHORT
from ..rate_limiting import RateLimitError
from ..search_engine_base import BaseSearchEngine
from ...security import SafeSession
+from ...security.log_sanitizer import redact_secrets
class 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.py
index 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 BaseLLM
from ..rate_limiting import RateLimitError
from ..search_engine_base import BaseSearchEngine
+from ...security.log_sanitizer import redact_secrets
class SerpAPISearchEngine(BaseSearchEngine):
@@ -150,6 +151,10 @@ class SerpAPISearchEngine(BaseSearchEngine):
except RateLimitError:
raise
except 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.py
index 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 BaseLLM
from ..search_engine_base import BaseSearchEngine
from ..rate_limiting import RateLimitError
from ...security import safe_post
+from ...security.log_sanitizer import redact_secrets
class SerperSearchEngine(BaseSearchEngine):
@@ -223,11 +224,15 @@ class SerperSearchEngine(BaseSearchEngine):
except RateLimitError:
raise # Re-raise rate limit errors
except 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.py
index 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 requests
from langchain_core.language_models import BaseLLM
from loguru import logger
+from ...security.log_sanitizer import redact_secrets
from ...security.safe_requests import safe_post
from ..rate_limiting import RateLimitError
from ..search_engine_base import BaseSearchEngine
@@ -176,11 +177,15 @@ class TavilySearchEngine(BaseSearchEngine):
except RateLimitError:
raise # Re-raise rate limit errors
except 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.py
index 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_base
from ..advanced_search_system.filters.base_filter import BaseFilter
from ..config.constants import DEFAULT_MAX_FILTERED_RESULTS
from ..config.thread_settings import get_setting_from_snapshot
+from ..security.log_sanitizer import redact_secrets
from ..utilities.thread_context import clear_search_context, set_search_context
from .rate_limiting import RateLimitError, get_tracker
@@ -538,8 +539,15 @@ class BaseSearchEngine(ABC):
# Other errors - don't retry
success = False
error_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 = 0
return []
@@ -550,14 +558,18 @@ class BaseSearchEngine(ABC):
# All retries exhausted
success = False
error_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 = False
error_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.py
index 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 state
logger.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.py
index 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 representative
providers, with the Google case being the one that previously failed.
"""
+import base64
from unittest.mock import patch
+from urllib.parse import quote, quote_plus
import pytest
import 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.fixture
def 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}"
+ )