unique_web_search 2026.30.0.dev0__tar.gz → 2026.30.0.dev2__tar.gz

{unique_web_search-2026.30.0.dev0 → 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.dev0
+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.dev0,<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
@@ -27,8 +27,8 @@ Requires-Dist: httpx>=0.28.1
 Requires-Dist: certifi>=2025.11.12
 Requires-Dist: jinja2>=3.1.6
 Requires-Dist: playwright>=1.58.0
-Requires-Dist: unique-search-proxy-core>=2026.30.0.dev0,<2026.30.0rc0
-Requires-Dist: unique-search-proxy-sdk>=2026.30.0.dev0,<2026.30.0rc0
+Requires-Dist: unique-search-proxy-core>=2026.30.0.dev2,<2026.30.0rc0
+Requires-Dist: unique-search-proxy-sdk>=2026.30.0.dev2,<2026.30.0rc0
 Requires-Python: >=3.12, <4.0
 Description-Content-Type: text/markdown
 

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

@@ -1,6 +1,6 @@
 [project]
 name = "unique_web_search"
-version = "2026.30.0.dev0"
+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.dev0,<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",
@@ -33,8 +33,8 @@ dependencies = [
     "certifi>=2025.11.12",
     "jinja2>=3.1.6",
     "playwright>=1.58.0",
-    "unique-search-proxy-core>=2026.30.0.dev0,<2026.30.0rc0",
-    "unique-search-proxy-sdk>=2026.30.0.dev0,<2026.30.0rc0",
+    "unique-search-proxy-core>=2026.30.0.dev2,<2026.30.0rc0",
+    "unique-search-proxy-sdk>=2026.30.0.dev2,<2026.30.0rc0",
 ]
 
 [build-system]

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

@@ -1,10 +1,10 @@
 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
 from unique_toolkit._common.chunk_relevancy_sorter.service import ChunkRelevancySorter
 from unique_toolkit.agentic.evaluation.schemas import EvaluationMetricName
 from unique_toolkit.agentic.feature_flags.feature_flags import (
@@ -31,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,
@@ -97,6 +90,8 @@ 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]:
 
@@ -111,83 +106,37 @@ class WebSearchTool(Tool[WebSearchConfig]):
 
         self.content_reducer = content_reducer
 
-    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 _resolve_exposed_params_cls(self) -> type[ExposedParams] | None:
+        """Resolve the exposed-params model from the search-engine config, if any."""
+        cfg = self.config.search_engine_config
+        if isinstance(cfg, BaseSearchEngineConfig):
+            return cfg.exposed_params_model()
+        return None
+
+    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:
-        if self.config.web_search_mode_config.mode == WebSearchMode.V1:
-            self.tool_parameter_calls = WebSearchToolParameters.from_tool_parameter_query_description(
-                self.config.web_search_mode_config.tool_parameters_description.query_description,
-                self.config.web_search_mode_config.tool_parameters_description.date_restrict_description,
-            )
-        else:
-            if self.config.web_search_mode_config.mode == WebSearchMode.V3:
-                self.tool_parameter_calls = WebSearchV3ToolParameters
-            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(),
-            )
-
+        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
@@ -202,7 +151,7 @@ class WebSearchTool(Tool[WebSearchConfig]):
 
         screening_service = await self._get_argument_screening_service_if_ff_enabled()
 
-        parameters_dump = parameters.model_dump()
+        parameters_dump = parameters.model_dump(by_alias=True)
         debug_info = WebSearchDebugInfo(parameters=parameters_dump)
 
         web_search_message_logger = WebSearchMessageLogger(
@@ -289,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,
@@ -322,43 +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,
-            )
-        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,
-            )
-        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,
-            )
-        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,
@@ -414,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.dev0 → unique_web_search-2026.30.0.dev2}/src/unique_web_search/services/executors/base_executor.py

@@ -4,6 +4,7 @@ from time import time
 from typing import Generic, TypeVar
 
 from pydantic import BaseModel
+from unique_search_proxy_core.param_policy.exposed_params import ExposedParams
 from unique_toolkit.agentic.tools.tool_progress_reporter import (
     ProgressState,
 )
@@ -39,6 +40,7 @@ class BaseWebSearchExecutor(ABC, Generic[T]):
         callbacks: ExecutorCallbacks,
         tool_call: LanguageModelFunction,
         tool_parameters: T,
+        exposed_params_cls: type[ExposedParams] | None = None,
     ):
         # Extract from service context
         self.search_service = services.search_engine_service
@@ -61,6 +63,7 @@ class BaseWebSearchExecutor(ABC, Generic[T]):
         # Store tool parameters
         self.tool_call = tool_call
         self.tool_parameters = tool_parameters
+        self.exposed_params_cls = exposed_params_cls
 
         # Initialize notification state
         self._notify_name = ""
@@ -78,6 +81,17 @@ class BaseWebSearchExecutor(ABC, Generic[T]):
 
         self.notify_callback = notify_callback
 
+    def _extract_search_params(self, source: BaseModel) -> ExposedParams | None:
+        """Validate ``source`` against the exposed-params class, dropping tool-only fields.
+
+        Returns ``None`` when no knobs are exposed for this deployment. Otherwise
+        re-validates the source dump through ``exposed_params_cls``
+        (``extra="ignore"``) so only admin-exposed engine knobs remain.
+        """
+        if self.exposed_params_cls is None:
+            return None
+        return self.exposed_params_cls.model_validate(source.model_dump(by_alias=True))
+
     @property
     def notify_name(self):
         return self._notify_name

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.dev0 → unique_web_search-2026.30.0.dev2}/src/unique_web_search/services/executors/v1/__init__.py

@@ -1,17 +1,15 @@
 from unique_web_search.services.executors.v1.config import (
     QueryRefinementConfig,
     RefineQueryMode,
-    WebSearchToolParametersDescriptionConfig,
     WebSearchV1Config,
 )
-from unique_web_search.services.executors.v1.executor import (
-    WebSearchV1Executor,
-)
+from unique_web_search.services.executors.v1.executor import WebSearchV1Executor
+from unique_web_search.services.executors.v1.schema import WebSearchToolParameters
 
 __all__ = [
     "QueryRefinementConfig",
     "RefineQueryMode",
-    "WebSearchToolParametersDescriptionConfig",
     "WebSearchV1Config",
     "WebSearchV1Executor",
+    "WebSearchToolParameters",
 ]

{unique_web_search-2026.30.0.dev0 → unique_web_search-2026.30.0.dev2}/src/unique_web_search/services/executors/v1/config.py

@@ -15,7 +15,6 @@ from unique_web_search.services.executors.v1.prompts import (
     DEFAULT_TOOL_DESCRIPTION,
     DEFAULT_TOOL_DESCRIPTION_FOR_SYSTEM_PROMPT,
     REFINE_QUERY_SYSTEM_PROMPT,
-    RESTRICT_DATE_DESCRIPTION,
 )
 from unique_web_search.settings import env_settings
 
@@ -26,34 +25,6 @@ class RefineQueryMode(StrEnum):
     DEACTIVATED = "Deactivated"
 
 
-_DEFAULT_QUERY_DESCRIPTION = "The search query to issue to the web."
-
-
-class WebSearchToolParametersDescriptionConfig(BaseModel):
-    model_config = get_configuration_dict()
-
-    query_description: Annotated[
-        str,
-        RJSFMetaTag.StringWidget.textarea(
-            rows=len(_DEFAULT_QUERY_DESCRIPTION.split("\n"))
-        ),
-    ] = Field(
-        default=_DEFAULT_QUERY_DESCRIPTION,
-        title="Query Parameter Description",
-        description="Advanced: Description of the search query parameter shown to the AI model.",
-    )
-    date_restrict_description: Annotated[
-        str,
-        RJSFMetaTag.StringWidget.textarea(
-            rows=len(RESTRICT_DATE_DESCRIPTION.split("\n"))
-        ),
-    ] = Field(
-        default=RESTRICT_DATE_DESCRIPTION,
-        title="Date Filter Description",
-        description="Advanced: Description of the date restriction parameter shown to the AI model.",
-    )
-
-
 class QueryRefinementConfig(BaseModel):
     model_config = get_configuration_dict()
 
@@ -101,12 +72,6 @@ class WebSearchV1Config(BaseWebSearchModeConfig[WebSearchMode.V1]):
         description="Maximum number of separate searches to run per user request. Only applies when Query Refinement is set to Advanced.",
     )
 
-    tool_parameters_description: WebSearchToolParametersDescriptionConfig = Field(
-        default_factory=WebSearchToolParametersDescriptionConfig,
-        title="Search Parameter Descriptions",
-        description="Advanced: Descriptions of each search parameter, shown to the AI model.",
-    )
-
     tool_description: Annotated[
         str,
         RJSFMetaTag.StringWidget.textarea(