unique_web_search 2026.32.0.dev1__tar.gz → 2026.32.0.dev2__tar.gz

{unique_web_search-2026.32.0.dev1 → unique_web_search-2026.32.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-web-search
-Version: 2026.32.0.dev1
+Version: 2026.32.0.dev2
 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>
@@ -14,7 +14,7 @@ Requires-Dist: fake-useragent>=2.2.0,<3
 Requires-Dist: firecrawl>=3.3.2,<4
 Requires-Dist: tavily-python>=0.7.11,<1
 Requires-Dist: unidecode>=1.4.0,<2
-Requires-Dist: azure-ai-projects>=1.0.0,<2
+Requires-Dist: azure-ai-projects>=2.3,<3
 Requires-Dist: azure-identity>=1.25.0,<2
 Requires-Dist: unique-toolkit[monitoring]>=2026.32.0.dev4,<2026.32.0rc0
 Requires-Dist: azure-core>=1.36.0,<2
@@ -25,8 +25,9 @@ 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.32.0.dev2,<2026.32.0rc0
+Requires-Dist: unique-search-proxy-core>=2026.32.0.dev3,<2026.32.0rc0
 Requires-Dist: unique-search-proxy-sdk>=2026.32.0.dev0,<2026.32.0rc0
+Requires-Dist: openai>=1.105.0,<3
 Requires-Python: >=3.12, <4.0
 Description-Content-Type: text/markdown
 

{unique_web_search-2026.32.0.dev1 → unique_web_search-2026.32.0.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_web_search"
-version = "2026.32.0.dev1"
+version = "2026.32.0.dev2"
 description = ""
 readme = "README.md"
 requires-python = ">=3.12,<4.0"
@@ -20,7 +20,7 @@ dependencies = [
     "firecrawl>=3.3.2,<4",
     "tavily-python>=0.7.11,<1",
     "unidecode>=1.4.0,<2",
-    "azure-ai-projects>=1.0.0,<2",
+    "azure-ai-projects>=2.3,<3",
     "azure-identity>=1.25.0,<2",
     "unique-toolkit[monitoring]>=2026.32.0.dev4,<2026.32.0rc0",
     "azure-core>=1.36.0,<2",
@@ -31,8 +31,9 @@ dependencies = [
     "httpx>=0.28.1",
     "certifi>=2025.11.12",
     "jinja2>=3.1.6",
-    "unique-search-proxy-core>=2026.32.0.dev2,<2026.32.0rc0",
+    "unique-search-proxy-core>=2026.32.0.dev3,<2026.32.0rc0",
     "unique-search-proxy-sdk>=2026.32.0.dev0,<2026.32.0rc0",
+    "openai>=1.105.0,<3",
 ]
 
 [build-system]
@@ -91,4 +92,4 @@ extend-select = ["I"]
 [tool.uv.sources]
 unique-toolkit = { workspace = true }
 unique-search-proxy-sdk = { workspace = true }
-unique-search-proxy-core = { workspace = true }
+unique-search-proxy-core = { workspace = true }

{unique_web_search-2026.32.0.dev1 → unique_web_search-2026.32.0.dev2}/src/unique_web_search/services/search_engine/bing.py

@@ -100,13 +100,14 @@ class BingSearch(SearchEngine[BingSearchConfig]):
         del params
         agent_client = get_project_client(self.credentials, self.config.endpoint)
 
-        search_results = await create_and_process_run(
-            agent_client,
-            agent_id=self.config.agent_id,
-            query=query,
-            fetch_size=self.config.fetch_size,
-            response_parsers_strategies=self.response_parsers,
-            generation_instructions=self.config.generation_instructions,
-        )
+        async with agent_client:
+            search_results = await create_and_process_run(
+                agent_client,
+                agent_id=self.config.agent_id,
+                query=query,
+                fetch_size=self.config.fetch_size,
+                response_parsers_strategies=self.response_parsers,
+                generation_instructions=self.config.generation_instructions,
+            )
 
         return search_results

{unique_web_search-2026.32.0.dev1 → unique_web_search-2026.32.0.dev2}/src/unique_web_search/services/search_engine/utils/grounding/bing/client.py

@@ -1,14 +1,17 @@
 import logging
 
 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.identity.aio import DefaultAzureCredential, WorkloadIdentityCredential
+from openai import AsyncOpenAI
 
 from unique_web_search.settings import env_settings
 
 _LOGGER = logging.getLogger(__name__)
+_private_endpoint_http_client: httpx.AsyncClient | None = None
 
 
 def _get_workload_identity_credentials(
@@ -16,14 +19,11 @@ def _get_workload_identity_credentials(
 ) -> WorkloadIdentityCredential:
     if with_request_transport:
         transport = AsyncioRequestsTransport(connection_verify=certifi.where())
-        credentials = WorkloadIdentityCredential(transport=transport)
-    else:
-        credentials = WorkloadIdentityCredential()
-
-    return credentials
+        return WorkloadIdentityCredential(transport=transport)
+    return WorkloadIdentityCredential()
 
 
-def get_credentials():
+def get_credentials() -> AsyncTokenCredential:
     match env_settings.azure_identity_credential_type:
         case "workload":
             return _get_workload_identity_credentials(
@@ -31,10 +31,8 @@ def get_credentials():
             )
         case "default":
             return DefaultAzureCredential()
-        case _:
-            raise ValueError(
-                f"Invalid Azure identity credential type: {env_settings.azure_identity_credential_type}"
-            )
+        case other:
+            raise ValueError(f"Invalid Azure identity credential type: {other}")
 
 
 async def credentials_are_valid(credentials: AsyncTokenCredential) -> bool:
@@ -72,3 +70,36 @@ def get_project_client(
             credential=credentials,
             endpoint=endpoint,
         )
+
+
+def _get_private_endpoint_http_client() -> httpx.AsyncClient:
+    """Return a process-wide certifi-backed httpx client (created once)."""
+    global _private_endpoint_http_client
+    if _private_endpoint_http_client is None or _private_endpoint_http_client.is_closed:
+        _private_endpoint_http_client = httpx.AsyncClient(verify=certifi.where())
+    return _private_endpoint_http_client
+
+
+async def aclose_private_endpoint_http_client() -> None:
+    """Close the shared private-endpoint httpx client if it was created."""
+    global _private_endpoint_http_client
+    if (
+        _private_endpoint_http_client is not None
+        and not _private_endpoint_http_client.is_closed
+    ):
+        await _private_endpoint_http_client.aclose()
+    _private_endpoint_http_client = None
+
+
+def get_openai_client(project_client: AIProjectClient) -> AsyncOpenAI:
+    """Return an authenticated AsyncOpenAI client from the Foundry project client.
+
+    When private-endpoint transport is enabled, reuse a shared certifi-backed
+    ``httpx.AsyncClient`` so TLS verification matches the AIProjectClient path
+    without leaking a new client per request.
+    """
+    if env_settings.use_unique_private_endpoint_transport:
+        return project_client.get_openai_client(
+            http_client=_get_private_endpoint_http_client(),
+        )
+    return project_client.get_openai_client()

unique_web_search-2026.32.0.dev2/src/unique_web_search/services/search_engine/utils/grounding/bing/runner.py

@@ -0,0 +1,361 @@
+from __future__ import annotations
+
+import hashlib
+import logging
+import time
+
+import openai
+from azure.ai.projects.aio import AIProjectClient
+from azure.ai.projects.models import (
+    BingGroundingSearchConfiguration,
+    BingGroundingSearchToolParameters,
+    BingGroundingTool,
+    PromptAgentDefinition,
+)
+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 (
+    ResponseOutputItemDoneEvent,
+)
+from openai.types.responses.response_output_message import ResponseOutputMessage
+from openai.types.responses.response_output_text import (
+    AnnotationURLCitation,
+    ResponseOutputText,
+)
+from openai.types.responses.response_text_delta_event import ResponseTextDeltaEvent
+
+from unique_web_search.invocation_stats import record_token_usage
+from unique_web_search.services.search_engine.schema import (
+    WebSearchResult,
+)
+from unique_web_search.services.search_engine.utils.grounding import (
+    ResponseParser,
+    convert_response_to_search_results,
+)
+from unique_web_search.services.search_engine.utils.grounding.bing.client import (
+    get_openai_client,
+)
+from unique_web_search.services.search_engine.utils.grounding.bing.models import (
+    RESPONSE_RULE,
+)
+from unique_web_search.settings import env_settings
+
+_LOGGER = logging.getLogger(__name__)
+BING_AUTO_AGENT_NAME_PREFIX = "unique-grounding-with-bing"
+_CONFIG_HASH_LENGTH = 12
+
+
+# ---------------------------------------------------------------------------
+# Agent naming
+# ---------------------------------------------------------------------------
+
+
+def _config_hash(*, model: str, fetch_size: int, instructions: str) -> str:
+    """Return a short hex digest of model + fetch_size + instructions for agent naming."""
+    payload = f"{model}\0{fetch_size}\0{instructions}".encode()
+    return hashlib.sha256(payload).hexdigest()[:_CONFIG_HASH_LENGTH]
+
+
+def _agent_name_for_config(*, model: str, fetch_size: int, instructions: str) -> str:
+    """Build a Foundry-safe agent name unique to this config."""
+    return (
+        f"{BING_AUTO_AGENT_NAME_PREFIX}-"
+        f"{_config_hash(model=model, fetch_size=fetch_size, instructions=instructions)}"
+    )
+
+
+def resolve_bing_agent_name(
+    *,
+    model: str,
+    fetch_size: int,
+    instructions: str,
+    agent_name: str | None = None,
+) -> str:
+    """Return the agent name to use for Responses (no Foundry round-trip).
+
+    Prefers an explicit / env-preconfigured name; otherwise derives a stable
+    hash-based name from ``model`` + ``fetch_size`` + ``instructions``.
+    """
+    resolved = agent_name or env_settings.azure_ai_assistant_id or None
+    if resolved:
+        return resolved
+    return _agent_name_for_config(
+        model=model, fetch_size=fetch_size, instructions=instructions
+    )
+
+
+async def create_bing_agent(
+    agent_client: AIProjectClient,
+    *,
+    agent_name: str,
+    model: str,
+    fetch_size: int,
+    instructions: str,
+) -> str:
+    """Create a Foundry agent version and return its name."""
+    started = time.perf_counter()
+    agent = await agent_client.agents.create_version(
+        agent_name=agent_name,
+        definition=PromptAgentDefinition(
+            model=model,
+            instructions=instructions,
+            tools=[get_bing_grounding_tool(fetch_size)],
+            tool_choice="required",
+        ),
+        description="Unique Bing grounding agent",
+    )
+    elapsed_ms = (time.perf_counter() - started) * 1000
+    _LOGGER.info(
+        "Created Bing grounding agent version %s (id=%s) in %.0fms",
+        agent.name,
+        agent.id,
+        elapsed_ms,
+    )
+    return agent.name
+
+
+async def get_or_create_agent_id(agent_client: AIProjectClient) -> str:
+    """Compatibility wrapper: return the resolved Bing grounding agent name.
+
+    Does not call Foundry. Creation happens lazily on Responses miss.
+    """
+    del agent_client  # kept for call-site compatibility
+    return resolve_bing_agent_name(
+        model=env_settings.azure_ai_bing_agent_model,
+        fetch_size=5,
+        instructions=RESPONSE_RULE,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Bing grounding tool
+# ---------------------------------------------------------------------------
+
+
+def get_bing_grounding_tool(fetch_size: int) -> BingGroundingTool:
+    """Build a BingGroundingTool configured with the environment connection string.
+
+    Args:
+        fetch_size: Maximum number of search results the tool should return.
+
+    Raises:
+        ValueError: If the Bing resource connection string is not configured.
+    """
+    connection_id = env_settings.azure_ai_bing_resource_connection_string
+    if not connection_id:
+        raise ValueError("Azure AI Bing Resource Connection String is not set")
+    return BingGroundingTool(
+        bing_grounding=BingGroundingSearchToolParameters(
+            search_configurations=[
+                BingGroundingSearchConfiguration(
+                    project_connection_id=connection_id,
+                    count=fetch_size,
+                )
+            ]
+        )
+    )
+
+
+# ---------------------------------------------------------------------------
+# Run orchestration
+# ---------------------------------------------------------------------------
+
+
+def _is_missing_agent_error(exc: BaseException, *, agent_name: str) -> bool:
+    """Return True when Responses failed because the agent does not exist."""
+    status_code = getattr(exc, "status_code", None)
+    message = str(exc).lower()
+    name_lower = agent_name.lower()
+
+    if isinstance(exc, openai.NotFoundError) or status_code == 404:
+        return True
+
+    missing_markers = (
+        "not found",
+        "does not exist",
+        "unknown agent",
+        "agent_not_found",
+        "no agent",
+    )
+    if any(marker in message for marker in missing_markers) and name_lower in message:
+        return True
+    if status_code in {400, 404} and any(
+        marker in message for marker in missing_markers
+    ):
+        return True
+    return False
+
+
+async def create_and_process_run(
+    agent_client: AIProjectClient,
+    agent_id: str,
+    query: str,
+    fetch_size: int,
+    response_parsers_strategies: list[ResponseParser],
+    generation_instructions: str,
+) -> list[WebSearchResult]:
+    """Execute a Bing-grounded agent run and return parsed search results.
+
+    Optimistically calls Responses with a hashed (or preconfigured) agent name.
+    If the agent is missing and the name was auto-derived, creates the agent once
+    and retries. Preconfigured agent names are never auto-created.
+
+    Args:
+        agent_client: Azure AI project client used to manage agents.
+        agent_id: Optional Foundry agent name; empty triggers hash-based naming.
+        query: The search query to send to the agent.
+        fetch_size: Maximum number of Bing results the agent should retrieve.
+        response_parsers_strategies: Ordered list of parsing strategies to try
+            when converting the agent's free-text response into structured results.
+        generation_instructions: Per-request system instructions for the agent.
+
+    Raises:
+        Exception: If the agent run fails.
+        ValueError: If none of the parser strategies can parse the response.
+    """
+    instructions = f"{generation_instructions}\n{RESPONSE_RULE}"
+    model = env_settings.azure_ai_bing_agent_model
+    preconfigured = agent_id or env_settings.azure_ai_assistant_id or None
+    answer = await _run_responses_agent(
+        agent_client,
+        query=query,
+        model=model,
+        fetch_size=fetch_size,
+        instructions=instructions,
+        agent_name=preconfigured,
+    )
+
+    return await convert_response_to_search_results(answer, response_parsers_strategies)
+
+
+async def _run_responses_agent(
+    agent_client: AIProjectClient,
+    *,
+    query: str,
+    model: str,
+    fetch_size: int,
+    instructions: str,
+    agent_name: str | None = None,
+) -> str:
+    """Invoke the agent via Responses API and return the full output text.
+
+    Instructions must already be baked into the agent version — Foundry returns
+    ``invalid_payload`` if ``instructions`` is passed alongside ``agent_reference``.
+    """
+    # Treat empty string like unset so auto-provisioning still works.
+    # Env assistant id is also preconfigured (same as resolve_bing_agent_name).
+    preconfigured = agent_name or env_settings.azure_ai_assistant_id or None
+    resolved_name = resolve_bing_agent_name(
+        model=model,
+        fetch_size=fetch_size,
+        instructions=instructions,
+        agent_name=preconfigured,
+    )
+    allow_create = preconfigured is None
+    openai_client = get_openai_client(agent_client)
+
+    try:
+        stream = await _create_responses_stream(
+            openai_client,
+            agent_name=resolved_name,
+            query=query,
+        )
+    except Exception as exc:
+        if not allow_create or not _is_missing_agent_error(
+            exc, agent_name=resolved_name
+        ):
+            raise
+        _LOGGER.info(
+            "Responses failed for missing Bing agent %s; creating then retrying: %s",
+            resolved_name,
+            exc,
+        )
+        await create_bing_agent(
+            agent_client,
+            agent_name=resolved_name,
+            model=model,
+            fetch_size=fetch_size,
+            instructions=instructions,
+        )
+        stream = await _create_responses_stream(
+            openai_client,
+            agent_name=resolved_name,
+            query=query,
+        )
+
+    answer_parts: list[str] = []
+    citation_replacements: list[tuple[str, str]] = []
+    emitted_text = False
+
+    async with stream:
+        async for event in stream:
+            if isinstance(event, ResponseTextDeltaEvent):
+                if event.delta:
+                    emitted_text = True
+                    answer_parts.append(event.delta)
+            elif isinstance(event, ResponseOutputItemDoneEvent):
+                citation_replacements.extend(_extract_markdown_citations(event))
+            elif isinstance(event, ResponseCompletedEvent):
+                output_text = event.response.output_text
+                # Foundry sometimes delivers the full answer only on completion.
+                if output_text and not emitted_text:
+                    emitted_text = True
+                    answer_parts.append(output_text)
+                record_token_usage(
+                    model_name=model,
+                    usage=event.response.usage,
+                    source="web_search.grounding.bing",
+                )
+
+    answer = "".join(answer_parts)
+    for marker, markdown_link in citation_replacements:
+        answer = answer.replace(marker, markdown_link)
+    return answer
+
+
+async def _create_responses_stream(
+    openai_client: openai.AsyncOpenAI,
+    *,
+    agent_name: str,
+    query: str,
+) -> openai.AsyncStream[ResponseStreamEvent]:
+    started = time.perf_counter()
+    stream = await openai_client.responses.create(
+        stream=True,
+        input=query,
+        extra_body={
+            "agent_reference": {
+                "name": agent_name,
+                "type": "agent_reference",
+            }
+        },
+    )
+    elapsed_ms = (time.perf_counter() - started) * 1000
+    _LOGGER.info(
+        "Opened Bing Responses stream for agent %s in %.0fms",
+        agent_name,
+        elapsed_ms,
+    )
+    return stream
+
+
+def _extract_markdown_citations(
+    event: ResponseOutputItemDoneEvent,
+) -> list[tuple[str, str]]:
+    """Extract (placeholder, markdown-link) pairs from a message output item."""
+    item = event.item
+    if not isinstance(item, ResponseOutputMessage) or not item.content:
+        return []
+    text_content = item.content[-1]
+    if not isinstance(text_content, ResponseOutputText):
+        return []
+
+    replacements: list[tuple[str, str]] = []
+    for annotation in text_content.annotations:
+        if not isinstance(annotation, AnnotationURLCitation):
+            continue
+        marker = text_content.text[annotation.start_index : annotation.end_index]
+        title = annotation.title or annotation.url
+        if annotation.url and marker:
+            replacements.append((marker, f"[{title}]({annotation.url})"))
+    return replacements

unique_web_search-2026.32.0.dev1/src/unique_web_search/services/search_engine/utils/grounding/bing/runner.py

@@ -1,208 +0,0 @@
-import logging
-
-from azure.ai.agents.models import (
-    AgentThreadCreationOptions,
-    BingGroundingTool,
-    MessageTextContent,
-    MessageTextUrlCitationAnnotation,
-    RunStatus,
-    ThreadMessageOptions,
-)
-from azure.ai.projects.aio import AIProjectClient
-
-from unique_web_search.invocation_stats import record_token_usage
-from unique_web_search.services.search_engine.schema import (
-    WebSearchResult,
-)
-from unique_web_search.services.search_engine.utils.grounding import (
-    ResponseParser,
-    convert_response_to_search_results,
-)
-from unique_web_search.services.search_engine.utils.grounding.bing.models import (
-    RESPONSE_RULE,
-)
-from unique_web_search.settings import env_settings
-
-_LOGGER = logging.getLogger(__name__)
-_AGENT_NAME_IDENTIFIER = "UNIQUE_GROUNDING_WITH_BING_AGENT"
-
-
-# ---------------------------------------------------------------------------
-# Agent management
-# ---------------------------------------------------------------------------
-
-
-async def _get_agent_id(agent_client: AIProjectClient) -> str:
-    """Look up the existing Bing grounding agent by name.
-
-    Raises:
-        Exception: If no agent with the expected name exists.
-    """
-    list_agents = agent_client.agents.list_agents()
-
-    async for agent in list_agents:
-        if agent.name == _AGENT_NAME_IDENTIFIER:
-            _LOGGER.info(f"Found agent {agent.id} with name {agent.name}")
-            return agent.id
-
-    raise Exception(f"Agent {_AGENT_NAME_IDENTIFIER} not found")
-
-
-async def _create_agent_id(agent_client: AIProjectClient) -> str:
-    """Provision a new Bing grounding agent using the configured model."""
-    agent = await agent_client.agents.create_agent(
-        name=_AGENT_NAME_IDENTIFIER,
-        model=env_settings.azure_ai_bing_agent_model,
-    )
-    return agent.id
-
-
-async def get_or_create_agent_id(agent_client: AIProjectClient) -> str:
-    """Return the Bing grounding agent id, creating one if it doesn't exist yet."""
-    if env_settings.azure_ai_assistant_id:
-        return env_settings.azure_ai_assistant_id
-
-    try:
-        _LOGGER.info("Looking for existing agent")
-        return await _get_agent_id(agent_client)
-    except Exception as e:
-        _LOGGER.exception(f"Error getting agent: {e}")
-        _LOGGER.info("No existing agent found, creating a new one")
-        return await _create_agent_id(agent_client)
-
-
-# ---------------------------------------------------------------------------
-# Bing grounding tool
-# ---------------------------------------------------------------------------
-
-
-def get_bing_grounding_tool(fetch_size: int) -> BingGroundingTool:
-    """Build a BingGroundingTool configured with the environment connection string.
-
-    Args:
-        fetch_size: Maximum number of search results the tool should return.
-
-    Raises:
-        ValueError: If the Bing resource connection string is not configured.
-    """
-    connection_id = env_settings.azure_ai_bing_resource_connection_string
-    if not connection_id:
-        raise ValueError("Azure AI Bing Resource Connection String is not set")
-    return BingGroundingTool(connection_id=connection_id, count=fetch_size)
-
-
-# ---------------------------------------------------------------------------
-# Run orchestration
-# ---------------------------------------------------------------------------
-
-
-async def create_and_process_run(
-    agent_client: AIProjectClient,
-    agent_id: str,
-    query: str,
-    fetch_size: int,
-    response_parsers_strategies: list[ResponseParser],
-    generation_instructions: str,
-) -> list[WebSearchResult]:
-    """Execute a Bing-grounded agent run and return parsed search results.
-
-    Creates a thread with the user query, runs the agent with Bing grounding,
-    then converts the unstructured response into ``WebSearchResult`` objects by
-    trying each parser strategy in order until one succeeds.
-
-    Args:
-        agent_client: Azure AI project client used to manage agents and threads.
-        query: The search query to send to the agent.
-        fetch_size: Maximum number of Bing results the agent should retrieve.
-        response_parsers_strategies: Ordered list of parsing strategies to try
-            when converting the agent's free-text response into structured results.
-
-    Raises:
-        Exception: If the agent run fails, is cancelled, or expires.
-        ValueError: If none of the parser strategies can parse the response.
-    """
-    if not agent_id:
-        _LOGGER.warning("No agent ID provided")
-        thread = await _create_agent_and_run_thread(
-            agent_client, query, fetch_size, generation_instructions
-        )
-    else:
-        _LOGGER.warning(f"Using existing agent ID: {agent_id}")
-        thread = await _create_agent_run_with_agent_id(agent_client, agent_id, query)
-
-    record_token_usage(
-        model_name=env_settings.azure_ai_bing_agent_model,
-        usage=getattr(thread, "usage", None),
-        source="web_search.grounding.bing",
-    )
-
-    if thread.status in [RunStatus.FAILED, RunStatus.CANCELLED, RunStatus.EXPIRED]:
-        raise Exception(f"Run failed: {thread.last_error}")
-
-    answer = await _get_answer_from_thread(thread.thread_id, agent_client)
-
-    search_results = await convert_response_to_search_results(
-        answer, response_parsers_strategies
-    )
-
-    return search_results
-
-
-async def _create_agent_run_with_agent_id(
-    agent_client: AIProjectClient,
-    agent_id: str,
-    query: str,
-):
-    """Execute a Bing-grounded agent run and return parsed search results."""
-    agent_run = await agent_client.agents.create_thread_and_process_run(
-        agent_id=agent_id,
-        thread=AgentThreadCreationOptions(
-            messages=[ThreadMessageOptions(role="user", content=query)]
-        ),
-    )
-    return agent_run
-
-
-async def _create_agent_and_run_thread(
-    agent_client: AIProjectClient,
-    query: str,
-    fetch_size: int,
-    generation_instructions: str,
-):
-    agent_id = await get_or_create_agent_id(agent_client)
-
-    instructions = f"{generation_instructions}\n{RESPONSE_RULE}"
-
-    agent_run = await agent_client.agents.create_thread_and_process_run(
-        agent_id=agent_id,
-        model=env_settings.azure_ai_bing_agent_model,
-        toolset=get_bing_grounding_tool(fetch_size=fetch_size),  # type: ignore
-        instructions=instructions,
-        thread=AgentThreadCreationOptions(
-            messages=[ThreadMessageOptions(role="user", content=query)]
-        ),
-    )
-    return agent_run
-
-
-async def _get_answer_from_thread(thread_id: str, agent_client: AIProjectClient) -> str:
-    """Concatenate all assistant text messages from a thread into a single string."""
-    messages = agent_client.agents.messages.list(thread_id=thread_id)
-    answer = ""
-    citations: list[MessageTextUrlCitationAnnotation] = []
-
-    async for message in messages:
-        if message.role == "assistant":
-            for content in message.content:
-                if isinstance(content, MessageTextContent):
-                    answer += content.text.value
-                elif isinstance(content, MessageTextUrlCitationAnnotation):
-                    citations.append(content)
-
-    for citation in citations:
-        answer = answer.replace(
-            citation.text,
-            f"[{citation.url_citation.title}]({citation.url_citation.url})",
-        )
-
-    return answer