unique-search-proxy 2026.44.0.dev0__tar.gz → 2026.44.0.dev1__tar.gz

{unique_search_proxy-2026.44.0.dev0 → unique_search_proxy-2026.44.0.dev1}/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.3
 Name: unique-search-proxy
-Version: 2026.44.0.dev0
+Version: 2026.44.0.dev1
 Summary: Web Search Proxy implementation
 Author: ThePhilAz
 Author-email: ThePhilAz <rami.azouz@philico.com>
+Requires-Dist: aiohttp>=3.14.1,<4
 Requires-Dist: fastapi>=0.133.0,<1.0.0
 Requires-Dist: starlette>=1.3.1,<2.0.0
 Requires-Dist: uvicorn[standard]>=0.32.0,<1.0.0
@@ -19,8 +20,8 @@ Requires-Dist: certifi>=2025.11.12,<2027
 Requires-Dist: google-genai>=1.73.0,<2
 Requires-Dist: google-auth>=2.43.0,<3
 Requires-Dist: jinja2>=3.1.6,<4
-Requires-Dist: unique-toolkit[monitoring]>=2026.44.0.dev0,<2026.44.0rc0
-Requires-Dist: unique-search-proxy-core>=2026.44.0.dev0,<2026.44.0rc0
+Requires-Dist: unique-toolkit[monitoring]>=2026.44.0.dev2,<2026.44.0rc0
+Requires-Dist: unique-search-proxy-core>=2026.44.0.dev1,<2026.44.0rc0
 Requires-Dist: openai>=1.105.0,<3
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{unique_search_proxy-2026.44.0.dev0 → unique_search_proxy-2026.44.0.dev1}/pyproject.toml

@@ -1,11 +1,12 @@
 [project]
 name = "unique-search-proxy"
-version = "2026.44.0.dev0"
+version = "2026.44.0.dev1"
 description = "Web Search Proxy implementation"
 authors = [{ name = "ThePhilAz", email = "rami.azouz@philico.com" }]
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
+    "aiohttp>=3.14.1,<4",
     "fastapi>=0.133.0,<1.0.0",
     "starlette>=1.3.1,<2.0.0",
     "uvicorn[standard]>=0.32.0,<1.0.0",
@@ -21,8 +22,8 @@ dependencies = [
     "google-genai>=1.73.0,<2",
     "google-auth>=2.43.0,<3",
     "jinja2>=3.1.6,<4",
-    "unique-toolkit[monitoring]>=2026.44.0.dev0,<2026.44.0rc0",
-    "unique-search-proxy-core>=2026.44.0.dev0,<2026.44.0rc0",
+    "unique-toolkit[monitoring]>=2026.44.0.dev2,<2026.44.0rc0",
+    "unique-search-proxy-core>=2026.44.0.dev1,<2026.44.0rc0",
     "openai>=1.105.0,<3",
 ]
 

{unique_search_proxy-2026.44.0.dev0 → unique_search_proxy-2026.44.0.dev1}/unique_search_proxy_client/web/api/v1/agent_search.py

@@ -23,9 +23,11 @@ from unique_search_proxy_core.schema import (
     ProxyErrorCode,
 )
 
+from unique_search_proxy_client.web.context import get_request_context
 from unique_search_proxy_client.web.core.agent_engines.factory import (
     get_agent_engine_service,
 )
+from unique_search_proxy_client.web.core.client import get_http_client_registry
 from unique_search_proxy_client.web.monitoring.metrics import (
     record_agent_search_error,
     record_agent_search_success,
@@ -84,8 +86,12 @@ async def agent_search(
     )
 
     try:
+        registry = get_http_client_registry(request.app)
+        egress = await registry.egress_for(get_request_context())
         engine_service = get_agent_engine_service(
             AgentEngineType(engine_id) if isinstance(engine, str) else engine,
+            http_client=egress.http_client,
+            egress_route=egress.route,
         )
         async with asyncio.timeout(timeout):
             result = await engine_service.search(body)
@@ -162,9 +168,20 @@ async def agent_search_stream(
     )
 
     try:
+        registry = get_http_client_registry(request.app)
+        egress = await registry.egress_for(get_request_context())
         engine_service = get_agent_engine_service(
             AgentEngineType(engine_id) if isinstance(engine, str) else engine,
+            http_client=egress.http_client,
+            egress_route=egress.route,
         )
+    except ProxyError as exc:
+        record_agent_search_error(
+            engine_id,
+            exc.code.value if hasattr(exc.code, "value") else str(exc.code),
+            time.perf_counter() - started,
+        )
+        raise _agent_search_request_context(exc, engine_id=engine_id) from exc
     except Exception as exc:
         record_agent_search_error(engine_id, "INTERNAL_ERROR", 0.0)
         _LOGGER.exception(

{unique_search_proxy-2026.44.0.dev0 → unique_search_proxy-2026.44.0.dev1}/unique_search_proxy_client/web/app.py

@@ -59,10 +59,10 @@ logging.getLogger("uvicorn.access").addFilter(HealthCheckFilter())
 async def lifespan(app: FastAPI):
     _LOGGER.info("Starting Unique Search Proxy...")
     log_startup_settings_report(_LOGGER)
-    await maybe_cleanup_auto_provisioned_bing_agents_on_start()
     registry = await create_http_client_registry()
     app.state.http_client_registry = registry
     try:
+        await maybe_cleanup_auto_provisioned_bing_agents_on_start(registry)
         yield
     finally:
         await aclose_private_endpoint_http_client()

{unique_search_proxy-2026.44.0.dev0 → unique_search_proxy-2026.44.0.dev1}/unique_search_proxy_client/web/core/agent_engines/bing/cleanup.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+from typing import TYPE_CHECKING
 
 from azure.ai.projects.aio import AIProjectClient
 from azure.core.exceptions import ResourceNotFoundError
@@ -10,6 +11,7 @@ from unique_search_proxy_core.agent_engines.bing.grounding import (
 from unique_search_proxy_core.errors import EngineNotConfiguredError
 
 from unique_search_proxy_client.web.core.agent_engines.bing.client import (
+    bing_azure_transport,
     get_credentials,
     get_project_client,
 )
@@ -18,6 +20,9 @@ from unique_search_proxy_client.web.settings.providers.bing_agent import (
 )
 from unique_search_proxy_client.web.settings.secret_str import read_secret
 
+if TYPE_CHECKING:
+    from unique_search_proxy_core.http_client import HttpClientRegistry
+
 _LOGGER = logging.getLogger(__name__)
 _LIST_PAGE_SIZE = 100
 
@@ -53,11 +58,15 @@ async def cleanup_auto_provisioned_bing_agents(project_client: AIProjectClient)
     return deleted
 
 
-async def maybe_cleanup_auto_provisioned_bing_agents_on_start() -> None:
+async def maybe_cleanup_auto_provisioned_bing_agents_on_start(
+    registry: HttpClientRegistry,
+) -> None:
     """Best-effort startup cleanup when ``BING_AGENT_CLEANUP_ON_START`` is enabled.
 
     Never raises: credential, client, list, or delete failures are logged and
     swallowed so multi-worker/replica races cannot block process startup.
+    Uses settings-backed proxy credentials because no request identity exists
+    during process startup; missing technical credentials fail closed.
     Transient Bing request failures during a race are recovered by create-on-miss.
     """
     if not bing_agent_credentials.cleanup_on_start:
@@ -73,12 +82,15 @@ async def maybe_cleanup_auto_provisioned_bing_agents_on_start() -> None:
         return
 
     try:
-        async with get_credentials() as credential:
-            async with get_project_client(
-                credential,
-                endpoint=read_secret(bing_agent_credentials.endpoint),
-            ) as project_client:
-                deleted = await cleanup_auto_provisioned_bing_agents(project_client)
+        egress = await registry.settings_egress()
+        async with bing_azure_transport(egress.route) as azure_transport:
+            async with get_credentials(transport=azure_transport) as credential:
+                async with get_project_client(
+                    credential,
+                    endpoint=read_secret(bing_agent_credentials.endpoint),
+                    transport=azure_transport,
+                ) as project_client:
+                    deleted = await cleanup_auto_provisioned_bing_agents(project_client)
         _LOGGER.info(
             "Bing agent startup cleanup finished; deleted %s auto-provisioned agent(s)",
             deleted,

{unique_search_proxy-2026.44.0.dev0 → unique_search_proxy-2026.44.0.dev1}/unique_search_proxy_client/web/core/agent_engines/bing/client.py

@@ -1,15 +1,21 @@
 from __future__ import annotations
 
 import logging
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
 
 import certifi
 import httpx
 from azure.ai.projects.aio import AIProjectClient
 from azure.core.credentials_async import AsyncTokenCredential
-from azure.core.pipeline.transport import AsyncioRequestsTransport
+from azure.core.pipeline.transport import AsyncHttpTransport, AsyncioRequestsTransport
 from azure.identity.aio import DefaultAzureCredential, WorkloadIdentityCredential
 from openai import AsyncOpenAI
+from unique_search_proxy_core.http_client import EgressRoute
 
+from unique_search_proxy_client.web.core.client.azure_transport import (
+    azure_transport_for_route,
+)
 from unique_search_proxy_client.web.settings.providers.bing_agent import (
     bing_agent_credentials,
 )
@@ -19,15 +25,32 @@ _LOGGER = logging.getLogger(__name__)
 _private_endpoint_http_client: httpx.AsyncClient | None = None
 
 
-def get_credentials() -> AsyncTokenCredential:
+@asynccontextmanager
+async def bing_azure_transport(
+    route: EgressRoute,
+) -> AsyncIterator[AsyncHttpTransport | None]:
+    """Yield proxied Azure transport, preserving explicit private endpoints."""
+    if bing_agent_credentials.use_private_endpoint_transport:
+        yield None
+        return
+    async with azure_transport_for_route(route) as transport:
+        yield transport
+
+
+def get_credentials(
+    *,
+    transport: AsyncHttpTransport | None = None,
+) -> AsyncTokenCredential:
     match bing_agent_credentials.azure_identity_credential_type:
         case "workload":
             if bing_agent_credentials.use_private_endpoint_transport:
-                transport = AsyncioRequestsTransport(connection_verify=certifi.where())
-                return WorkloadIdentityCredential(transport=transport)
-            return WorkloadIdentityCredential()
+                private_transport = AsyncioRequestsTransport(
+                    connection_verify=certifi.where()
+                )
+                return WorkloadIdentityCredential(transport=private_transport)
+            return WorkloadIdentityCredential(transport=transport)
         case "default":
-            return DefaultAzureCredential()
+            return DefaultAzureCredential(transport=transport)
         case other:
             msg = f"Invalid Azure identity credential type: {other}"
             raise ValueError(msg)
@@ -37,6 +60,7 @@ def get_project_client(
     credential: AsyncTokenCredential,
     *,
     endpoint: str | None = None,
+    transport: AsyncHttpTransport | None = None,
 ) -> AIProjectClient:
     resolved_endpoint = endpoint or read_secret(bing_agent_credentials.endpoint)
     if not resolved_endpoint or resolved_endpoint == NOT_PROVIDED:
@@ -53,6 +77,7 @@ def get_project_client(
     return AIProjectClient(
         credential=credential,
         endpoint=resolved_endpoint,
+        transport=transport,
     )
 
 
@@ -75,7 +100,11 @@ async def aclose_private_endpoint_http_client() -> None:
     _private_endpoint_http_client = None
 
 
-def get_openai_client(project_client: AIProjectClient) -> AsyncOpenAI:
+def get_openai_client(
+    project_client: AIProjectClient,
+    *,
+    http_client: httpx.AsyncClient | None = None,
+) -> AsyncOpenAI:
     """Return an authenticated AsyncOpenAI client from the Foundry project client.
 
     When private-endpoint transport is enabled, reuse a shared certifi-backed
@@ -86,6 +115,8 @@ def get_openai_client(project_client: AIProjectClient) -> AsyncOpenAI:
         return project_client.get_openai_client(
             http_client=_get_private_endpoint_http_client(),
         )
+    if http_client is not None:
+        return project_client.get_openai_client(http_client=http_client)
     return project_client.get_openai_client()
 
 

{unique_search_proxy-2026.44.0.dev0 → unique_search_proxy-2026.44.0.dev1}/unique_search_proxy_client/web/core/agent_engines/bing/runner.py

@@ -12,6 +12,7 @@ from azure.ai.projects.models import (
     BingGroundingTool,
     PromptAgentDefinition,
 )
+from httpx import AsyncClient
 from openai.types.responses import ResponseStreamEvent
 from openai.types.responses.response_completed_event import ResponseCompletedEvent
 from openai.types.responses.response_output_item_done_event import (
@@ -140,10 +141,12 @@ def _is_missing_agent_error(exc: BaseException, *, agent_name: str) -> bool:
 async def stream_bing_grounding_agent(
     project_client: AIProjectClient,
     *,
+    http_client: AsyncClient | None = None,
     query: str,
     model: str,
     instructions: str,
     grounding: BingGroundingConfiguration,
+    timeout: float,
 ) -> AsyncIterator[tuple[str, dict]]:
     """Stream Bing-grounded Responses events as ``(delta_text, raw_event)`` pairs.
 
@@ -158,13 +161,17 @@ async def stream_bing_grounding_agent(
         instructions=instructions,
         grounding=grounding,
     )
-    openai_client = get_openai_client(project_client)
+    openai_client = get_openai_client(
+        project_client,
+        http_client=http_client,
+    )
 
     try:
         stream = await _create_responses_stream(
             openai_client,
             agent_name=resolved_name,
             query=query,
+            timeout=timeout,
         )
     except Exception as exc:
         if not _is_missing_agent_error(exc, agent_name=resolved_name):
@@ -185,6 +192,7 @@ async def stream_bing_grounding_agent(
             openai_client,
             agent_name=resolved_name,
             query=query,
+            timeout=timeout,
         )
 
     emitted_text = False
@@ -225,6 +233,7 @@ async def _create_responses_stream(
     *,
     agent_name: str,
     query: str,
+    timeout: float,
 ) -> openai.AsyncStream[ResponseStreamEvent]:
     started = time.perf_counter()
     stream = await openai_client.responses.create(
@@ -236,6 +245,9 @@ async def _create_responses_stream(
                 "type": "agent_reference",
             }
         },
+        # The shared egress client defaults to 30s, while Bing requests allow
+        # longer runs. The API's outer deadline still caps total request time.
+        timeout=timeout,
     )
     elapsed_ms = (time.perf_counter() - started) * 1000
     _LOGGER.info(

unique_search_proxy-2026.44.0.dev1/unique_search_proxy_client/web/core/agent_engines/bing/service.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from collections.abc import AsyncIterator
+from typing import TYPE_CHECKING
+
+import openai
+from unique_search_proxy_core.agent_engines.base import AgentEngineType
+from unique_search_proxy_core.agent_engines.bing.grounding import (
+    BingGroundingConfiguration,
+)
+from unique_search_proxy_core.agent_engines.bing.schema import BingAgentSearchRequest
+from unique_search_proxy_core.agent_engines.bing.settings import resolve_market
+from unique_search_proxy_core.agent_engines.resolve import (
+    resolve_output_schema_for_engine,
+)
+from unique_search_proxy_core.errors import UpstreamError
+from unique_search_proxy_core.schema import (
+    AgentSearchDelta,
+    AgentSearchDone,
+    AgentSearchResponse,
+    AgentSearchStreamEvent,
+)
+
+from unique_search_proxy_client.web.core.agent_engines.bing.client import (
+    bing_azure_transport,
+    get_credentials,
+    get_project_client,
+)
+from unique_search_proxy_client.web.core.agent_engines.bing.runner import (
+    stream_bing_grounding_agent,
+)
+from unique_search_proxy_client.web.core.agent_engines.service_base import (
+    AgentSearchEngineService,
+)
+from unique_search_proxy_client.web.core.agent_engines.structured_output import (
+    build_agent_instructions,
+)
+from unique_search_proxy_client.web.core.provider_response import transport_error_raw
+from unique_search_proxy_client.web.settings.providers.bing_agent import (
+    bing_agent_credentials,
+)
+from unique_search_proxy_client.web.settings.secret_str import read_secret
+
+if TYPE_CHECKING:
+    from httpx import AsyncClient
+    from unique_search_proxy_core.http_client import EgressRoute
+
+_LOGGER = logging.getLogger(__name__)
+# Foundry can report transient backend failures inside an HTTP 200 SSE stream,
+# beyond the reach of the OpenAI client's HTTP retry policy.
+_RETRYABLE_STREAM_ERROR_CODES = frozenset({"server_error", "internal_error"})
+_RETRYABLE_STREAM_ERROR_MESSAGES = (
+    "model deployment encountered an error processing your request",
+    "invalid or expired token",
+)
+_STREAM_RETRY_DELAYS_SECONDS = (2.0, 8.0)
+_STREAM_MAX_ATTEMPTS = len(_STREAM_RETRY_DELAYS_SECONDS) + 1
+
+
+def _is_retryable_bing_stream_error(exc: BaseException) -> bool:
+    """Return whether a pre-output Foundry stream failure is safe to retry."""
+    if isinstance(exc, openai.APIStatusError):
+        # The OpenAI client already retries retryable HTTP statuses. This
+        # classifier is only for errors embedded in an HTTP 200 SSE stream.
+        return False
+    if not isinstance(exc, openai.APIError):
+        return False
+
+    code = exc.code.lower() if isinstance(exc.code, str) else None
+    if code in _RETRYABLE_STREAM_ERROR_CODES:
+        return True
+
+    message = str(exc).lower()
+    return any(marker in message for marker in _RETRYABLE_STREAM_ERROR_MESSAGES)
+
+
+class BingAgentSearchService(AgentSearchEngineService[BingAgentSearchRequest]):
+    engine_id = AgentEngineType.BING.value
+
+    def __init__(
+        self,
+        *,
+        http_client: AsyncClient,
+        egress_route: EgressRoute,
+    ) -> None:
+        super().__init__(http_client=http_client)
+        self._egress_route = egress_route
+
+    async def search(self, request: BingAgentSearchRequest) -> AgentSearchResponse:  # type: ignore[override]
+        response: AgentSearchResponse | None = None
+        async for event in self.stream(request):
+            if isinstance(event, AgentSearchDone):
+                response = event.response
+        if response is None:
+            msg = "Bing agent search stream ended without a done event"
+            raise UpstreamError(msg)
+        return response
+
+    async def stream(
+        self,
+        request: BingAgentSearchRequest,  # type: ignore[override]
+    ) -> AsyncIterator[AgentSearchStreamEvent]:
+        bing_agent_credentials.check_credentials()
+        creds = bing_agent_credentials
+        http_client = self._http_client
+        egress_route = self._egress_route
+        if http_client is None:
+            raise RuntimeError("HTTP client is required for Bing")
+
+        answer_parts: list[str] = []
+        raw_chunks: list[dict] = []
+
+        output_schema = resolve_output_schema_for_engine(request.engine)
+        instructions = build_agent_instructions(
+            generation_instructions=request.generation_instructions,
+            output_schema=output_schema,
+        )
+        grounding = BingGroundingConfiguration(
+            fetch_size=request.fetch_size,
+            market=resolve_market(request.market),
+            freshness=request.freshness,
+        )
+
+        for attempt in range(1, _STREAM_MAX_ATTEMPTS + 1):
+            try:
+                async with bing_azure_transport(egress_route) as azure_transport:
+                    async with get_credentials(transport=azure_transport) as credential:
+                        async with get_project_client(
+                            credential,
+                            endpoint=read_secret(creds.endpoint),
+                            transport=azure_transport,
+                        ) as project_client:
+                            async for (
+                                delta,
+                                raw_event,
+                            ) in stream_bing_grounding_agent(
+                                project_client,
+                                http_client=http_client,
+                                query=request.query,
+                                model=read_secret(creds.bing_agent_model),
+                                instructions=instructions,
+                                grounding=grounding,
+                                timeout=request.timeout,
+                            ):
+                                if delta:
+                                    answer_parts.append(delta)
+                                    yield AgentSearchDelta(text=delta)
+                                if raw_event:
+                                    raw_chunks.append(raw_event)
+                break
+            except Exception as exc:
+                retryable = (
+                    attempt < _STREAM_MAX_ATTEMPTS
+                    and not answer_parts
+                    and _is_retryable_bing_stream_error(exc)
+                )
+                if not retryable:
+                    raise UpstreamError(
+                        f"Bing agent search failed: {exc}",
+                        upstream_raw=transport_error_raw(exc),
+                    ) from exc
+
+                raw_chunks.clear()
+                retry_delay = _STREAM_RETRY_DELAYS_SECONDS[attempt - 1]
+                _LOGGER.warning(
+                    "Bing response failed before output; retrying attempt %d/%d "
+                    "after %.1fs (type=%s, code=%s)",
+                    attempt + 1,
+                    _STREAM_MAX_ATTEMPTS,
+                    retry_delay,
+                    type(exc).__name__,
+                    getattr(exc, "code", None),
+                )
+                await asyncio.sleep(retry_delay)
+
+        answer = "".join(answer_parts)
+        response = AgentSearchResponse(
+            engine=AgentEngineType.BING.value,
+            query=request.query,
+            answer=answer,
+            raw=raw_chunks if len(raw_chunks) != 1 else raw_chunks[0],
+        )
+        yield AgentSearchDone(response=response)

{unique_search_proxy-2026.44.0.dev0 → unique_search_proxy-2026.44.0.dev1}/unique_search_proxy_client/web/core/agent_engines/factory.py

@@ -17,17 +17,22 @@ from unique_search_proxy_client.web.core.agent_engines.vertexai.service import (
 
 if TYPE_CHECKING:
     from httpx import AsyncClient
+    from unique_search_proxy_core.http_client import EgressRoute
 
 
 def get_agent_engine_service(
     engine: AgentEngineType,
     *,
-    http_client: AsyncClient | None = None,
+    http_client: AsyncClient,
+    egress_route: EgressRoute,
 ) -> AgentSearchEngine[Any]:
     """Instantiate an agent search engine by registered id."""
     match engine:
         case AgentEngineType.BING:
-            return BingAgentSearchService(http_client=http_client)
+            return BingAgentSearchService(
+                http_client=http_client,
+                egress_route=egress_route,
+            )
         case AgentEngineType.VERTEXAI:
             return VertexAIAgentSearchService(http_client=http_client)
         case _:

{unique_search_proxy-2026.44.0.dev0 → unique_search_proxy-2026.44.0.dev1}/unique_search_proxy_client/web/core/agent_engines/service_base.py

@@ -1,28 +1,18 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Generic
+from typing import Generic
 
 from unique_search_proxy_core.agent_engines.base import (
     AgentRequestT,
     AgentSearchEngine,
 )
 
-if TYPE_CHECKING:
-    from httpx import AsyncClient
-
 
 class AgentSearchEngineService(
     AgentSearchEngine[AgentRequestT], Generic[AgentRequestT]
 ):
     """Client-side agent search engine base (HTTP client wiring)."""
 
-    def __init__(
-        self,
-        *,
-        http_client: AsyncClient | None = None,
-    ) -> None:
-        super().__init__(http_client=http_client)
-
     @property
     def mode(self) -> str:
         return "agent"

{unique_search_proxy-2026.44.0.dev0 → unique_search_proxy-2026.44.0.dev1}/unique_search_proxy_client/web/core/agent_engines/vertexai/client.py

@@ -7,6 +7,8 @@ from base64 import b64decode
 from google.auth import load_credentials_from_dict
 from google.genai._api_client import BaseApiClient
 from google.genai.client import AsyncClient
+from google.genai.types import HttpOptions
+from httpx import AsyncClient as HttpxAsyncClient
 
 from unique_search_proxy_client.web.settings.providers.vertexai_agent import (
     vertexai_agent_credentials,
@@ -19,7 +21,9 @@ from unique_search_proxy_client.web.settings.secret_str import (
 _LOGGER = logging.getLogger(__name__)
 
 
-def _get_base_api_client_from_service_account() -> BaseApiClient:
+def _get_base_api_client_from_service_account(
+    http_client: HttpxAsyncClient | None = None,
+) -> BaseApiClient:
     if not is_secret_configured(vertexai_agent_credentials.service_account_credentials):
         msg = (
             "VERTEXAI_AGENT_CREDENTIAL_TYPE is 'service_account' but "
@@ -43,20 +47,28 @@ def _get_base_api_client_from_service_account() -> BaseApiClient:
         vertexai=True,
         credentials=credentials,
         project=project_id,
+        http_options=HttpOptions(httpx_async_client=http_client),
     )
 
 
-def _get_base_api_client_from_adc() -> BaseApiClient:
-    return BaseApiClient(vertexai=True)
+def _get_base_api_client_from_adc(
+    http_client: HttpxAsyncClient | None = None,
+) -> BaseApiClient:
+    return BaseApiClient(
+        vertexai=True,
+        http_options=HttpOptions(httpx_async_client=http_client),
+    )
 
 
-def get_vertex_client() -> AsyncClient:
+def get_vertex_client(
+    http_client: HttpxAsyncClient | None = None,
+) -> AsyncClient:
     if vertexai_agent_credentials.credential_type == "service_account":
         _LOGGER.info("Using explicit service account credentials for VertexAI agent")
-        base_api_client = _get_base_api_client_from_service_account()
+        base_api_client = _get_base_api_client_from_service_account(http_client)
     else:
         _LOGGER.info("Using workload identity (ADC) for VertexAI agent")
-        base_api_client = _get_base_api_client_from_adc()
+        base_api_client = _get_base_api_client_from_adc(http_client)
     return AsyncClient(api_client=base_api_client)
 
 

{unique_search_proxy-2026.44.0.dev0 → unique_search_proxy-2026.44.0.dev1}/unique_search_proxy_client/web/core/agent_engines/vertexai/service.py

@@ -42,7 +42,7 @@ class VertexAIAgentSearchService(
 
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
-        self._client = get_vertex_client()
+        self._client = get_vertex_client(self._http_client)
 
     async def search(self, request: VertexAIAgentSearchRequest) -> AgentSearchResponse:  # type: ignore[override]
         response: AgentSearchResponse | None = None