unique_web_search 2026.44.0.dev2__tar.gz → 2026.44.0.dev4__tar.gz

{unique_web_search-2026.44.0.dev2 → unique_web_search-2026.44.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-web-search
-Version: 2026.44.0.dev2
+Version: 2026.44.0.dev4
 Summary: 
 Author: Andreas Hauri, Gustav Hartz, Rami Azouz
 Author-email: Andreas Hauri <andreas@unique.ch>, Gustav Hartz <gustav.hartz.ext@unique.ch>, Rami Azouz <rami.ext@unique.ch>
@@ -25,8 +25,8 @@ Requires-Dist: rapidfuzz>=3.0.0,<4
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: certifi>=2025.11.12
 Requires-Dist: jinja2>=3.1.6
-Requires-Dist: unique-search-proxy-core>=2026.44.0.dev4,<2026.44.0rc0
-Requires-Dist: unique-search-proxy-sdk>=2026.44.0.dev2,<2026.44.0rc0
+Requires-Dist: unique-search-proxy-core>=2026.44.0.dev6,<2026.44.0rc0
+Requires-Dist: unique-search-proxy-sdk>=2026.44.0.dev3,<2026.44.0rc0
 Requires-Dist: openai>=1.105.0,<3
 Requires-Python: >=3.12, <4.0
 Description-Content-Type: text/markdown

{unique_web_search-2026.44.0.dev2 → unique_web_search-2026.44.0.dev4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_web_search"
-version = "2026.44.0.dev2"
+version = "2026.44.0.dev4"
 description = ""
 readme = "README.md"
 requires-python = ">=3.12,<4.0"
@@ -31,8 +31,8 @@ dependencies = [
     "httpx>=0.28.1",
     "certifi>=2025.11.12",
     "jinja2>=3.1.6",
-    "unique-search-proxy-core>=2026.44.0.dev4,<2026.44.0rc0",
-    "unique-search-proxy-sdk>=2026.44.0.dev2,<2026.44.0rc0",
+    "unique-search-proxy-core>=2026.44.0.dev6,<2026.44.0rc0",
+    "unique-search-proxy-sdk>=2026.44.0.dev3,<2026.44.0rc0",
     "openai>=1.105.0,<3",
 ]
 

{unique_web_search-2026.44.0.dev2 → unique_web_search-2026.44.0.dev4}/src/unique_web_search/services/content_processing/processing_strategies/llm_guard_judge.py

@@ -157,13 +157,9 @@ class LLMGuardJudge:
             needs_sanitization, _ = await self.judge_only(**kwargs)
             page = kwargs["page"]
             if not needs_sanitization:
-                _LOGGER.info(
-                    f"Page {page.url} does not require sanitization — keeping as-is"
-                )
+                _LOGGER.info("Page does not require sanitization — keeping as-is")
                 return page
-            _LOGGER.info(
-                f"Page {page.url} flagged — replacing content with flag message"
-            )
+            _LOGGER.info("Page flagged — replacing content with flag message")
             return page.model_copy(
                 update={
                     "content": "",
@@ -178,13 +174,9 @@ class LLMGuardJudge:
         if mode == SanitizeMode.JUDGE_THEN_SANITIZE:
             needs_sanitization, _ = await self.judge_only(**kwargs)
             if not needs_sanitization:
-                _LOGGER.info(
-                    f"Page {kwargs['page'].url} does not require sanitization — keeping as-is"
-                )
+                _LOGGER.info("Page does not require sanitization — keeping as-is")
                 return kwargs["page"]
-            _LOGGER.info(
-                f"Page {kwargs['page'].url} flagged — running full sanitize call"
-            )
+            _LOGGER.info("Page flagged — running full sanitize call")
             return await self.sanitize_page(**kwargs)
 
         raise ValueError(f"Unknown sanitize_mode: {mode}")
@@ -238,9 +230,7 @@ class LLMGuardJudge:
 
         parsed = await self._complete(JudgeResponse, system_prompt, user_prompt)
 
-        _LOGGER.info(
-            f"Judge result for {page.url}: needs_sanitization={parsed.needs_sanitization}"
-        )
+        _LOGGER.info(f"Judge result: needs_sanitization={parsed.needs_sanitization}")
 
         return parsed.needs_sanitization, page
 
@@ -272,9 +262,7 @@ class LLMGuardJudge:
             JudgeAndSanitizeResponse, system_prompt, user_prompt
         )
 
-        _LOGGER.info(
-            f"Judge result for {page.url}: needs_sanitization={parsed.needs_sanitization}"
-        )
+        _LOGGER.info(f"Judge result: needs_sanitization={parsed.needs_sanitization}")
 
         if parsed.needs_sanitization:
             page = parsed.apply_to_page(page, self._config.privacy_filter.flag_message)

{unique_web_search-2026.44.0.dev2 → unique_web_search-2026.44.0.dev4}/src/unique_web_search/services/content_processing/processing_strategies/llm_keyword_redact.py

@@ -171,7 +171,7 @@ class LLMKeywordRedact:
         )
 
         _LOGGER.info(
-            f"Running keyword extraction for page {page.url} "
+            "Running keyword extraction for page "
             f"(model={self._config.language_model.name})"
         )
 
@@ -195,7 +195,7 @@ class LLMKeywordRedact:
         )
 
         _LOGGER.info(
-            f"Extracted {len(parsed.sensitive_keywords)} sensitive keyword(s) from {page.url}"
+            f"Extracted {len(parsed.sensitive_keywords)} sensitive keyword(s) from page"
         )
 
         return parsed.apply_to_page(page)

{unique_web_search-2026.44.0.dev2 → unique_web_search-2026.44.0.dev4}/src/unique_web_search/services/content_processing/processing_strategies/llm_process.py

@@ -246,12 +246,12 @@ class LLMProcess:
 
         if not self._config.should_run(self._encoder, page.content):
             _LOGGER.warning(
-                f"Content is already short enough, skipping LLM processing for page {page.url}"
+                "Content is already short enough, skipping LLM processing for page"
             )
             return page
 
         _LOGGER.info(
-            f"Processing page {page.url} with LLM processor "
+            "Processing page with LLM processor "
             f"(sanitize={self._config.privacy_filter.sanitize}, mode={self._config.privacy_filter.sanitize_mode})"
         )
 

{unique_web_search-2026.44.0.dev2 → unique_web_search-2026.44.0.dev4}/src/unique_web_search/services/content_processing/processing_strategies/truncate.py

@@ -48,7 +48,7 @@ class Truncate:
             _LOGGER.warning("Truncate strategy is disabled, skipping")
             return page
 
-        _LOGGER.info(f"Truncating page {page.url} with truncate strategy")
+        _LOGGER.info("Truncating page with truncate strategy")
         tokens = self._encoder(page.content)
         if len(tokens) > self._config.max_tokens:
             page.content = self._decoder(tokens[: self._config.max_tokens])

{unique_web_search-2026.44.0.dev2 → unique_web_search-2026.44.0.dev4}/src/unique_web_search/services/content_processing/service.py

@@ -161,7 +161,7 @@ class ContentProcessor:
                 # Clear content to avoid overfilling the context; the chunker will
                 # render the compliance placeholder via the empty-content branch.
                 _LOGGER.error(
-                    f"Processing strategy failed for page {page.url}: {result.exception}",
+                    f"Processing strategy failed for page: {result.exception}",
                     exc_info=result.exception,
                 )
                 processed_pages.append(page.model_copy(update={"content": ""}))

{unique_web_search-2026.44.0.dev2 → unique_web_search-2026.44.0.dev4}/src/unique_web_search/services/crawlers/base.py

@@ -12,6 +12,7 @@ from unique_search_proxy_core.url_safety import (
 )
 
 from unique_web_search.metrics import crawl_blocked
+from unique_web_search.services.httpx_logging import hide_httpx_request_logs
 from unique_web_search.services.proxy.bridge import (
     open_search_proxy_client,
     search_proxy_client_enabled,
@@ -41,16 +42,17 @@ class BaseCrawler(ABC, Generic[CrawlerConfig]):
         self._request_context = request_context
 
     async def crawl(self, urls: list[str]) -> list[str]:
-        if search_proxy_client_enabled:
-            return await self._proxy_crawl(urls)
+        with hide_httpx_request_logs():
+            if search_proxy_client_enabled:
+                return await self._proxy_crawl(urls)
 
-        try:
-            targets = await UrlSafetyService.validate_batch_urls(urls)
-        except CrawlTargetValidationError as exc:
-            for target in exc.blocked_targets:
-                crawl_blocked.labels(reason_category=target.category).inc()
-            raise
-        return await self._legacy_crawl(targets)
+            try:
+                targets = await UrlSafetyService.validate_batch_urls(urls)
+            except CrawlTargetValidationError as exc:
+                for target in exc.blocked_targets:
+                    crawl_blocked.labels(reason_category=target.category).inc()
+                raise
+            return await self._legacy_crawl(targets)
 
     async def _proxy_crawl(self, urls: list[str]) -> list[str]:
         """Dump deployment config fields into the generic proxy crawl call."""

{unique_web_search-2026.44.0.dev2 → unique_web_search-2026.44.0.dev4}/src/unique_web_search/services/executors/base_executor.py

@@ -71,7 +71,7 @@ class BaseWebSearchExecutor(ABC, Generic[T]):
         self._notify_message = ""
 
         async def notify_callback() -> None:
-            _LOGGER.debug(f"{self.notify_name}: {self.notify_message}")
+            _LOGGER.debug(f"Progress update: {self.notify_name}")
             if self.tool_progress_reporter:
                 await self.tool_progress_reporter.notify_from_tool_call(
                     tool_call=tool_call,

{unique_web_search-2026.44.0.dev2 → unique_web_search-2026.44.0.dev4}/src/unique_web_search/services/executors/v1/schema.py

@@ -16,6 +16,7 @@ class WebSearchToolParameters(ExposedParams):
         alias_generator=to_camel,
         populate_by_name=True,
         extra="forbid",
+        hide_input_in_errors=True,
     )
 
     query: str = Field(description=_DEFAULT_QUERY_DESCRIPTION)

{unique_web_search-2026.44.0.dev2 → unique_web_search-2026.44.0.dev4}/src/unique_web_search/services/executors/v2/executor.py

@@ -212,7 +212,7 @@ class WebSearchV2Executor(BaseWebSearchExecutor[WebSearchPlan]):
         )
         delta_time = time() - time_start
         _LOGGER.debug(
-            f"Crawled {step.query_or_url} with {self.crawler_service} completed in {delta_time} seconds"
+            f"Crawled URL with {self.crawler_service} completed in {delta_time} seconds"
         )
 
         self.debug_info.steps.append(

{unique_web_search-2026.44.0.dev2 → unique_web_search-2026.44.0.dev4}/src/unique_web_search/services/executors/v2/schema.py

@@ -26,7 +26,7 @@ class Step(BaseModel):
 
 
 class WebSearchPlan(BaseModel):
-    model_config = ConfigDict(extra="forbid")
+    model_config = ConfigDict(extra="forbid", hide_input_in_errors=True)
     objective: str = Field(description="The objective of the plan")
     query_analysis: str = Field(
         description="Analysis of the user's query and what information is needed"

{unique_web_search-2026.44.0.dev2 → unique_web_search-2026.44.0.dev4}/src/unique_web_search/services/executors/v3/schema.py

@@ -15,6 +15,7 @@ _LLM_TOOL_MODEL_CONFIG = ConfigDict(
     alias_generator=to_camel,
     populate_by_name=True,
     extra="forbid",
+    hide_input_in_errors=True,
 )
 
 

unique_web_search-2026.44.0.dev4/src/unique_web_search/services/httpx_logging.py

@@ -0,0 +1,56 @@
+"""Hide httpx request logs while a web search call runs.
+
+httpx logs every request URL at INFO, and web search request URLs carry
+search queries, crawled URLs and provider credentials. httpx logs from other
+code in the same process are kept.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Iterator
+from contextlib import contextmanager
+from contextvars import ContextVar
+
+from unique_search_proxy_core.logging import HttpxRequestLogFilter
+
+_hide_httpx_request_logs: ContextVar[bool] = ContextVar(
+    "unique_web_search_hide_httpx_request_logs", default=False
+)
+
+
+# Wraps instead of subclassing HttpxRequestLogFilter: the SDK's global
+# suppress_httpx_request_logs() skips installing itself when it finds an
+# instance of that class on the httpx logger.
+class _WebSearchHttpxRequestLogFilter(logging.Filter):
+    _request_log_filter = HttpxRequestLogFilter()
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        if not _hide_httpx_request_logs.get():
+            return True
+        return self._request_log_filter.filter(record)
+
+
+def _install_filter() -> None:
+    httpx_logger = logging.getLogger("httpx")
+    if any(
+        isinstance(log_filter, _WebSearchHttpxRequestLogFilter)
+        for log_filter in httpx_logger.filters
+    ):
+        return
+    httpx_logger.addFilter(_WebSearchHttpxRequestLogFilter())
+
+
+@contextmanager
+def hide_httpx_request_logs() -> Iterator[None]:
+    """Drop httpx request logs from the current task and tasks it starts.
+
+    Scoping follows ``contextvars``: work handed to threads without a copied
+    context (e.g. ``loop.run_in_executor``) is not covered.
+    """
+    _install_filter()
+    token = _hide_httpx_request_logs.set(True)
+    try:
+        yield
+    finally:
+        _hide_httpx_request_logs.reset(token)

{unique_web_search-2026.44.0.dev2 → unique_web_search-2026.44.0.dev4}/src/unique_web_search/services/query_elicitation.py

@@ -50,7 +50,7 @@ class QueryElicitationModel(BaseModel):
     creation with default values for form pre-population.
     """
 
-    model_config = ConfigDict(title="Query Elicitation")
+    model_config = ConfigDict(title="Query Elicitation", hide_input_in_errors=True)
     queries: list[str] = Field(description="The queries to search the web for")
 
     @classmethod
@@ -160,13 +160,13 @@ class QueryElicitationService:
             elif elicitation.status == ElicitationStatus.DECLINED:
                 _LOGGER.info(f"Query elicitation {elicitation.id} declined")
                 raise ElicitationDeclinedException(
-                    f"Elicitation triggered with queries {queries} was declined"
+                    f"Query elicitation {elicitation.id} was declined"
                 )
 
             elif elicitation.status == ElicitationStatus.CANCELLED:
                 _LOGGER.info(f"Query elicitation {elicitation.id} cancelled")
                 raise ElicitationCancelledException(
-                    f"Elicitation triggered with queries {queries} was cancelled"
+                    f"Query elicitation {elicitation.id} was cancelled"
                 )
 
         raise ElicitationExpiredException(

{unique_web_search-2026.44.0.dev2 → unique_web_search-2026.44.0.dev4}/src/unique_web_search/services/search_engine/README.md

@@ -212,7 +212,14 @@ BING_AGENT_DEFAULT_MARKET=fr-FR
 
 **Provider:** Gemini + Google Search grounding on Vertex AI · Config extends `VertexAIAgentConfig`.
 
-Requires GCP ADC / workload identity. Fields include `vertexai_model_name`, `generation_instructions`, `enable_entreprise_search`, `enable_redirect_resolution`, `requires_scraping`.
+Requires GCP ADC / workload identity. Fields include `vertexai_model_name`,
+`generation_instructions`, `enable_entreprise_search`,
+`enable_redirect_resolution`, and `requires_scraping`.
+
+In proxy mode, Vertex grounding redirect URLs are resolved by Search Proxy,
+where every redirect hop passes URL-safety and shared egress controls. Legacy
+mode returns redirect URLs unchanged instead of resolving them directly from
+assistants-core.
 
 ```bash
 VERTEXAI_AGENT_DEFAULT_VERTEX_AI_MODEL_NAME=gemini-3-flash-preview

{unique_web_search-2026.44.0.dev2 → unique_web_search-2026.44.0.dev4}/src/unique_web_search/services/search_engine/base.py

@@ -17,6 +17,7 @@ from unique_search_proxy_core.param_policy.exposable_param import (
 from unique_search_proxy_core.param_policy.exposed_params import ExposedParams
 from unique_search_proxy_core.search_engines.base import SearchEngineType
 
+from unique_web_search.services.httpx_logging import hide_httpx_request_logs
 from unique_web_search.services.proxy.bridge import (
     open_search_proxy_client,
     search_proxy_client_enabled,
@@ -110,14 +111,15 @@ class SearchEngine(ABC, Generic[SearchEngineConfig]):
         params: ExposedParams | None = None,
     ) -> list[WebSearchResult]:
         """Search the web for the given query using the search engine."""
-        proxy_engine = self._proxy_engine
-        if (
-            search_proxy_client_enabled
-            and proxy_engine is not None
-            and await self._proxy_routing_enabled()
-        ):
-            return await self._proxy_search(query, params, proxy_engine)
-        return await self._legacy_search(query=query, params=params)
+        with hide_httpx_request_logs():
+            proxy_engine = self._proxy_engine
+            if (
+                search_proxy_client_enabled
+                and proxy_engine is not None
+                and await self._proxy_routing_enabled()
+            ):
+                return await self._proxy_search(query, params, proxy_engine)
+            return await self._legacy_search(query=query, params=params)
 
     async def _proxy_search(
         self,

{unique_web_search-2026.44.0.dev2 → unique_web_search-2026.44.0.dev4}/src/unique_web_search/services/search_engine/custom_api.py

@@ -191,7 +191,7 @@ class CustomAPI(SearchEngine[CustomAPIConfig]):
 
         if not response.is_success:
             raise ValueError(
-                f"Search engine request failed with status {response.status_code}: {response.text}"
+                f"Search engine request failed with status {response.status_code}"
             )
 
         validated_response = WebSearchResults.model_validate(response.json())

{unique_web_search-2026.44.0.dev2 → unique_web_search-2026.44.0.dev4}/src/unique_web_search/services/search_engine/utils/grounding/response_parsing.py

@@ -46,21 +46,19 @@ async def convert_response_to_search_results(
 
 
 class JsonConversionStrategy(ResponseParser):
-    """Extract a fenced JSON block from the response and validate it directly.
+    """Validate a ``GroundingSearchResults``-shaped JSON response directly.
 
-    Expects the response to contain a ``GroundingSearchResults``-shaped
-    JSON object wrapped in a ```json ... ``` code fence.
+    Accepts JSON wrapped in a ```json ... ``` code fence or a bare JSON object.
 
     Raises:
-        ValueError: If no JSON code fence is found in the response.
+        ValueError: If the response does not contain valid results JSON.
     """
 
     async def __call__(self, response: str) -> list[WebSearchResult]:
         json_match = _JSON_PATTERN.search(response)
-        if not json_match:
-            raise ValueError("No JSON found in the response")
+        payload = json_match.group(1) if json_match else response
         return GroundingSearchResults.model_validate_json(
-            json_match.group(1)
+            payload
         ).to_web_search_results()
 
 

{unique_web_search-2026.44.0.dev2 → unique_web_search-2026.44.0.dev4}/src/unique_web_search/services/search_engine/vertexai.py

@@ -1,9 +1,5 @@
-import asyncio
-import logging
 from typing import override
 
-from httpx import AsyncClient as HttpxAsyncClient
-from httpx import HTTPError
 from pydantic import Field
 from unique_search_proxy_core.agent_engines.base import AgentEngineType
 from unique_search_proxy_core.agent_engines.vertexai.schema import VertexAIAgentConfig
@@ -19,10 +15,7 @@ from unique_web_search.services.proxy.bridge import (
 )
 from unique_web_search.services.search_engine.base import SearchEngine, SearchEngineMode
 from unique_web_search.services.search_engine.registry import register_search_engine
-from unique_web_search.services.search_engine.schema import (
-    WebSearchResult,
-    WebSearchResults,
-)
+from unique_web_search.services.search_engine.schema import WebSearchResult
 from unique_web_search.services.search_engine.utils.grounding import (
     JsonConversionStrategy,
     LLMParserStrategy,
@@ -35,8 +28,6 @@ from unique_web_search.services.search_engine.utils.grounding.vertexai import (
     get_vertex_grounding_with_structured_output_config,
 )
 
-_LOGGER = logging.getLogger(__name__)
-
 
 class VertexAIConfig(VertexAIAgentConfig):
     language_model: LMI = get_LMI_default_field(
@@ -49,11 +40,6 @@ class VertexAIConfig(VertexAIAgentConfig):
         description="Whether the search engine requires scraping.",
     )
 
-    enable_redirect_resolution: bool = Field(
-        default=True,
-        description="Whether to enable redirect resolution.",
-    )
-
 
 @register_search_engine(
     name="vertexai",
@@ -87,16 +73,6 @@ class VertexAI(SearchEngine[VertexAIConfig]):
     def requires_scraping(self) -> bool:
         return self.config.requires_scraping
 
-    @override
-    async def _postprocess_results(
-        self,
-        results: list[WebSearchResult],
-    ) -> list[WebSearchResult]:
-        if self.config.enable_redirect_resolution:
-            resolved = await resolve_all(WebSearchResults(results=results))
-            return resolved.results
-        return results
-
     @override
     async def _legacy_search(
         self,
@@ -127,21 +103,4 @@ class VertexAI(SearchEngine[VertexAIConfig]):
             answer_with_citations, self.response_parsers
         )
 
-        return await self._postprocess_results(results)
-
-
-async def resolve_url(client: HttpxAsyncClient, web_search_result: WebSearchResult):
-    try:
-        resp = await client.head(web_search_result.url, follow_redirects=True)
-        web_search_result.url = str(resp.url)
-        return web_search_result
-    except HTTPError as e:
-        _LOGGER.error(f"Unable to redirect URL: {web_search_result.url}: {e}")
-        return web_search_result
-
-
-async def resolve_all(web_search_results: WebSearchResults):
-    async with HttpxAsyncClient(follow_redirects=True, timeout=10) as client:
-        tasks = [resolve_url(client, result) for result in web_search_results.results]
-        results = await asyncio.gather(*tasks)
-        return WebSearchResults(results=results)
+        return results