unique_web_search 2026.20.0.dev7__tar.gz → 2026.20.0.dev9__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-web-search
-Version: 2026.20.0.dev7
+Version: 2026.20.0.dev9
 Summary: 
 Author: Andreas Hauri, Gustav Hartz, Rami Azouz
 Author-email: Andreas Hauri <andreas@unique.ch>, Gustav Hartz <gustav.hartz.ext@unique.ch>, Rami Azouz <rami.ext@unique.ch>
@@ -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.20.0.dev11
+Requires-Dist: unique-toolkit[monitoring]>=2026.20.0.dev14,<2026.20.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.20.0.dev7 → unique_web_search-2026.20.0.dev9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_web_search"
-version = "2026.20.0.dev7"
+version = "2026.20.0.dev9"
 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.20.0.dev11",
+    "unique-toolkit[monitoring]>=2026.20.0.dev14,<2026.20.0rc0",
     "azure-core>=1.36.0,<2",
     "google-cloud-aiplatform>=1.128.0,<2",
     "google-auth>=2.43.0,<3",

{unique_web_search-2026.20.0.dev7 → unique_web_search-2026.20.0.dev9}/src/unique_web_search/config.py

@@ -28,13 +28,12 @@ from unique_web_search.services.crawlers import (
     get_crawler_config_types_from_names,
     get_default_crawler_config,
 )
-from unique_web_search.services.executors.configs import (
+from unique_web_search.services.executors import (
     RefineQueryMode,
     WebSearchMode,
     WebSearchModeConfig,
     WebSearchV1Config,
     WebSearchV2Config,
-    WebSearchV3Config,
     get_default_web_search_mode_config,
 )
 from unique_web_search.services.query_elicitation import QueryElicitationConfig
@@ -173,11 +172,6 @@ class WebSearchConfig(BaseToolConfig):
         title="Search Mode V2 Settings",
         description="Settings for the advanced AI-planned search mode (V2), including step limits and tool behavior.",
     )
-    web_search_mode_config_v3: WebSearchV3Config = Field(
-        default_factory=WebSearchV3Config,
-        title="Search Mode V3 Settings (Experimental)",
-        description="Settings for V3: pre-filter search results by relevance (snippet judge) before fetching full pages.",
-    )
 
     # Todo [UN-17655] RJSF Tags don't function properly when using union + dscriminator
     search_engine_config: ActivatedSearchEngine = Field(  # type: ignore (This type is computed at runtime so pyright is not able to infer it)
@@ -259,8 +253,6 @@ class WebSearchConfig(BaseToolConfig):
     def web_search_mode_config(self) -> WebSearchModeConfig:
         if self.web_search_active_mode == WebSearchMode.V1:
             return self.web_search_mode_config_v1
-        if self.web_search_active_mode == WebSearchMode.V3:
-            return self.web_search_mode_config_v3
         return self.web_search_mode_config_v2
 
     @field_validator("web_search_active_mode", mode="before")

unique_web_search-2026.20.0.dev9/src/unique_web_search/schema.py

@@ -0,0 +1,68 @@
+"""Shared web-search runtime models and re-exports for tool parameters.
+
+Tool-call Pydantic models live under ``services/executors/vN/schema.py``;
+symbols below are re-exported for backward-compatible imports
+(e.g. ``from unique_web_search.schema import WebSearchPlan``).
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+from unidecode import unidecode
+from unique_toolkit.content.schemas import ContentChunk
+
+
+class StepDebugInfo(BaseModel):
+    step_name: str
+    execution_time: float
+    config: str | dict
+    extra: dict = Field(default_factory=dict)
+
+
+class WebPageChunk(BaseModel):
+    url: str
+    display_link: str
+    title: str
+    snippet: str
+    content: str
+    order: str
+
+    def to_content_chunk(self) -> ContentChunk:
+        """Convert WebPageChunk to ContentChunk format."""
+
+        # Convert to ascii
+        title = unidecode(self.title)
+        name = f'{self.display_link}: "{title}"'
+
+        return ContentChunk(
+            id=name,
+            text=self.content,
+            order=int(self.order),
+            start_page=None,
+            end_page=None,
+            key=name,
+            chunk_id=self.order,
+            url=self.url,
+            title=name,
+        )
+
+
+class WebSearchDebugInfo(BaseModel):
+    parameters: dict
+    steps: list[StepDebugInfo] = []
+    web_page_chunks: list[WebPageChunk] = []
+    execution_time: float | None = None
+    num_chunks_in_final_prompts: int = 0
+
+    def model_dump(self, *, with_debug_details: bool = True, **kwargs):
+        """
+        Dump the model, dropping `additional_info` in steps when debug=False.
+        """
+        exclude = kwargs.pop("exclude", {})
+        if not with_debug_details:
+            # Build an exclude structure that applies to all steps
+            exclude = {
+                "steps": {i: {"extra"} for i in range(len(self.steps))},
+                "web_page_chunks": True,
+            } | exclude
+        return super().model_dump(exclude=exclude, **kwargs)

{unique_web_search-2026.20.0.dev7 → unique_web_search-2026.20.0.dev9}/src/unique_web_search/service.py

@@ -2,7 +2,7 @@ import logging
 from datetime import datetime
 from time import time
 
-import jinja2
+from jinja2 import Template
 from typing_extensions import override
 from unique_toolkit._common.chunk_relevancy_sorter.service import ChunkRelevancySorter
 from unique_toolkit.agentic.evaluation.schemas import EvaluationMetricName
@@ -24,33 +24,32 @@ from unique_toolkit.monitoring import metric_scope
 
 from unique_web_search.config import WebSearchConfig
 from unique_web_search.metrics import tool_duration, tool_empty_results, tool_errors
-from unique_web_search.schema import (
-    WebSearchDebugInfo,
-    WebSearchPlan,
-    WebSearchToolParameters,
-)
+from unique_web_search.schema import WebSearchDebugInfo
 from unique_web_search.services.argument_screening import (
     ArgumentScreeningService,
 )
 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,
-    WebSearchV3Executor,
-)
-from unique_web_search.services.executors.configs import (
-    WebSearchMode,
-    WebSearchV3Config,
 )
 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.message_log import WebSearchMessageLogger
 from unique_web_search.services.query_elicitation import QueryElicitationService
-from unique_web_search.services.search_engine import get_search_engine_service
+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,
@@ -104,12 +103,18 @@ class WebSearchTool(Tool[WebSearchConfig]):
                 self.config.language_model_max_input_tokens,
                 self.config.percentage_of_input_tokens_for_sources,
                 self.config.limit_token_sources,
-                language_model,
+                language_model,  # type: ignore
                 self.chat_history_token_length,
             )
 
         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.search_engine_name, override=override)
+
     @override
     def tool_description(self) -> LanguageModelToolDescription:
         if self.config.web_search_mode_config.mode == WebSearchMode.V1:
@@ -118,7 +123,10 @@ class WebSearchTool(Tool[WebSearchConfig]):
                 self.config.web_search_mode_config.tool_parameters_description.date_restrict_description,
             )
         else:
-            self.tool_parameter_calls = WebSearchPlan
+            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
 
@@ -129,23 +137,39 @@ class WebSearchTool(Tool[WebSearchConfig]):
         )
 
     def tool_description_for_system_prompt(self) -> str:
-        if self.config.web_search_mode_config.mode == WebSearchMode.V3:
-            return jinja2.Template(
-                self.config.web_search_mode_config.tool_description_for_system_prompt
-            ).render(
-                max_steps=self.config.web_search_mode_config.max_steps,
-                date_string=datetime.now().strftime("%A %B %d, %Y"),
+        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
+
+        # 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."
             )
-        if self.config.web_search_mode_config.mode == WebSearchMode.V2:
-            return self.config.web_search_mode_config.tool_description_for_system_prompt.replace(
-                "$max_steps",
-                str(self.config.web_search_mode_config.max_steps),
-            )
-        return self.config.web_search_mode_config.tool_description_for_system_prompt
+            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),
+        )
 
     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
 
     def evaluation_check_list(self) -> list[EvaluationMetricName]:
@@ -161,7 +185,8 @@ class WebSearchTool(Tool[WebSearchConfig]):
 
         screening_service = await self._get_argument_screening_service_if_ff_enabled()
 
-        debug_info = WebSearchDebugInfo(parameters=parameters.model_dump())
+        parameters_dump = parameters.model_dump()
+        debug_info = WebSearchDebugInfo(parameters=parameters_dump)
 
         web_search_message_logger = WebSearchMessageLogger(
             message_step_logger=self._message_step_logger,
@@ -176,7 +201,10 @@ class WebSearchTool(Tool[WebSearchConfig]):
 
         try:
             if screening_service is not None:
-                screening_result = await screening_service(parameters.model_dump())
+                screening_result = await screening_service(
+                    parameters_dump, web_search_message_logger
+                )
+
                 debug_info.steps.append(
                     screening_service.build_step_debug_info_from_result(
                         screening_result
@@ -247,7 +275,7 @@ class WebSearchTool(Tool[WebSearchConfig]):
         parameters: WebSearchPlan | WebSearchToolParameters,
         debug_info: WebSearchDebugInfo,
         web_search_message_logger: WebSearchMessageLogger,
-    ) -> WebSearchV1Executor | WebSearchV2Executor | WebSearchV3Executor:
+    ) -> WebSearchV1Executor | WebSearchV2Executor:
         # Initialize query elicitation service and get callbacks
         elicitation_service = QueryElicitationService(
             chat_service=self._chat_service,
@@ -278,41 +306,29 @@ class WebSearchTool(Tool[WebSearchConfig]):
             tool_progress_reporter=self._ff_tool_progress_reporter(),
         )
 
+        search_config = self.config.web_search_mode_config
+
         if isinstance(parameters, WebSearchPlan):
-            mode = self.config.web_search_mode_config.mode
-            if mode == WebSearchMode.V3:
-                v3_config = self.config.web_search_mode_config
-                assert isinstance(v3_config, WebSearchV3Config)
-
-                return WebSearchV3Executor(
-                    services=services,
-                    config=config,
-                    callbacks=callbacks,
-                    tool_call=tool_call,
-                    tool_parameters=parameters,
-                    max_steps=v3_config.max_steps,
-                    snippet_judge_config=v3_config.snippet_judge_config,
-                )
-            assert mode == WebSearchMode.V2
+            assert search_config.mode == WebSearchMode.V2
             return WebSearchV2Executor(
                 services=services,
                 config=config,
                 callbacks=callbacks,
                 tool_call=tool_call,
                 tool_parameters=parameters,
-                max_steps=self.config.web_search_mode_config.max_steps,
+                max_steps=search_config.max_steps,
             )
         elif isinstance(parameters, WebSearchToolParameters):
-            assert self.config.web_search_mode_config.mode == WebSearchMode.V1
+            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=self.config.web_search_mode_config.refine_query_mode.system_prompt,
-                mode=self.config.web_search_mode_config.refine_query_mode.mode,
-                max_queries=self.config.web_search_mode_config.max_queries,
+                refine_query_system_prompt=search_config.refine_query_mode.system_prompt,
+                mode=search_config.refine_query_mode.mode,
+                max_queries=search_config.max_queries,
             )
         else:
             raise ValueError(f"Invalid parameters: {parameters}")

{unique_web_search-2026.20.0.dev7 → unique_web_search-2026.20.0.dev9}/src/unique_web_search/services/argument_screening/service.py

@@ -14,7 +14,6 @@ from pydantic import Field, PrivateAttr
 from unique_toolkit._common.utils.structured_output.schema import StructuredOutputModel
 from unique_toolkit._common.validators import LMI
 from unique_toolkit.language_model import LanguageModelService
-from unique_toolkit.language_model.builder import MessagesBuilder
 
 from unique_web_search.schema import StepDebugInfo
 from unique_web_search.services.argument_screening.config import (
@@ -23,6 +22,11 @@ from unique_web_search.services.argument_screening.config import (
 from unique_web_search.services.argument_screening.exceptions import (
     ArgumentScreeningUnparseableResponseException,
 )
+from unique_web_search.services.message_log import WebSearchMessageLogger
+from unique_web_search.services.structured_llm import (
+    StructuredLlmUnparseableResponseError,
+    complete_structured_llm,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -55,7 +59,9 @@ class ArgumentScreeningService:
         self._language_model = language_model
         self._config = config
 
-    async def __call__(self, arguments: dict) -> ArgumentScreeningResult:
+    async def __call__(
+        self, arguments: dict, message_log_callback: WebSearchMessageLogger
+    ) -> ArgumentScreeningResult:
         """Screen tool call arguments; raises on rejection.
 
         Args:
@@ -69,9 +75,17 @@ class ArgumentScreeningService:
                 go=True, reason="Argument screening disabled"
             )
 
+        await message_log_callback.log_progress("PII Detection running...")
+
         start_time = time()
         result = await self._screen_arguments(arguments)
         result._execution_time = time() - start_time
+
+        if not result.go:
+            await message_log_callback.log_progress(f"PII Detection: {result.reason}")
+        else:
+            await message_log_callback.log_progress("PII Detection completed!")
+
         return result
 
     async def _screen_arguments(self, arguments: dict) -> ArgumentScreeningResult:
@@ -83,27 +97,19 @@ class ArgumentScreeningService:
             guidelines=self._config.guidelines,
         )
 
-        messages = (
-            MessagesBuilder()
-            .system_message_append(self._config.system_prompt)
-            .user_message_append(user_prompt)
-            .build()
-        )
-
-        response = await self._language_model_service.complete_async(
-            messages,
-            model_name=self._language_model.name,
-            structured_output_model=ArgumentScreeningResult,
-            structured_output_enforce_schema=True,
-        )
-
-        parsed = response.choices[0].message.parsed
-        if parsed is None:
+        try:
+            result = await complete_structured_llm(
+                self._language_model_service,
+                self._language_model,
+                system_message=self._config.system_prompt,
+                user_message=user_prompt,
+                response_model=ArgumentScreeningResult,
+            )
+        except StructuredLlmUnparseableResponseError as e:
             raise ArgumentScreeningUnparseableResponseException(
                 reason="Argument screening agent failed to return a valid response"
-            )
+            ) from e
 
-        result = ArgumentScreeningResult.model_validate(parsed)
         _LOGGER.info(f"Argument screening verdict: go={result.go}")
         return result
 

unique_web_search-2026.20.0.dev9/src/unique_web_search/services/executors/__init__.py

@@ -0,0 +1,48 @@
+from logging import getLogger
+
+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 (
+    RefineQueryMode,
+    WebSearchV1Config,
+)
+from unique_web_search.services.executors.v1.executor import (
+    WebSearchV1Executor,
+)
+from unique_web_search.services.executors.v2.config import WebSearchV2Config
+from unique_web_search.services.executors.v2.executor import (
+    WebSearchV2Executor,
+)
+from unique_web_search.settings import env_settings
+
+_LOGGER = getLogger(__name__)
+WebSearchModeConfig = WebSearchV1Config | WebSearchV2Config
+
+
+def get_default_web_search_mode_config() -> WebSearchMode:
+    match env_settings.web_search_mode:
+        case "v1":
+            return WebSearchMode.V1
+        case "v2":
+            return WebSearchMode.V2
+        case _:
+            raise ValueError(f"Invalid web search mode: {env_settings.web_search_mode}")
+
+
+__all__ = [
+    "WebSearchModeConfig",
+    "WebSearchV1Config",
+    "WebSearchV2Config",
+    "get_default_web_search_mode_config",
+    "WebSearchMode",
+    "RefineQueryMode",
+    "WebSearchV1Executor",
+    "WebSearchV2Executor",
+    "ExecutorServiceContext",
+    "ExecutorConfiguration",
+    "ExecutorCallbacks",
+]

unique_web_search-2026.20.0.dev7/src/unique_web_search/services/executors/configs/base.py → unique_web_search-2026.20.0.dev9/src/unique_web_search/services/executors/base_config.py

@@ -12,7 +12,6 @@ from unique_web_search.services.helpers import (
 class WebSearchMode(StrEnum):
     V1 = "v1"
     V2 = "v2"
-    V3 = "v3"
 
     @staticmethod
     def get_enum_names() -> list[str]:
@@ -23,7 +22,6 @@ class WebSearchMode(StrEnum):
         return [
             "V1 — Simple keyword searches with optional query refinement",
             "V2 — AI-planned multi-step research (search and read pages in sequence)",
-            "V3 (Experimental) — Like V2, but pre-filters results by relevance (snippet judge) before fetching full pages",
         ]
 
     @classmethod

{unique_web_search-2026.20.0.dev7 → unique_web_search-2026.20.0.dev9}/src/unique_web_search/services/executors/base_executor.py

@@ -1,7 +1,9 @@
 import logging
 from abc import ABC, abstractmethod
 from time import time
+from typing import Generic, TypeVar
 
+from pydantic import BaseModel
 from unique_toolkit.agentic.feature_flags import feature_flags
 from unique_toolkit.agentic.tools.tool_progress_reporter import (
     ProgressState,
@@ -14,8 +16,6 @@ from unique_web_search.metrics import llm_duration, llm_errors
 from unique_web_search.schema import (
     StepDebugInfo,
     WebPageChunk,
-    WebSearchPlan,
-    WebSearchToolParameters,
 )
 from unique_web_search.services.executors.context import (
     ExecutorCallbacks,
@@ -29,14 +29,17 @@ from unique_web_search.services.search_engine.schema import (
 _LOGGER = logging.getLogger(__name__)
 
 
-class BaseWebSearchExecutor(ABC):
+T = TypeVar("T", bound=BaseModel)
+
+
+class BaseWebSearchExecutor(ABC, Generic[T]):
     def __init__(
         self,
         services: ExecutorServiceContext,
         config: ExecutorConfiguration,
         callbacks: ExecutorCallbacks,
         tool_call: LanguageModelFunction,
-        tool_parameters: WebSearchPlan | WebSearchToolParameters,
+        tool_parameters: T,
     ):
         # Extract from service context
         self.search_service = services.search_engine_service

unique_web_search-2026.20.0.dev9/src/unique_web_search/services/executors/v1/__init__.py

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

unique_web_search-2026.20.0.dev7/src/unique_web_search/services/executors/configs/v1_config.py → unique_web_search-2026.20.0.dev9/src/unique_web_search/services/executors/v1/config.py

@@ -6,11 +6,11 @@ from pydantic.json_schema import SkipJsonSchema
 from unique_toolkit._common.pydantic.rjsf_tags import RJSFMetaTag
 from unique_toolkit.agentic.tools.config import get_configuration_dict
 
-from unique_web_search.services.executors.configs.base import (
+from unique_web_search.services.executors.base_config import (
     BaseWebSearchModeConfig,
     WebSearchMode,
 )
-from unique_web_search.services.executors.configs.prompts import (
+from unique_web_search.services.executors.v1.prompts import (
     DEFAULT_TOOL_DESCRIPTION,
     DEFAULT_TOOL_DESCRIPTION_FOR_SYSTEM_PROMPT,
     REFINE_QUERY_SYSTEM_PROMPT,
@@ -97,22 +97,20 @@ class WebSearchV1Config(BaseWebSearchModeConfig[WebSearchMode.V1]):
     tool_description: Annotated[
         str,
         RJSFMetaTag.StringWidget.textarea(
-            rows=int(len(DEFAULT_TOOL_DESCRIPTION["v1"].split("\n")))
+            rows=int(len(DEFAULT_TOOL_DESCRIPTION.split("\n")))
         ),
     ] = Field(
-        default=DEFAULT_TOOL_DESCRIPTION["v1"],
+        default=DEFAULT_TOOL_DESCRIPTION,
         title="Tool Description",
         description="Advanced: Description that helps the AI model decide when to use web search.",
     )
     tool_description_for_system_prompt: Annotated[
         str,
         RJSFMetaTag.StringWidget.textarea(
-            rows=int(
-                len(DEFAULT_TOOL_DESCRIPTION_FOR_SYSTEM_PROMPT["v1"].split("\n")) / 2
-            )
+            rows=int(len(DEFAULT_TOOL_DESCRIPTION_FOR_SYSTEM_PROMPT.split("\n")) / 2)
         ),
     ] = Field(
-        default=DEFAULT_TOOL_DESCRIPTION_FOR_SYSTEM_PROMPT["v1"],
+        default=DEFAULT_TOOL_DESCRIPTION_FOR_SYSTEM_PROMPT,
         title="Tool Description For System Prompt",
         description="Advanced: Detailed instructions for the AI model on how and when to use web search.",
     )

unique_web_search-2026.20.0.dev7/src/unique_web_search/services/executors/web_search_v1_executor.py → unique_web_search-2026.20.0.dev9/src/unique_web_search/services/executors/v1/executor.py

@@ -20,16 +20,17 @@ from unique_web_search.metrics import (
     search_errors,
     search_total,
 )
-from unique_web_search.schema import StepDebugInfo, WebSearchToolParameters
+from unique_web_search.schema import StepDebugInfo
 from unique_web_search.services.executors.base_executor import (
     BaseWebSearchExecutor,
 )
-from unique_web_search.services.executors.configs import RefineQueryMode
 from unique_web_search.services.executors.context import (
     ExecutorCallbacks,
     ExecutorConfiguration,
     ExecutorServiceContext,
 )
+from unique_web_search.services.executors.v1.config import RefineQueryMode
+from unique_web_search.services.executors.v1.schema import WebSearchToolParameters
 from unique_web_search.services.search_engine.schema import (
     WebSearchResult,
 )
@@ -99,7 +100,6 @@ async def query_generation_agent(
     match mode:
         case RefineQueryMode.DEACTIVATED:
             _LOGGER.info("Query Refinement deactivated")
-            ### Early return for deactivated mode
             return RefinedQuery(
                 objective=query,
                 refined_query=query,
@@ -134,7 +134,7 @@ async def query_generation_agent(
     return structured_output_model.model_validate(parsed_response)
 
 
-class WebSearchV1Executor(BaseWebSearchExecutor):
+class WebSearchV1Executor(BaseWebSearchExecutor[WebSearchToolParameters]):
     """Executes research plans step by step."""
 
     @override
@@ -157,7 +157,6 @@ class WebSearchV1Executor(BaseWebSearchExecutor):
             tool_parameters=tool_parameters,
         )
         self.mode = mode
-        self.tool_parameters = tool_parameters
         self.refine_query_system_prompt = refine_query_system_prompt
         self.max_queries = max_queries
 
@@ -177,7 +176,6 @@ class WebSearchV1Executor(BaseWebSearchExecutor):
         elicitated_queries = await self._ff_elicitate_queries(refined_queries)
 
         web_search_results = []
-        # Pass query strings only - callback handles creating WebSearchLogEntry objects
 
         queries_wo_results = [
             query_params_to_human_string(refined_query, date_restrict)