unique_web_search 2026.26.0.dev7__tar.gz → 2026.26.0.dev9__tar.gz

{unique_web_search-2026.26.0.dev7 → unique_web_search-2026.26.0.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-web-search
-Version: 2026.26.0.dev7
+Version: 2026.26.0.dev9
 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>
@@ -28,7 +28,7 @@ Requires-Dist: certifi>=2025.11.12
 Requires-Dist: jinja2>=3.1.6
 Requires-Dist: playwright>=1.58.0
 Requires-Dist: perplexityai>=0.34.0
-Requires-Dist: unique-search-proxy-core>=2026.26.0.dev5,<2026.26.0rc0
+Requires-Dist: unique-search-proxy-core>=2026.26.0.dev7,<2026.26.0rc0
 Requires-Dist: unique-search-proxy-sdk>=2026.26.0.dev5,<2026.26.0rc0
 Requires-Python: >=3.12, <4.0
 Description-Content-Type: text/markdown

{unique_web_search-2026.26.0.dev7 → unique_web_search-2026.26.0.dev9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_web_search"
-version = "2026.26.0.dev7"
+version = "2026.26.0.dev9"
 description = ""
 readme = "README.md"
 requires-python = ">=3.12,<4.0"
@@ -34,7 +34,7 @@ dependencies = [
     "jinja2>=3.1.6",
     "playwright>=1.58.0",
     "perplexityai>=0.34.0",
-    "unique-search-proxy-core>=2026.26.0.dev5,<2026.26.0rc0",
+    "unique-search-proxy-core>=2026.26.0.dev7,<2026.26.0rc0",
     "unique-search-proxy-sdk>=2026.26.0.dev5,<2026.26.0rc0",
 ]
 

{unique_web_search-2026.26.0.dev7 → unique_web_search-2026.26.0.dev9}/src/unique_web_search/client_settings.py

@@ -235,30 +235,3 @@ def get_perplexity_search_settings() -> PerplexitySearchSettings:
     if _perplexity_search_settings is None:
         _perplexity_search_settings = PerplexitySearchSettings.from_env_settings()
     return _perplexity_search_settings
-
-
-class SearchProxySettings(BaseModel):
-    base_url: str | None = None
-
-    @property
-    def is_configured(self) -> bool:
-        return self.base_url is not None
-
-    @classmethod
-    def from_env_settings(cls):
-        if env_settings.search_proxy_base_url is None:
-            _LOGGER.warning("Unique Search Proxy missing required setting: Base URL")
-        else:
-            _LOGGER.info("Unique Search Proxy is properly configured")
-
-        return cls(base_url=env_settings.search_proxy_base_url)
-
-
-_search_proxy_settings: SearchProxySettings | None = None
-
-
-def get_search_proxy_settings() -> SearchProxySettings:
-    global _search_proxy_settings
-    if _search_proxy_settings is None:
-        _search_proxy_settings = SearchProxySettings.from_env_settings()
-    return _search_proxy_settings

{unique_web_search-2026.26.0.dev7 → unique_web_search-2026.26.0.dev9}/src/unique_web_search/services/crawlers/__init__.py

@@ -9,10 +9,6 @@ from unique_web_search.services.crawlers.basic import (
     BasicCrawler,
     BasicCrawlerConfig,
 )
-from unique_web_search.services.crawlers.basic_proxy import (
-    BasicCrawlerProxyConfig,
-    BasicProxyCrawler,
-)
 from unique_web_search.services.crawlers.crawl4ai import (
     Crawl4AiCrawler,
     Crawl4AiCrawlerConfig,
@@ -31,17 +27,11 @@ from unique_web_search.services.crawlers.tavily import (
 )
 
 CrawlerTypes = (
-    BasicCrawler
-    | BasicProxyCrawler
-    | Crawl4AiCrawler
-    | FirecrawlCrawler
-    | JinaCrawler
-    | TavilyCrawler
+    BasicCrawler | Crawl4AiCrawler | FirecrawlCrawler | JinaCrawler | TavilyCrawler
 )
 
 CrawlerConfigTypes = (
     BasicCrawlerConfig
-    | BasicCrawlerProxyConfig
     | Crawl4AiCrawlerConfig
     | FirecrawlCrawlerConfig
     | JinaCrawlerConfig
@@ -54,7 +44,6 @@ CRAWLER_NAME_TO_CONFIG = {
     "firecrawl": FirecrawlCrawlerConfig,
     "jina": JinaCrawlerConfig,
     "tavily": TavilyCrawlerConfig,
-    "basic_proxy": BasicCrawlerProxyConfig,
 }
 
 
@@ -72,8 +61,6 @@ def get_crawler_service(
             return FirecrawlCrawler(crawler_config)
         case CrawlerType.JINA:
             return JinaCrawler(crawler_config)
-        case CrawlerType.BASIC_PROXY:
-            return BasicProxyCrawler(crawler_config)
 
 
 def get_crawler_config_types_from_names(crawler_names: list[str]) -> TypeAlias:
@@ -103,8 +90,6 @@ def get_default_crawler_config(
 __all__ = [
     "BasicCrawler",
     "BasicCrawlerConfig",
-    "BasicProxyCrawler",
-    "BasicCrawlerProxyConfig",
     "Crawl4AiCrawler",
     "Crawl4AiCrawlerConfig",
     "FirecrawlCrawler",

{unique_web_search-2026.26.0.dev7 → unique_web_search-2026.26.0.dev9}/src/unique_web_search/services/crawlers/base.py

@@ -1,26 +1,28 @@
 from abc import ABC, abstractmethod
 from enum import StrEnum
-from typing import Generic, TypeVar
+from typing import ClassVar, Generic, TypeVar
 
 from pydantic import BaseModel
+from unique_search_proxy_core.url_safety import (
+    CrawlTargetValidationError,
+    ResolvedCrawlTarget,
+    UrlSafetyService,
+)
 from unique_toolkit.agentic.tools.config import (
     get_configuration_dict,
 )
 
-from unique_web_search.services.crawlers.url_safety import (
-    ResolvedCrawlTarget,
-    UrlSafetyService,
-)
+from unique_web_search.metrics import crawl_blocked
 from unique_web_search.services.helpers import (
     clean_model_title_generator,
     experimental_model_title_generator,
 )
+from unique_web_search.services.proxy.bridge import search_proxy_client_enabled
 
 
 class CrawlerType(StrEnum):
     CRAWL4AI = "Crawl4AiCrawler"
     BASIC = "BasicCrawler"
-    BASIC_PROXY = "BasicProxyCrawler"
     NO_CRAWLER = "NoCrawler"
     TAVILY = "TavilyCrawler"
     FIRECRAWL = "FirecrawlCrawler"
@@ -51,12 +53,25 @@ CrawlerConfig = TypeVar(
 
 
 class BaseCrawler(ABC, Generic[CrawlerConfig]):
+    supports_proxy_crawl: ClassVar[bool] = False
+
     def __init__(self, config: CrawlerConfig):
         self.config = config
 
     async def crawl(self, urls: list[str]) -> list[str]:
-        targets = await UrlSafetyService.validate_batch_urls(urls)
-        return await self._crawl(targets)
+        if search_proxy_client_enabled and self.supports_proxy_crawl:
+            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)
+
+    @abstractmethod
+    async def _proxy_crawl(self, urls: list[str]) -> list[str]: ...
 
     @abstractmethod
-    async def _crawl(self, targets: list[ResolvedCrawlTarget]) -> list[str]: ...
+    async def _legacy_crawl(self, targets: list[ResolvedCrawlTarget]) -> list[str]: ...

{unique_web_search-2026.26.0.dev7 → unique_web_search-2026.26.0.dev9}/src/unique_web_search/services/crawlers/basic.py

@@ -20,6 +20,10 @@ from unique_web_search.services.crawlers.url_safety import (
     ResolvedCrawlTarget,
 )
 from unique_web_search.services.crawlers.utils import get_random_user_agent
+from unique_web_search.services.proxy.bridge import (
+    open_search_proxy_client,
+)
+from unique_web_search.services.proxy.mappers import map_crawl_response
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -51,6 +55,8 @@ class BasicCrawlerConfig(BaseCrawlerConfig[CrawlerType.BASIC]):
 
 
 class BasicCrawler(BaseCrawler[BasicCrawlerConfig]):
+    supports_proxy_crawl = True
+
     def __init__(self, config: BasicCrawlerConfig):
         super().__init__(config)
 
@@ -63,7 +69,19 @@ class BasicCrawler(BaseCrawler[BasicCrawlerConfig]):
     #     tags=["basic", "scrape"],
     # )
     @override
-    async def _crawl(self, targets: list[ResolvedCrawlTarget]) -> list[str]:
+    async def _proxy_crawl(self, urls: list[str]) -> list[str]:
+        async with open_search_proxy_client(
+            timeout=float(self.config.timeout),
+        ) as client:
+            response = await client.crawl.basic(
+                urls=urls,
+                timeout=int(self.config.timeout),
+                max_concurrent_requests=self.config.max_concurrent_requests,
+            )
+            return map_crawl_response(response, urls)
+
+    @override
+    async def _legacy_crawl(self, targets: list[ResolvedCrawlTarget]) -> list[str]:
         async with async_client(timeout=Timeout(self.config.timeout)) as client:
             tasks = [self._crawl_url_with_client(client, target) for target in targets]
             results = await asyncio.gather(*tasks, return_exceptions=True)

{unique_web_search-2026.26.0.dev7 → unique_web_search-2026.26.0.dev9}/src/unique_web_search/services/crawlers/crawl4ai.py

@@ -1,6 +1,6 @@
 import logging
 from enum import StrEnum
-from typing import Any, Literal
+from typing import Any, Literal, override
 
 from pydantic import BaseModel, Field
 from unique_toolkit.agentic.tools.config import get_configuration_dict
@@ -169,6 +169,9 @@ class Crawl4AiCrawler(BaseCrawler[Crawl4AiCrawlerConfig]):
     # @track(
     #     tags=["crawl4ai", "scrape"],
     # )
+    @override
+    async def _proxy_crawl(self, urls: list[str]) -> list[str]:
+        raise NotImplementedError("Crawl4AiCrawler does not support proxy crawl")
 
     @staticmethod
     def _get_ssrf_guard_hook():
@@ -209,7 +212,8 @@ class Crawl4AiCrawler(BaseCrawler[Crawl4AiCrawlerConfig]):
 
         return _ssrf_guard_hook
 
-    async def _crawl(self, targets: list[ResolvedCrawlTarget]) -> list[str]:
+    @override
+    async def _legacy_crawl(self, targets: list[ResolvedCrawlTarget]) -> list[str]:
         urls = [target.normalized_url for target in targets]
         # Lazy import of crawl4ai - only import when actually needed
         from crawl4ai import (

{unique_web_search-2026.26.0.dev7 → unique_web_search-2026.26.0.dev9}/src/unique_web_search/services/crawlers/firecrawl.py

@@ -1,4 +1,4 @@
-from typing import Literal
+from typing import Literal, override
 
 from firecrawl import AsyncFirecrawl
 
@@ -11,6 +11,10 @@ from unique_web_search.services.crawlers.base import (
     CrawlerType,
 )
 from unique_web_search.services.crawlers.url_safety import ResolvedCrawlTarget
+from unique_web_search.services.proxy.bridge import (
+    open_search_proxy_client,
+)
+from unique_web_search.services.proxy.mappers import map_crawl_response
 
 
 class FirecrawlCrawlerConfig(BaseCrawlerConfigExperimental[CrawlerType.FIRECRAWL]):
@@ -18,6 +22,8 @@ class FirecrawlCrawlerConfig(BaseCrawlerConfigExperimental[CrawlerType.FIRECRAWL
 
 
 class FirecrawlCrawler(BaseCrawler[FirecrawlCrawlerConfig]):
+    supports_proxy_crawl = True
+
     def __init__(self, config: FirecrawlCrawlerConfig):
         super().__init__(config)
 
@@ -25,8 +31,22 @@ class FirecrawlCrawler(BaseCrawler[FirecrawlCrawlerConfig]):
     # @track(
     #     tags=["firecrawl", "scrape"],
     # )
-    async def _crawl(self, targets: list[ResolvedCrawlTarget]) -> list[str]:
+    @override
+    async def _proxy_crawl(self, urls: list[str]) -> list[str]:
+        async with open_search_proxy_client(
+            timeout=float(self.config.timeout),
+        ) as client:
+            response = await client.crawl.firecrawl(
+                urls=urls,
+                timeout=int(self.config.timeout),
+                only_main_content=True,
+            )
+            return map_crawl_response(response, urls)
+
+    @override
+    async def _legacy_crawl(self, targets: list[ResolvedCrawlTarget]) -> list[str]:
         urls = [target.normalized_url for target in targets]
+
         api_key = get_firecrawl_search_settings().api_key
         assert api_key is not None, "Firecrawl API key is not configured"
 

{unique_web_search-2026.26.0.dev7 → unique_web_search-2026.26.0.dev9}/src/unique_web_search/services/crawlers/jina.py

@@ -1,8 +1,9 @@
 import asyncio
-from typing import Any, Literal
+from typing import Any, Literal, cast, override
 
 from httpx import AsyncClient
 from pydantic import BaseModel, Field, HttpUrl
+from unique_search_proxy_core.crawlers.jina.schema import JinaEngine, JinaReturnFormat
 
 from unique_web_search.client_settings import get_jina_search_settings
 from unique_web_search.services.crawlers.base import (
@@ -11,6 +12,10 @@ from unique_web_search.services.crawlers.base import (
     CrawlerType,
 )
 from unique_web_search.services.crawlers.url_safety import ResolvedCrawlTarget
+from unique_web_search.services.proxy.bridge import (
+    open_search_proxy_client,
+)
+from unique_web_search.services.proxy.mappers import map_crawl_response
 
 
 class ReaderBody(BaseModel):
@@ -46,6 +51,8 @@ class JinaCrawlerConfig(BaseCrawlerConfigExperimental[CrawlerType.JINA]):
 
 
 class JinaCrawler(BaseCrawler[JinaCrawlerConfig]):
+    supports_proxy_crawl = True
+
     def __init__(self, config: JinaCrawlerConfig):
         super().__init__(config)
 
@@ -53,8 +60,28 @@ class JinaCrawler(BaseCrawler[JinaCrawlerConfig]):
     # @track(
     #     tags=["jina", "scrape"],
     # )
-    async def _crawl(self, targets: list[ResolvedCrawlTarget]) -> list[str]:
+    @override
+    async def _proxy_crawl(self, urls: list[str]) -> list[str]:
+        headers = self.config.headers
+        async with open_search_proxy_client(
+            timeout=float(self.config.timeout),
+        ) as client:
+            response = await client.crawl.jina(
+                urls=urls,
+                timeout=int(self.config.timeout),
+                return_format=cast(
+                    JinaReturnFormat,
+                    headers.get("X-Return-Format", "markdown"),
+                ),
+                engine=cast(JinaEngine, headers.get("X-Engine", "browser")),
+                do_not_track=headers.get("DNT") == "1",
+            )
+            return map_crawl_response(response, urls)
+
+    @override
+    async def _legacy_crawl(self, targets: list[ResolvedCrawlTarget]) -> list[str]:
         urls = [target.normalized_url for target in targets]
+
         jina_settings = get_jina_search_settings()
         api_key = jina_settings.api_key
         assert api_key is not None, "Jina API key is not configured"

{unique_web_search-2026.26.0.dev7 → unique_web_search-2026.26.0.dev9}/src/unique_web_search/services/crawlers/tavily.py

@@ -10,6 +10,10 @@ from unique_web_search.services.crawlers.base import (
     CrawlerType,
 )
 from unique_web_search.services.crawlers.url_safety import ResolvedCrawlTarget
+from unique_web_search.services.proxy.bridge import (
+    open_search_proxy_client,
+)
+from unique_web_search.services.proxy.mappers import map_crawl_response
 
 
 class TavilyCrawlerConfig(BaseCrawlerConfigExperimental[CrawlerType.TAVILY]):
@@ -18,6 +22,8 @@ class TavilyCrawlerConfig(BaseCrawlerConfigExperimental[CrawlerType.TAVILY]):
 
 
 class TavilyCrawler(BaseCrawler[TavilyCrawlerConfig]):
+    supports_proxy_crawl = True
+
     def __init__(self, config: TavilyCrawlerConfig):
         super().__init__(config)
 
@@ -25,8 +31,23 @@ class TavilyCrawler(BaseCrawler[TavilyCrawlerConfig]):
     # @track(
     #     tags=["tavily", "scrape"],
     # )
-    async def _crawl(self, targets: list[ResolvedCrawlTarget]) -> list[str]:
+    async def _proxy_crawl(self, urls: list[str]) -> list[str]:
+        async with open_search_proxy_client(
+            timeout=float(self.config.timeout),
+        ) as client:
+            response = await client.crawl.tavily(
+                urls=urls,
+                timeout=int(self.config.timeout),
+                extract_depth=self.config.depth,
+                format="markdown",
+                include_images=False,
+                include_favicon=False,
+            )
+            return map_crawl_response(response, urls)
+
+    async def _legacy_crawl(self, targets: list[ResolvedCrawlTarget]) -> list[str]:
         urls = [target.normalized_url for target in targets]
+
         api_key = get_tavily_search_settings().api_key
         assert api_key is not None, "Tavily API key is not configured"
 

unique_web_search-2026.26.0.dev9/src/unique_web_search/services/crawlers/url_safety/__init__.py

@@ -0,0 +1,21 @@
+"""Deprecated re-exports — use ``unique_search_proxy_core.url_safety`` directly."""
+
+from unique_search_proxy_core.url_safety import (
+    BlockedCrawlTarget,
+    CrawlTargetValidationError,
+    ResolvedCrawlTarget,
+    UrlSafetyOutcome,
+    UrlSafetyService,
+    UrlSafetySettings,
+    url_safety_settings,
+)
+
+__all__ = [
+    "BlockedCrawlTarget",
+    "CrawlTargetValidationError",
+    "ResolvedCrawlTarget",
+    "UrlSafetyOutcome",
+    "UrlSafetyService",
+    "UrlSafetySettings",
+    "url_safety_settings",
+]

unique_web_search-2026.26.0.dev9/src/unique_web_search/services/proxy/__init__.py

@@ -0,0 +1,21 @@
+from unique_web_search.services.proxy.bridge import (
+    open_search_proxy_client,
+    search_proxy_client_enabled,
+)
+from unique_web_search.services.proxy.mappers import (
+    agent_answer_text,
+    map_agent_answer,
+    map_crawl_response,
+    map_search_response,
+    result_to_markdown,
+)
+
+__all__ = [
+    "agent_answer_text",
+    "map_agent_answer",
+    "map_crawl_response",
+    "map_search_response",
+    "open_search_proxy_client",
+    "result_to_markdown",
+    "search_proxy_client_enabled",
+]

unique_web_search-2026.26.0.dev9/src/unique_web_search/services/proxy/bridge.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+
+from unique_search_proxy_sdk import UniqueSearchProxyClient
+
+from unique_web_search.settings import env_settings
+
+search_proxy_client_enabled = env_settings.search_proxy_base_url is not None
+
+
+@asynccontextmanager
+async def open_search_proxy_client(
+    timeout: float,
+) -> AsyncIterator[UniqueSearchProxyClient]:
+    base_url = env_settings.search_proxy_base_url
+    assert base_url is not None, "Unique Search Proxy base URL is not configured"
+
+    async with UniqueSearchProxyClient(
+        base_url=base_url,
+        timeout=timeout,
+    ) as client:
+        yield client
+
+
+__all__ = [
+    "open_search_proxy_client",
+    "search_proxy_client_enabled",
+]

unique_web_search-2026.26.0.dev9/src/unique_web_search/services/proxy/mappers.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import TYPE_CHECKING
+
+from unique_search_proxy_sdk._generated.models.agent_search_response import (
+    AgentSearchResponse,
+)
+from unique_search_proxy_sdk._generated.models.crawl_response import CrawlResponse
+from unique_search_proxy_sdk._generated.models.crawl_url_result import CrawlUrlResult
+from unique_search_proxy_sdk._generated.models.per_url_error import PerUrlError
+from unique_search_proxy_sdk._generated.models.search_response import SearchResponse
+
+if TYPE_CHECKING:
+    from unique_web_search.services.search_engine.schema import WebSearchResult
+    from unique_web_search.services.search_engine.utils.grounding.response_parsing import (
+        ResponseParser,
+    )
+
+
+def map_search_response(response: SearchResponse) -> list[WebSearchResult]:
+    from unique_web_search.services.search_engine.schema import WebSearchResult
+
+    return [
+        WebSearchResult(
+            url=result.url,
+            title=result.title,
+            snippet=result.snippet,
+            content=result.content if isinstance(result.content, str) else "",
+        )
+        for result in response.curated
+    ]
+
+
+_CRAWL_RESULT_TEMPLATE = "URL: {url}\n\n{body}"
+
+
+def _crawl_result_body(result: CrawlUrlResult) -> str:
+    if isinstance(result.content, str):
+        return result.content
+
+    if isinstance(result.error, PerUrlError):
+        return f"Error: {result.error.message}"
+
+    return "Error: No content returned by search proxy"
+
+
+def result_to_markdown(result: CrawlUrlResult) -> str:
+    return _CRAWL_RESULT_TEMPLATE.format(
+        url=result.url,
+        body=_crawl_result_body(result),
+    )
+
+
+def map_crawl_response(response: CrawlResponse, urls: list[str]) -> list[str]:
+    return [result_to_markdown(result) for result in response.results]
+
+
+async def map_agent_answer(
+    answer: str,
+    parsers: Sequence[ResponseParser],
+) -> list[WebSearchResult]:
+    from unique_web_search.services.search_engine.utils.grounding.response_parsing import (
+        convert_response_to_search_results,
+    )
+
+    return await convert_response_to_search_results(answer, list(parsers))
+
+
+def agent_answer_text(response: AgentSearchResponse) -> str:
+    if isinstance(response.answer, str):
+        return response.answer
+    return ""

{unique_web_search-2026.26.0.dev7 → unique_web_search-2026.26.0.dev9}/src/unique_web_search/services/search_engine/base.py

@@ -1,10 +1,11 @@
 from abc import ABC, abstractmethod
 from enum import StrEnum
-from typing import Generic, TypeVar
+from typing import ClassVar, Generic, TypeVar
 
 from pydantic import BaseModel, ConfigDict, Field
 from unique_toolkit.agentic.tools.config import get_configuration_dict
 
+from unique_web_search.services.proxy.bridge import search_proxy_client_enabled
 from unique_web_search.services.search_engine.schema import (
     WebSearchResult,
 )
@@ -104,16 +105,16 @@ class SearchEngine(ABC, Generic[SearchEngineConfig]):
     """Base class for the search engine. It provides the common methods to search the web. This allows to use different search engines easily.
 
     Abstract Methods:
-        _extract_urls: Clean the response from the search engine.
-        _get_request_params: Get the request parameters.
+        _legacy_search: Direct search implementation (no proxy).
         requires_scraping: Whether the search engine requires scraping.
 
-    Args:
-        assistant: The assistant configuration.
-        chat_manager: The chat manager.
+    Subclasses with proxy support set ``supports_proxy_search = True`` and
+    implement ``_proxy_search``.
 
     """
 
+    supports_proxy_search: ClassVar[bool] = False
+
     def __init__(self, config: SearchEngineConfig):
         self.config = config
 
@@ -122,6 +123,16 @@ class SearchEngine(ABC, Generic[SearchEngineConfig]):
     def requires_scraping(self) -> bool:
         """Whether the search engine requires scraping."""
 
-    @abstractmethod
     async def search(self, query: str, **kwargs) -> list[WebSearchResult]:
         """Search the web for the given query using the search engine."""
+        if search_proxy_client_enabled and self.supports_proxy_search:
+            return await self._proxy_search(query=query, **kwargs)
+        return await self._legacy_search(query=query, **kwargs)
+
+    @abstractmethod
+    async def _proxy_search(self, query: str, **kwargs) -> list[WebSearchResult]:
+        """Search the web via the search proxy."""
+
+    @abstractmethod
+    async def _legacy_search(self, query: str, **kwargs) -> list[WebSearchResult]:
+        """Search the web directly without the search proxy."""

{unique_web_search-2026.26.0.dev7 → unique_web_search-2026.26.0.dev9}/src/unique_web_search/services/search_engine/bing.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import Annotated, Literal
+from typing import Annotated, Literal, override
 
 from pydantic import BaseModel, Field
 from unique_toolkit._common.default_language_model import DEFAULT_GPT_4o
@@ -8,6 +8,14 @@ from unique_toolkit._common.validators import LMI, get_LMI_default_field
 from unique_toolkit.agentic.tools.config import get_configuration_dict
 from unique_toolkit.language_model import LanguageModelService
 
+from unique_web_search.services.proxy.bridge import (
+    open_search_proxy_client,
+    search_proxy_client_enabled,
+)
+from unique_web_search.services.proxy.mappers import (
+    agent_answer_text,
+    map_agent_answer,
+)
 from unique_web_search.services.search_engine.base import (
     BaseSearchEngineConfig,
     SearchEngine,
@@ -75,6 +83,8 @@ class BingSearchConfig(
 
 
 class BingSearch(SearchEngine[BingSearchConfig]):
+    supports_proxy_search = True
+
     def __init__(
         self,
         config: BingSearchConfig,
@@ -93,6 +103,9 @@ class BingSearch(SearchEngine[BingSearchConfig]):
 
     @property
     def is_configured(self) -> bool:
+        if search_proxy_client_enabled:
+            return True
+
         async def _is_configured() -> bool:
             return await credentials_are_valid(self.credentials)
 
@@ -102,7 +115,22 @@ class BingSearch(SearchEngine[BingSearchConfig]):
     def requires_scraping(self) -> bool:
         return self.config.requires_scraping
 
-    async def search(self, query: str, **kwargs) -> list[WebSearchResult]:
+    @override
+    async def _proxy_search(self, query: str, **kwargs) -> list[WebSearchResult]:
+        async with open_search_proxy_client(timeout=120.0) as client:
+            response = await client.agent_search.bing(
+                query=query,
+                fetch_size=self.config.fetch_size,
+                agent_id=self.config.agent_id or None,
+                generation_instructions=self.config.generation_instructions,
+            )
+            return await map_agent_answer(
+                agent_answer_text(response),
+                self.response_parsers,
+            )
+
+    @override
+    async def _legacy_search(self, query: str, **kwargs) -> list[WebSearchResult]:
         agent_client = get_project_client(self.credentials, self.config.endpoint)
 
         search_results = await create_and_process_run(