unique_web_search 2026.30.0.dev1__tar.gz → 2026.30.0.dev2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-web-search
-Version: 2026.30.0.dev1
+Version: 2026.30.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>
@@ -17,7 +17,7 @@ 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-identity>=1.25.0,<2
-Requires-Dist: unique-toolkit[monitoring]>=2026.30.0.dev10,<2026.30.0rc0
+Requires-Dist: unique-toolkit[monitoring]>=2026.30.0.dev12,<2026.30.0rc0
 Requires-Dist: azure-core>=1.36.0,<2
 Requires-Dist: google-cloud-aiplatform>=1.128.0,<2
 Requires-Dist: google-auth>=2.43.0,<3

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

@@ -1,6 +1,6 @@
 [project]
 name = "unique_web_search"
-version = "2026.30.0.dev1"
+version = "2026.30.0.dev2"
 description = ""
 readme = "README.md"
 requires-python = ">=3.12,<4.0"
@@ -23,7 +23,7 @@ dependencies = [
     "unidecode>=1.4.0,<2",
     "azure-ai-projects>=1.0.0,<2",
     "azure-identity>=1.25.0,<2",
-    "unique-toolkit[monitoring]>=2026.30.0.dev10,<2026.30.0rc0",
+    "unique-toolkit[monitoring]>=2026.30.0.dev12,<2026.30.0rc0",
     "azure-core>=1.36.0,<2",
     "google-cloud-aiplatform>=1.128.0,<2",
     "google-auth>=2.43.0,<3",

{unique_web_search-2026.30.0.dev1 → unique_web_search-2026.30.0.dev2}/src/unique_web_search/service.py

@@ -1,9 +1,7 @@
 import logging
-import re
 from datetime import datetime
 from time import time
 
-from jinja2 import Template
 from typing_extensions import override
 from unique_search_proxy_core.param_policy.exposed_params import ExposedParams
 from unique_search_proxy_core.search_engines.base import BaseSearchEngineConfig
@@ -33,29 +31,22 @@ from unique_web_search.services.argument_screening import (
 )
 from unique_web_search.services.content_processing import ContentProcessor
 from unique_web_search.services.crawlers import get_crawler_service
-from unique_web_search.services.executors import (
-    WebSearchMode,
-    WebSearchV1Executor,
-    WebSearchV2Executor,
-    WebSearchV3Config,
-    WebSearchV3Executor,
-)
 from unique_web_search.services.executors.context import (
     ExecutorCallbacks,
     ExecutorConfiguration,
     ExecutorServiceContext,
 )
-from unique_web_search.services.executors.v1.schema import WebSearchToolParameters
-from unique_web_search.services.executors.v2.schema import WebSearchPlan
-from unique_web_search.services.executors.v3.schema import WebSearchV3ToolParameters
+from unique_web_search.services.executors.modes import (
+    WebSearchExecutor,
+    WebSearchToolContext,
+    WebSearchToolParametersInstance,
+    get_mode_strategy,
+)
 from unique_web_search.services.message_log import WebSearchMessageLogger
 from unique_web_search.services.query_elicitation import QueryElicitationService
 from unique_web_search.services.search_engine import (
-    SearchEngineMode,
-    get_search_engine_mode,
     get_search_engine_service,
 )
-from unique_web_search.services.search_engine.custom_api import CustomAPIConfig
 from unique_web_search.utils import (
     WebPageChunk,
     reduce_sources_to_token_limit,
@@ -100,6 +91,7 @@ class WebSearchTool(Tool[WebSearchConfig]):
         self.debug = self.config.debug
         self._display_name = kwargs.get("display_name", "Web Search")
         self.exposed_params_cls = self._resolve_exposed_params_cls()
+        self._mode_strategy = get_mode_strategy(self.config.web_search_mode_config)
 
         def content_reducer(web_page_chunks: list[WebPageChunk]) -> list[WebPageChunk]:
 
@@ -121,85 +113,30 @@ class WebSearchTool(Tool[WebSearchConfig]):
             return cfg.exposed_params_model()
         return None
 
-    def _resolve_search_engine_mode(self) -> SearchEngineMode:
-        """Derive the search-engine mode, respecting CustomAPI overrides."""
-        cfg = self.search_engine_service.config
-        override = cfg.search_engine_mode if isinstance(cfg, CustomAPIConfig) else None
-        return get_search_engine_mode(cfg.engine, override=override)
+    def _tool_context(self) -> WebSearchToolContext:
+        return WebSearchToolContext(
+            search_engine_config=self.search_engine_service.config,
+            date_string=datetime.now().strftime("%A %B %d, %Y"),
+            exposed_params_cls=self.exposed_params_cls,
+        )
 
     @override
     def tool_description(self) -> LanguageModelToolDescription:
-        exposed = self.exposed_params_cls
-        if self.config.web_search_mode_config.mode == WebSearchMode.V1:
-            self.tool_parameter_calls = WebSearchToolParameters.with_exposed_params(
-                exposed
-            )
-        else:
-            if self.config.web_search_mode_config.mode == WebSearchMode.V3:
-                self.tool_parameter_calls = (
-                    WebSearchV3ToolParameters.with_exposed_params(exposed)
-                )
-            else:
-                engine_mode = self._resolve_search_engine_mode()
-                self.tool_parameter_calls = WebSearchPlan.with_search_engine_mode(
-                    engine_mode
-                )
-
-        tool_description = self.config.web_search_mode_config.tool_description
-
-        if self.config.web_search_mode_config.mode == WebSearchMode.V3:
-            tool_description = Template(tool_description).render(
-                tool_parameters_schema=WebSearchV3ToolParameters.schema_hint(exposed),
-            )
-
+        ctx = self._tool_context()
+        self.tool_parameter_calls = self._mode_strategy.build_tool_parameters(ctx)
         return LanguageModelToolDescription(
             name=self.name,
-            description=tool_description,
+            description=self._mode_strategy.tool_description(ctx),
             parameters=self.tool_parameter_calls,
         )
 
     def tool_description_for_system_prompt(self) -> str:
-        mode_config = self.config.web_search_mode_config
-        if mode_config.mode == WebSearchMode.V1:
-            return mode_config.tool_description_for_system_prompt
-
-        template_str = mode_config.tool_description_for_system_prompt
-
-        if mode_config.mode == WebSearchMode.V3:
-            return Template(template_str).render(
-                date_string=datetime.now().strftime("%A %B %d, %Y"),
-            )
-
-        # Backwards compatibility: V2 prompts persisted before the Jinja
-        # migration use the legacy ``$max_steps`` placeholder. Jinja would
-        # otherwise pass it through verbatim, so rewrite it to the Jinja
-        # equivalent before rendering.
-        if "$max_steps" in template_str:
-            _LOGGER.warning(
-                "V2 web-search prompt contains legacy '$max_steps' placeholder; "
-                "rewriting to '{{ max_steps }}'. Please update the stored "
-                "configuration to use Jinja syntax."
-            )
-            template_str = template_str.replace("$max_steps", "{{ max_steps }}")
-
-        engine_mode = self._resolve_search_engine_mode()
-        return Template(template_str).render(
-            max_steps=mode_config.max_steps,
-            date_string=datetime.now().strftime("%A %B %d, %Y"),
-            search_engine_mode=engine_mode.value,
-            tool_parameters_schema=WebSearchPlan.schema_hint(engine_mode),
-            example_simple=WebSearchPlan.build_example_simple(
-                engine_mode
-            ).model_dump_json(indent=2),
-            example_complex=WebSearchPlan.build_example_complex(
-                engine_mode
-            ).model_dump_json(indent=2),
-        )
+        return self._mode_strategy.system_prompt(self._tool_context())
 
     def tool_format_information_for_system_prompt(self) -> str:
-        if self.config.web_search_active_mode == WebSearchMode.V3:
-            return self.config.web_search_mode_config_v3.tool_format_information_for_system_prompt
-        return self.config.tool_format_information_for_system_prompt
+        return self._mode_strategy.format_information_for_system_prompt(
+            default=self.config.tool_format_information_for_system_prompt,
+        )
 
     def evaluation_check_list(self) -> list[EvaluationMetricName]:
         return self.config.evaluation_check_list
@@ -301,18 +238,16 @@ class WebSearchTool(Tool[WebSearchConfig]):
     def _get_executor(
         self,
         tool_call: LanguageModelFunction,
-        parameters: WebSearchPlan | WebSearchToolParameters | WebSearchV3ToolParameters,
+        parameters: WebSearchToolParametersInstance,
         debug_info: WebSearchDebugInfo,
         web_search_message_logger: WebSearchMessageLogger,
-    ) -> WebSearchV1Executor | WebSearchV2Executor | WebSearchV3Executor:
-        # Initialize query elicitation service and get callbacks
+    ) -> WebSearchExecutor:
         elicitation_service = QueryElicitationService(
             chat_service=self._chat_service,
             display_name=self.display_name(),
             config=self.config.query_elicitation_config,
         )
 
-        # Build context objects
         services = ExecutorServiceContext(
             search_engine_service=self.search_engine_service,
             crawler_service=self.crawler_service,
@@ -334,46 +269,14 @@ class WebSearchTool(Tool[WebSearchConfig]):
             tool_progress_reporter=self._ff_tool_progress_reporter(),
         )
 
-        search_config = self.config.web_search_mode_config
-        if search_config.mode == WebSearchMode.V3:
-            assert isinstance(search_config, WebSearchV3Config)
-            assert isinstance(parameters, WebSearchV3ToolParameters)
-
-            return WebSearchV3Executor(
-                services=services,
-                config=config,
-                callbacks=callbacks,
-                tool_call=tool_call,
-                tool_parameters=parameters,
-                exposed_params_cls=self.exposed_params_cls,
-            )
-        if isinstance(parameters, WebSearchPlan):
-            assert search_config.mode == WebSearchMode.V2
-            return WebSearchV2Executor(
-                services=services,
-                config=config,
-                callbacks=callbacks,
-                tool_call=tool_call,
-                tool_parameters=parameters,
-                max_steps=search_config.max_steps,
-                exposed_params_cls=self.exposed_params_cls,
-            )
-        elif isinstance(parameters, WebSearchToolParameters):
-            assert search_config.mode == WebSearchMode.V1
-            return WebSearchV1Executor(
-                services=services,
-                config=config,
-                callbacks=callbacks,
-                tool_call=tool_call,
-                tool_parameters=parameters,
-                refine_query_system_prompt=search_config.refine_query_mode.system_prompt,
-                refine_query_language_model=search_config.refine_query_mode.language_model,
-                mode=search_config.refine_query_mode.mode,
-                max_queries=search_config.max_queries,
-                exposed_params_cls=self.exposed_params_cls,
-            )
-        else:
-            raise ValueError(f"Invalid parameters: {parameters}")
+        return self._mode_strategy.build_executor(
+            services=services,
+            config=config,
+            callbacks=callbacks,
+            tool_call=tool_call,
+            parameters=parameters,
+            exposed_params_cls=self.exposed_params_cls,
+        )
 
     def get_evaluation_checks_based_on_tool_response(
         self,
@@ -429,20 +332,12 @@ class WebSearchTool(Tool[WebSearchConfig]):
 
     def _build_display_name(
         self,
-        parameters: WebSearchPlan | WebSearchToolParameters | WebSearchV3ToolParameters,
+        parameters: WebSearchToolParametersInstance,
     ) -> str:
-        if not isinstance(parameters, WebSearchV3ToolParameters):
-            return self.display_name()
-
-        display_name = self.display_name()
-        # Remove "search" from the display name (case-insensitive, all occurrences).
-        display_name = re.sub(
-            r"\bsearch\b", "", display_name, flags=re.IGNORECASE
-        ).strip()
-
-        suffix = parameters.get_display_name_suffix()
-
-        return display_name + suffix
+        return self._mode_strategy.build_display_name(
+            base_display_name=self.display_name(),
+            parameters=parameters,
+        )
 
 
 ToolFactory.register_tool(WebSearchTool, WebSearchConfig)

unique_web_search-2026.30.0.dev2/src/unique_web_search/services/executors/modes.py

@@ -0,0 +1,164 @@
+"""Per-mode strategy objects for the WebSearch tool.
+
+Each WebSearch mode (V1/V2/V3) differs only in how it builds its LLM-facing
+surface and which executor runs it. A :class:`WebSearchModeStrategy` owns all of
+that per-mode behaviour in one place:
+
+- the tool-call parameter model (``query`` plus any engine-exposed knobs),
+- the tool description shown to the model,
+- the system-prompt text and citation/format-information text,
+- the executor construction, and
+- the runtime display name.
+
+``WebSearchTool`` resolves the strategy for the active mode via
+:func:`get_mode_strategy` and delegates to it, staying free of mode branching.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import cast
+
+from pydantic import BaseModel
+from unique_search_proxy_core.param_policy.exposed_params import ExposedParams
+from unique_toolkit.language_model import LanguageModelFunction
+
+from unique_web_search.services.executors.base_config import WebSearchMode
+from unique_web_search.services.executors.context import (
+    ExecutorCallbacks,
+    ExecutorConfiguration,
+    ExecutorServiceContext,
+)
+from unique_web_search.services.executors.v1.config import WebSearchV1Config
+from unique_web_search.services.executors.v1.executor import WebSearchV1Executor
+from unique_web_search.services.executors.v1.schema import WebSearchToolParameters
+from unique_web_search.services.executors.v2.config import WebSearchV2Config
+from unique_web_search.services.executors.v2.executor import WebSearchV2Executor
+from unique_web_search.services.executors.v2.schema import WebSearchPlan
+from unique_web_search.services.executors.v3.config import WebSearchV3Config
+from unique_web_search.services.executors.v3.executor import WebSearchV3Executor
+from unique_web_search.services.executors.v3.schema import WebSearchV3ToolParameters
+
+__all__ = [
+    "WebSearchExecutor",
+    "WebSearchModeConfig",
+    "WebSearchModeStrategy",
+    "WebSearchToolContext",
+    "WebSearchToolParametersInstance",
+    "WebSearchToolParametersType",
+    "get_mode_strategy",
+]
+
+WebSearchModeConfig = WebSearchV1Config | WebSearchV2Config | WebSearchV3Config
+
+WebSearchToolParametersType = (
+    type[WebSearchToolParameters]
+    | type[WebSearchPlan]
+    | type[WebSearchV3ToolParameters]
+)
+
+WebSearchToolParametersInstance = (
+    WebSearchToolParameters | WebSearchPlan | WebSearchV3ToolParameters
+)
+
+WebSearchExecutor = WebSearchV1Executor | WebSearchV2Executor | WebSearchV3Executor
+
+_STRATEGY_FACTORIES: (
+    dict[WebSearchMode, Callable[[WebSearchModeConfig], WebSearchModeStrategy]] | None
+) = None
+
+
+@dataclass(frozen=True)
+class WebSearchToolContext:
+    """Inputs the mode strategy needs to build the LLM-facing tool surface.
+
+    ``exposed_params_cls`` is resolved once by ``WebSearchTool`` at init so
+    strategies do not re-call ``exposed_params_model()``. The engine *mode*
+    (standard vs agent) is resolved lazily by the one strategy (V2) that needs
+    it, so V1/V3 never pay for a resolution they ignore.
+    """
+
+    search_engine_config: BaseModel
+    date_string: str
+    exposed_params_cls: type[ExposedParams] | None
+
+
+class WebSearchModeStrategy(ABC):
+    """Mode-specific behaviour for building and running the WebSearch tool."""
+
+    @abstractmethod
+    def build_tool_parameters(
+        self, ctx: WebSearchToolContext
+    ) -> WebSearchToolParametersType:
+        """Build the tool-call parameter model (``query`` plus exposed knobs)."""
+
+    @abstractmethod
+    def tool_description(self, ctx: WebSearchToolContext) -> str:
+        """Return the description the model sees when choosing this tool."""
+
+    @abstractmethod
+    def system_prompt(self, ctx: WebSearchToolContext) -> str:
+        """Return the tool's system-prompt instructions."""
+
+    @abstractmethod
+    def build_executor(
+        self,
+        *,
+        services: ExecutorServiceContext,
+        config: ExecutorConfiguration,
+        callbacks: ExecutorCallbacks,
+        tool_call: LanguageModelFunction,
+        parameters: WebSearchToolParametersInstance,
+        exposed_params_cls: type[ExposedParams] | None,
+    ) -> WebSearchExecutor:
+        """Construct the executor that runs a validated tool call."""
+
+    def format_information_for_system_prompt(self, *, default: str) -> str:
+        """Return citation/format instructions; falls back to the tool default."""
+        return default
+
+    def build_display_name(
+        self,
+        *,
+        base_display_name: str,
+        parameters: WebSearchToolParametersInstance,
+    ) -> str:
+        """Return the runtime display name for a tool call."""
+        return base_display_name
+
+
+def _strategy_factories() -> dict[
+    WebSearchMode, Callable[[WebSearchModeConfig], WebSearchModeStrategy]
+]:
+    global _STRATEGY_FACTORIES
+    if _STRATEGY_FACTORIES is None:
+        from unique_web_search.services.executors.v1.strategy import (
+            WebSearchV1Strategy,
+        )
+        from unique_web_search.services.executors.v2.strategy import (
+            WebSearchV2Strategy,
+        )
+        from unique_web_search.services.executors.v3.strategy import (
+            WebSearchV3Strategy,
+        )
+
+        _STRATEGY_FACTORIES = {
+            WebSearchMode.V1: lambda cfg: WebSearchV1Strategy(
+                cast(WebSearchV1Config, cfg),
+            ),
+            WebSearchMode.V2: lambda cfg: WebSearchV2Strategy(
+                cast(WebSearchV2Config, cfg),
+            ),
+            WebSearchMode.V3: lambda cfg: WebSearchV3Strategy(
+                cast(WebSearchV3Config, cfg),
+            ),
+        }
+    return _STRATEGY_FACTORIES
+
+
+def get_mode_strategy(mode_config: WebSearchModeConfig) -> WebSearchModeStrategy:
+    """Resolve the strategy for the configured WebSearch mode."""
+    factory = _strategy_factories()[mode_config.mode]
+    return factory(mode_config)

unique_web_search-2026.30.0.dev2/src/unique_web_search/services/executors/v1/strategy.py

@@ -0,0 +1,67 @@
+"""V1 WebSearch mode strategy: single-query search with optional refinement."""
+
+from __future__ import annotations
+
+from typing import cast
+
+from unique_search_proxy_core.param_policy.exposed_params import ExposedParams
+from unique_toolkit.language_model import LanguageModelFunction
+
+from unique_web_search.services.executors.context import (
+    ExecutorCallbacks,
+    ExecutorConfiguration,
+    ExecutorServiceContext,
+)
+from unique_web_search.services.executors.modes import (
+    WebSearchModeStrategy,
+    WebSearchToolContext,
+    WebSearchToolParametersInstance,
+    WebSearchToolParametersType,
+)
+from unique_web_search.services.executors.v1.config import WebSearchV1Config
+from unique_web_search.services.executors.v1.executor import WebSearchV1Executor
+from unique_web_search.services.executors.v1.schema import WebSearchToolParameters
+
+
+class WebSearchV1Strategy(WebSearchModeStrategy):
+    def __init__(self, mode_config: WebSearchV1Config) -> None:
+        self.mode_config = mode_config
+
+    def build_tool_parameters(
+        self, ctx: WebSearchToolContext
+    ) -> WebSearchToolParametersType:
+        """Build the V1 tool schema, grafting any admin-exposed engine knobs."""
+        return WebSearchToolParameters.with_exposed_params(ctx.exposed_params_cls)
+
+    def tool_description(self, ctx: WebSearchToolContext) -> str:
+        """Return the static V1 tool description from mode config."""
+        return self.mode_config.tool_description
+
+    def system_prompt(self, ctx: WebSearchToolContext) -> str:
+        """Return the static V1 system-prompt instructions from mode config."""
+        return self.mode_config.tool_description_for_system_prompt
+
+    def build_executor(
+        self,
+        *,
+        services: ExecutorServiceContext,
+        config: ExecutorConfiguration,
+        callbacks: ExecutorCallbacks,
+        tool_call: LanguageModelFunction,
+        parameters: WebSearchToolParametersInstance,
+        exposed_params_cls: type[ExposedParams] | None,
+    ) -> WebSearchV1Executor:
+        """Construct the V1 executor with refine-query settings from mode config."""
+        refine_query_mode = self.mode_config.refine_query_mode
+        return WebSearchV1Executor(
+            services=services,
+            config=config,
+            callbacks=callbacks,
+            tool_call=tool_call,
+            tool_parameters=cast(WebSearchToolParameters, parameters),
+            refine_query_system_prompt=refine_query_mode.system_prompt,
+            refine_query_language_model=refine_query_mode.language_model,
+            mode=refine_query_mode.mode,
+            max_queries=self.mode_config.max_queries,
+            exposed_params_cls=exposed_params_cls,
+        )

{unique_web_search-2026.30.0.dev1 → unique_web_search-2026.30.0.dev2}/src/unique_web_search/services/executors/v2/config.py

@@ -1,3 +1,4 @@
+from logging import getLogger
 from typing import Annotated, Literal
 
 from pydantic import Field, field_validator
@@ -15,6 +16,11 @@ from unique_web_search.services.executors.v2.prompts import (
 )
 from unique_web_search.services.helpers import clean_model_title_generator
 
+_LOGGER = getLogger(__name__)
+
+_LEGACY_MAX_STEPS_PLACEHOLDER = "$max_steps"
+_JINJA_MAX_STEPS_PLACEHOLDER = "{{ max_steps }}"
+
 
 class WebSearchV2Config(BaseWebSearchModeConfig[WebSearchMode.V2]):
     model_config = get_configuration_dict(
@@ -52,3 +58,25 @@ class WebSearchV2Config(BaseWebSearchModeConfig[WebSearchMode.V2]):
         if "v2" in v.lower():
             return "v2"
         raise ValueError(f"Invalid mode: {v}")
+
+    @field_validator("tool_description_for_system_prompt", mode="after")
+    @classmethod
+    def migrate_legacy_max_steps_placeholder(cls, value: str) -> str:
+        """Rewrite the pre-Jinja ``$max_steps`` token to ``{{ max_steps }}``.
+
+        V2 prompts persisted before the Jinja migration use the legacy
+        ``$max_steps`` placeholder, which Jinja would otherwise emit verbatim.
+        Normalising here keeps rendering free of backwards-compatibility logic.
+        """
+        if _LEGACY_MAX_STEPS_PLACEHOLDER not in value:
+            return value
+        _LOGGER.warning(
+            "V2 web-search prompt contains legacy '%s' placeholder; rewriting "
+            "to '%s'. Please update the stored configuration to use Jinja "
+            "syntax.",
+            _LEGACY_MAX_STEPS_PLACEHOLDER,
+            _JINJA_MAX_STEPS_PLACEHOLDER,
+        )
+        return value.replace(
+            _LEGACY_MAX_STEPS_PLACEHOLDER, _JINJA_MAX_STEPS_PLACEHOLDER
+        )

unique_web_search-2026.30.0.dev2/src/unique_web_search/services/executors/v2/strategy.py

@@ -0,0 +1,79 @@
+"""V2 WebSearch mode strategy: AI-planned multi-step research."""
+
+from __future__ import annotations
+
+from typing import cast
+
+from jinja2 import Template
+from unique_search_proxy_core.param_policy.exposed_params import ExposedParams
+from unique_toolkit.language_model import LanguageModelFunction
+
+from unique_web_search.services.executors.context import (
+    ExecutorCallbacks,
+    ExecutorConfiguration,
+    ExecutorServiceContext,
+)
+from unique_web_search.services.executors.modes import (
+    WebSearchModeStrategy,
+    WebSearchToolContext,
+    WebSearchToolParametersInstance,
+    WebSearchToolParametersType,
+)
+from unique_web_search.services.executors.v2.config import WebSearchV2Config
+from unique_web_search.services.executors.v2.executor import WebSearchV2Executor
+from unique_web_search.services.executors.v2.schema import WebSearchPlan
+from unique_web_search.services.search_engine import resolve_search_engine_mode
+
+
+class WebSearchV2Strategy(WebSearchModeStrategy):
+    def __init__(self, mode_config: WebSearchV2Config) -> None:
+        self.mode_config = mode_config
+
+    def build_tool_parameters(
+        self, ctx: WebSearchToolContext
+    ) -> WebSearchToolParametersType:
+        """Build the V2 plan schema shaped for the active search-engine mode."""
+        return WebSearchPlan.with_search_engine_mode(
+            resolve_search_engine_mode(ctx.search_engine_config)
+        )
+
+    def tool_description(self, ctx: WebSearchToolContext) -> str:
+        """Return the static V2 tool description from mode config."""
+        return self.mode_config.tool_description
+
+    def system_prompt(self, ctx: WebSearchToolContext) -> str:
+        """Render the V2 Jinja system prompt with plan examples and schema hint."""
+        engine_mode = resolve_search_engine_mode(ctx.search_engine_config)
+        return Template(self.mode_config.tool_description_for_system_prompt).render(
+            max_steps=self.mode_config.max_steps,
+            date_string=ctx.date_string,
+            search_engine_mode=engine_mode.value,
+            tool_parameters_schema=WebSearchPlan.schema_hint(engine_mode),
+            example_simple=WebSearchPlan.build_example_simple(
+                engine_mode
+            ).model_dump_json(indent=2),
+            example_complex=WebSearchPlan.build_example_complex(
+                engine_mode
+            ).model_dump_json(indent=2),
+        )
+
+    def build_executor(
+        self,
+        *,
+        services: ExecutorServiceContext,
+        config: ExecutorConfiguration,
+        callbacks: ExecutorCallbacks,
+        tool_call: LanguageModelFunction,
+        parameters: WebSearchToolParametersInstance,
+        exposed_params_cls: type[ExposedParams] | None,
+    ) -> WebSearchV2Executor:
+        """Construct the V2 executor with the configured max-steps budget."""
+        return WebSearchV2Executor(
+            services=services,
+            config=config,
+            callbacks=callbacks,
+            tool_call=tool_call,
+            tool_parameters=cast(WebSearchPlan, parameters),
+            max_steps=self.mode_config.max_steps,
+            exposed_params_cls=exposed_params_cls,
+        )

{unique_web_search-2026.30.0.dev1 → unique_web_search-2026.30.0.dev2}/src/unique_web_search/services/executors/v3/schema.py

@@ -176,11 +176,3 @@ class WebSearchV3ToolParameters(ExposedParams):
             lines.append(f'  - For `"{cmd.value}"`: `{_inline_json(payload_model)}`.')
 
         return "\n".join(lines)
-
-    def get_display_name_suffix(self) -> str:
-        if self.command == Command.SEARCH:
-            return " - Searching"
-        elif self.command == Command.FETCH_URLS:
-            return " - Reading Pages"
-        else:
-            raise ValueError(f"Invalid command: {self.command}")