unique-web-search 1.9.1__py3-none-any.whl → 1.10.0__py3-none-any.whl

unique_web_search/services/executors/web_search_v1_executor.py

@@ -1,38 +1,30 @@
 import logging
 from time import time
-from typing import Callable, Literal, Optional, overload, override
+from typing import Literal, overload, override
 
 from pydantic import Field
 from unique_toolkit import LanguageModelService
-from unique_toolkit._common.chunk_relevancy_sorter.config import (
-    ChunkRelevancySortConfig,
-)
-from unique_toolkit._common.chunk_relevancy_sorter.service import ChunkRelevancySorter
 from unique_toolkit._common.utils.structured_output.schema import StructuredOutputModel
 from unique_toolkit._common.validators import LMI
-from unique_toolkit.agentic.tools.tool_progress_reporter import (
-    ToolProgressReporter,
-)
 from unique_toolkit.content import ContentChunk
 from unique_toolkit.language_model import LanguageModelFunction
 from unique_toolkit.language_model.builder import MessagesBuilder
 
-from unique_web_search.schema import StepType, WebSearchToolParameters
-from unique_web_search.services.content_processing import ContentProcessor, WebPageChunk
-from unique_web_search.services.crawlers import CrawlerTypes
+from unique_web_search.schema import WebSearchToolParameters
 from unique_web_search.services.executors.base_executor import (
     BaseWebSearchExecutor,
-    MessageLogCallback,
-    WebSearchLogEntry,
 )
 from unique_web_search.services.executors.configs import RefineQueryMode
-from unique_web_search.services.search_engine import SearchEngineTypes
+from unique_web_search.services.executors.context import (
+    ExecutorCallbacks,
+    ExecutorConfiguration,
+    ExecutorServiceContext,
+)
 from unique_web_search.services.search_engine.schema import (
     WebSearchResult,
 )
 from unique_web_search.utils import (
     StepDebugInfo,
-    WebSearchDebugInfo,
     query_params_to_human_string,
 )
 
@@ -139,105 +131,74 @@ class WebSearchV1Executor(BaseWebSearchExecutor):
     @override
     def __init__(
         self,
-        company_id: str,
-        language_model_service: LanguageModelService,
-        language_model: LMI,
-        search_service: SearchEngineTypes,
-        crawler_service: CrawlerTypes,
-        content_processor: ContentProcessor,
-        message_log_callback: MessageLogCallback,
-        chunk_relevancy_sorter: ChunkRelevancySorter | None,
-        chunk_relevancy_sort_config: ChunkRelevancySortConfig,
-        content_reducer: Callable[[list[WebPageChunk]], list[WebPageChunk]],
+        services: ExecutorServiceContext,
+        config: ExecutorConfiguration,
+        callbacks: ExecutorCallbacks,
         tool_call: LanguageModelFunction,
         tool_parameters: WebSearchToolParameters,
         refine_query_system_prompt: str,
-        debug_info: WebSearchDebugInfo,
-        tool_progress_reporter: Optional[ToolProgressReporter] = None,
         mode: RefineQueryMode = RefineQueryMode.BASIC,
         max_queries: int = 10,
     ):
         super().__init__(
-            search_service=search_service,
-            language_model_service=language_model_service,
-            language_model=language_model,
-            crawler_service=crawler_service,
+            services=services,
+            config=config,
+            callbacks=callbacks,
             tool_call=tool_call,
             tool_parameters=tool_parameters,
-            company_id=company_id,
-            content_processor=content_processor,
-            chunk_relevancy_sorter=chunk_relevancy_sorter,
-            chunk_relevancy_sort_config=chunk_relevancy_sort_config,
-            debug_info=debug_info,
-            content_reducer=content_reducer,
-            tool_progress_reporter=tool_progress_reporter,
-            message_log_callback=message_log_callback,
         )
         self.mode = mode
         self.tool_parameters = tool_parameters
         self.refine_query_system_prompt = refine_query_system_prompt
         self.max_queries = max_queries
 
-    async def run(self) -> tuple[list[ContentChunk], list[WebSearchLogEntry]]:
+    async def run(self) -> list[ContentChunk]:
         query = self.tool_parameters.query
         date_restrict = self.tool_parameters.date_restrict
 
         self.notify_name = "**Refining Query**"
         self.notify_message = query_params_to_human_string(query, date_restrict)
         await self.notify_callback()
-        self._active_message_log = self._message_log_callback(
-            progress_message=f"_Refining Query:_ {self.notify_message}"
+
+        await self._message_log_callback.log_progress(
+            f"_Refining Query:_ {self.notify_message}"
         )
         refined_queries, objective = await self._refine_query(query)
 
+        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)
-            for refined_query in refined_queries
+            for refined_query in elicitated_queries
         ]
-        self._active_message_log = self._message_log_callback(
-            queries_for_log=queries_wo_results
-        )
+        await self._message_log_callback.log_queries(queries_wo_results)
 
-        queries_for_log = []
-        for index, refined_query in enumerate(refined_queries):
-            if len(refined_queries) > 1:
+        for index, query in enumerate(elicitated_queries):
+            if len(elicitated_queries) > 1:
                 self.notify_name = (
-                    f"**Searching Web {index + 1}/{len(refined_queries)}**"
+                    f"**Searching Web {index + 1}/{len(elicitated_queries)}**"
                 )
             else:
                 self.notify_name = "**Searching Web**"
 
-            self.notify_message = query_params_to_human_string(
-                refined_query, date_restrict
-            )
+            self.notify_message = query_params_to_human_string(query, date_restrict)
             await self.notify_callback()
+            await self._message_log_callback.log_progress(self.notify_message)
 
-            search_results = await self._search(
-                refined_query, date_restrict=date_restrict
-            )
-            queries_for_log.append(
-                WebSearchLogEntry(
-                    type=StepType.SEARCH,
-                    message=self.notify_message,
-                    web_search_results=search_results,
-                )
-            )
+            search_results = await self._search(query, date_restrict=date_restrict)
 
-            web_search_results.extend(search_results)
+            await self._message_log_callback.log_web_search_results(search_results)
 
-        self._active_message_log = self._message_log_callback(
-            queries_for_log=queries_for_log
-        )
+            web_search_results.extend(search_results)
 
         if self.search_service.requires_scraping:
             self.notify_name = "**Crawling URLs**"
             self.notify_message = f"{len(web_search_results)} URLs to fetch"
             await self.notify_callback()
-            self._active_message_log = self._message_log_callback(
-                progress_message="_Crawling URLs_", queries_for_log=queries_for_log
-            )
+            await self._message_log_callback.log_progress("_Crawling URLs_")
             crawl_results = await self._crawl(web_search_results)
             for web_search_result, crawl_result in zip(
                 web_search_results, crawl_results
@@ -247,9 +208,7 @@ class WebSearchV1Executor(BaseWebSearchExecutor):
         self.notify_name = "**Analyzing Web Pages**"
         self.notify_message = objective
         await self.notify_callback()
-        self._active_message_log = self._message_log_callback(
-            progress_message="_Analyzing Web Pages_", queries_for_log=queries_for_log
-        )
+        await self._message_log_callback.log_progress("_Analyzing Web Pages_")
 
         content_results = await self._content_processing(objective, web_search_results)
 
@@ -257,15 +216,13 @@ class WebSearchV1Executor(BaseWebSearchExecutor):
             self.notify_name = "**Resorting Sources**"
             self.notify_message = objective
             await self.notify_callback()
-            self._active_message_log = self._message_log_callback(
-                progress_message="_Resorting Sources_", queries_for_log=queries_for_log
-            )
+            await self._message_log_callback.log_progress("_Resorting Sources_")
 
         relevant_sources = await self._select_relevant_sources(
             objective, content_results
         )
 
-        return relevant_sources, queries_for_log
+        return relevant_sources
 
     async def _refine_query(self, query: str) -> tuple[list[str], str]:
         start_time = time()

unique_web_search/services/executors/web_search_v2_executor.py

@@ -1,17 +1,7 @@
 import asyncio
 import logging
 from time import time
-from typing import Callable, Optional
 
-from unique_toolkit import LanguageModelService
-from unique_toolkit._common.chunk_relevancy_sorter.config import (
-    ChunkRelevancySortConfig,
-)
-from unique_toolkit._common.chunk_relevancy_sorter.service import ChunkRelevancySorter
-from unique_toolkit._common.validators import LMI
-from unique_toolkit.agentic.tools.tool_progress_reporter import (
-    ToolProgressReporter,
-)
 from unique_toolkit.content import ContentChunk
 from unique_toolkit.language_model import LanguageModelFunction
 
@@ -20,18 +10,18 @@ from unique_web_search.schema import (
     StepType,
     WebSearchPlan,
 )
-from unique_web_search.services.content_processing import ContentProcessor, WebPageChunk
-from unique_web_search.services.crawlers import CrawlerTypes
 from unique_web_search.services.executors.base_executor import (
     BaseWebSearchExecutor,
-    MessageLogCallback,
-    WebSearchLogEntry,
 )
-from unique_web_search.services.search_engine import SearchEngineTypes
+from unique_web_search.services.executors.context import (
+    ExecutorCallbacks,
+    ExecutorConfiguration,
+    ExecutorServiceContext,
+)
 from unique_web_search.services.search_engine.schema import (
     WebSearchResult,
 )
-from unique_web_search.utils import StepDebugInfo, WebSearchDebugInfo
+from unique_web_search.utils import StepDebugInfo
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -46,42 +36,23 @@ class WebSearchV2Executor(BaseWebSearchExecutor):
 
     def __init__(
         self,
-        search_service: SearchEngineTypes,
-        language_model_service: LanguageModelService,
-        language_model: LMI,
-        crawler_service: CrawlerTypes,
+        services: ExecutorServiceContext,
+        config: ExecutorConfiguration,
+        callbacks: ExecutorCallbacks,
         tool_call: LanguageModelFunction,
         tool_parameters: WebSearchPlan,
-        company_id: str,
-        content_processor: ContentProcessor,
-        message_log_callback: MessageLogCallback,
-        chunk_relevancy_sorter: ChunkRelevancySorter | None,
-        chunk_relevancy_sort_config: ChunkRelevancySortConfig,
-        content_reducer: Callable[[list[WebPageChunk]], list[WebPageChunk]],
-        debug_info: WebSearchDebugInfo,
-        tool_progress_reporter: Optional[ToolProgressReporter] = None,
         max_steps: int = 3,
     ):
         super().__init__(
-            search_service=search_service,
-            language_model_service=language_model_service,
-            language_model=language_model,
-            crawler_service=crawler_service,
+            services=services,
+            config=config,
+            callbacks=callbacks,
             tool_call=tool_call,
             tool_parameters=tool_parameters,
-            company_id=company_id,
-            content_processor=content_processor,
-            chunk_relevancy_sorter=chunk_relevancy_sorter,
-            chunk_relevancy_sort_config=chunk_relevancy_sort_config,
-            content_reducer=content_reducer,
-            debug_info=debug_info,
-            tool_progress_reporter=tool_progress_reporter,
-            message_log_callback=message_log_callback,
         )
 
         self.tool_parameters = tool_parameters
         self.max_steps = max_steps
-        self.queries_for_log: list[WebSearchLogEntry] = []
 
     @property
     def notify_name(self):
@@ -99,20 +70,20 @@ class WebSearchV2Executor(BaseWebSearchExecutor):
     def notify_message(self, value):
         self._notify_message = value
 
-    async def run(self) -> tuple[list[ContentChunk], list[WebSearchLogEntry]]:
+    async def run(self) -> list[ContentChunk]:
         await self._enforce_max_steps()
 
         results: list[WebSearchResult] = []
         self.notify_name = "**Searching Web**"
         self.notify_message = self.tool_parameters.objective
+
         await self.notify_callback()
-        self._message_log_callback(
-            progress_message="_Searching Web_", queries_for_log=self.queries_for_log
-        )
+        await self._message_log_callback.log_progress("_Searching Web_")
+
+        elicitated_steps = await self._elicitate_steps(self.tool_parameters.steps)
 
         tasks = [
-            asyncio.create_task(self._execute_step(step))
-            for step in self.tool_parameters.steps
+            asyncio.create_task(self._execute_step(step)) for step in elicitated_steps
         ]
 
         results_nested = await asyncio.gather(*tasks, return_exceptions=True)
@@ -123,20 +94,10 @@ class WebSearchV2Executor(BaseWebSearchExecutor):
             else:
                 results.extend(result)
 
-        # for step in self.tool_parameters.steps:
-        #     self.notify_name = step_type_to_name[step.step_type]
-        #     self.notify_message = step.objective
-        #     await self.notify_callback()
-        #     step_results = await self._execute_step(step)
-        #     results.extend(step_results)
-
         self.notify_name = "**Analyzing Web Pages**"
         self.notify_message = self.tool_parameters.expected_outcome
         await self.notify_callback()
-        self._message_log_callback(
-            progress_message="_Analyzing Web Pages_",
-            queries_for_log=self.queries_for_log,
-        )
+        await self._message_log_callback.log_progress("_Analyzing Web Pages_")
 
         content_results = await self._content_processing(
             self.tool_parameters.objective, results
@@ -146,16 +107,13 @@ class WebSearchV2Executor(BaseWebSearchExecutor):
             self.notify_name = "**Resorting Sources**"
             self.notify_message = self.tool_parameters.objective
             await self.notify_callback()
-            self._message_log_callback(
-                progress_message="_Resorting Sources_",
-                queries_for_log=self.queries_for_log,
-            )
+            await self._message_log_callback.log_progress("_Resorting Sources_")
 
         relevant_sources = await self._select_relevant_sources(
             self.tool_parameters.objective, content_results
         )
 
-        return relevant_sources, self.queries_for_log
+        return relevant_sources
 
     async def _execute_step(self, step: Step) -> list[WebSearchResult]:
         if step.step_type == StepType.SEARCH:
@@ -178,14 +136,9 @@ class WebSearchV2Executor(BaseWebSearchExecutor):
         time_start = time()
         _LOGGER.info(f"Company {self.company_id} Searching with {self.search_service}")
 
+        await self._message_log_callback.log_queries([step.query_or_url])
         results = await self.search_service.search(step.query_or_url)
-        self.queries_for_log.append(
-            WebSearchLogEntry(
-                type=StepType.SEARCH,
-                message=step.query_or_url,
-                web_search_results=results,
-            )
-        )
+        await self._message_log_callback.log_web_search_results(results)
 
         delta_time = time() - time_start
 
@@ -245,20 +198,17 @@ class WebSearchV2Executor(BaseWebSearchExecutor):
         )
         time_start = time()
         _LOGGER.info(f"Company {self.company_id} Crawling with {self.crawler_service}")
+
         results = await self.crawler_service.crawl([step.query_or_url])
-        self.queries_for_log.append(
-            WebSearchLogEntry(
-                type=StepType.READ_URL,
-                message=f"{step.query_or_url}",
-                web_search_results=[
-                    WebSearchResult(
-                        url=step.query_or_url,
-                        content=results[0],  # .content or "",
-                        snippet=step.objective,
-                        title=step.objective,
-                    )
-                ],
-            )
+        await self._message_log_callback.log_web_search_results(
+            [
+                WebSearchResult(
+                    url=step.query_or_url,
+                    content=results[0],
+                    snippet=step.objective,
+                    title=step.objective,
+                )
+            ]
         )
         delta_time = time() - time_start
         _LOGGER.debug(
@@ -300,3 +250,43 @@ class WebSearchV2Executor(BaseWebSearchExecutor):
                     },
                 )
             )
+
+    async def _elicitate_steps(self, steps: list[Step]) -> list[Step]:
+        """Elicit user approval for search steps while preserving read URL steps.
+
+        This method partitions the steps into search and read URL types. Search steps
+        require query elicitation for user approval/modification, while read URL steps
+        are passed through unchanged. The elicited queries replace the original search
+        steps, maintaining the step order (search steps first, then read URL steps).
+
+        Args:
+            steps: List of planned steps to elicit
+
+        Returns:
+            List of approved steps with elicited search queries and original read URL steps
+        """
+        # Partition steps by type in a single pass
+        search_steps, read_url_steps = [], []
+        for step in steps:
+            if step.step_type == StepType.SEARCH:
+                search_steps.append(step)
+            else:  # StepType.READ_URL
+                read_url_steps.append(step)
+
+        # Early return if no search steps require elicitation
+        if not search_steps:
+            return read_url_steps
+
+        # Extract queries and elicit user approval/modifications
+        search_queries = [step.query_or_url for step in search_steps]
+        elicited_queries = await self._ff_elicitate_queries(search_queries)
+
+        # Reconstruct search steps with elicited queries
+        # Note: Objectives are cleared as elicitation may have changed query intent
+        elicited_search_steps = [
+            Step(step_type=StepType.SEARCH, query_or_url=query, objective="")
+            for query in elicited_queries
+        ]
+
+        # Return elicited search steps followed by unchanged read URL steps
+        return elicited_search_steps + read_url_steps

unique_web_search/services/message_log.py

@@ -0,0 +1,70 @@
+from unique_toolkit.agentic.message_log_manager.service import MessageStepLogger
+from unique_toolkit.chat.schemas import (
+    MessageLog,
+    MessageLogDetails,
+    MessageLogEvent,
+    MessageLogStatus,
+)
+from unique_toolkit.content import ContentReference
+
+from unique_web_search.services.search_engine.schema import WebSearchResult
+
+
+class WebSearchMessageLogger:
+    def __init__(self, message_step_logger: MessageStepLogger, tool_display_name: str):
+        self._message_step_logger = message_step_logger
+        self._current_message_log: MessageLog | None = None
+        self._tool_display_name = tool_display_name
+
+        self._status = MessageLogStatus.RUNNING
+        self._details: MessageLogDetails = MessageLogDetails(data=[])
+        self._references: list[ContentReference] = []
+        self._progress_message = ""
+
+    async def finished(self) -> None:
+        self._status = MessageLogStatus.COMPLETED
+        await self._propagate_message_log()
+
+    async def failed(self) -> None:
+        self._status = MessageLogStatus.FAILED
+        await self._propagate_message_log()
+
+    async def log_progress(self, progress_message: str) -> None:
+        self._progress_message = progress_message
+        await self._propagate_message_log()
+
+    async def log_queries(self, queries: list[str]) -> None:
+        log_events_from_queries = [
+            MessageLogEvent(
+                type="WebSearch",
+                text=query,
+            )
+            for query in queries
+        ]
+        self._details.data.extend(log_events_from_queries)  # type: ignore (data has already been initialized with an empty list)
+        await self._propagate_message_log()
+
+    async def log_web_search_results(
+        self, web_search_results: list[WebSearchResult]
+    ) -> None:
+        offset_sequence_number = len(self._references)
+        new_references = [
+            web_search_result.to_content_reference(sequence_number)
+            for sequence_number, web_search_result in enumerate(
+                web_search_results, start=offset_sequence_number
+            )
+        ]
+        self._references.extend(new_references)
+        await self._propagate_message_log()
+
+    async def _propagate_message_log(self) -> None:
+        self._current_message_log = (
+            await self._message_step_logger.create_or_update_message_log_async(
+                active_message_log=self._current_message_log,
+                header=self._tool_display_name,
+                progress_message=self._progress_message,
+                details=self._details,
+                references=self._references,
+                status=self._status,
+            )
+        )

unique_web_search/services/query_elicitation.py

@@ -0,0 +1,162 @@
+"""Query elicitation service for web search.
+
+This module provides functionality for creating and evaluating query elicitations,
+allowing users to review and modify proposed search queries before execution.
+"""
+
+import asyncio
+import logging
+from typing import Self
+
+from pydantic import BaseModel, ConfigDict, Field, create_model
+from unique_toolkit._common.pydantic_helpers import get_configuration_dict
+from unique_toolkit.chat.service import ChatService
+from unique_toolkit.elicitation import (
+    ElicitationCancelledException,
+    ElicitationDeclinedException,
+    ElicitationExpiredException,
+    ElicitationFailedException,
+    ElicitationMode,
+    ElicitationStatus,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class QueryElicitationConfig(BaseModel):
+    model_config = get_configuration_dict()
+
+    enable_elicitation: bool = Field(
+        default=True,
+        description="Whether to enable elicitation. This flag is relevant only if the associated feature flag is enabled.",
+    )
+    timeout_seconds: int = Field(
+        default=60,
+        description="Timeout in seconds for waiting for user approval",
+        ge=1,
+        le=300,
+    )
+
+
+class QueryElicitationModel(BaseModel):
+    """Model for query elicitation with support for default values.
+
+    This model uses Pydantic's RootModel to represent a list of queries.
+    The create_model_with_default_queries classmethod enables dynamic model
+    creation with default values for form pre-population.
+    """
+
+    model_config = ConfigDict(title="Query Elicitation")
+    queries: list[str] = Field(description="The queries to search the web for")
+
+    @classmethod
+    def create_model_with_default_queries(cls, queries: list[str]) -> type[Self]:
+        """Create a model with default query values.
+
+        This method dynamically creates a Pydantic model where the root field
+        has default values set to the provided queries. This allows elicitation
+        forms to be pre-populated with suggested queries that users can review
+        and modify.
+
+        Args:
+            queries: List of default query strings to pre-populate
+
+        Returns:
+            A new model class with default values set
+        """
+        model = create_model(
+            cls.__name__,
+            queries=(
+                list[str],
+                Field(
+                    description="The queries to search the web for",
+                    default=queries,
+                ),
+            ),
+            __base__=cls,
+        )
+        return model
+
+
+class QueryElicitationService:
+    """Service for managing query elicitation workflow.
+
+    This service encapsulates the logic for creating elicitations and waiting
+    for user approval, providing a clean callback-based interface for integration
+    with web search executors.
+    """
+
+    def __init__(
+        self,
+        chat_service: ChatService,
+        display_name: str,
+        config: QueryElicitationConfig,
+    ):
+        """Initialize the query elicitation service.
+
+        Args:
+            chat_service: Service for interacting with chat/elicitation APIs
+            display_name: Display name for the tool in elicitation UI
+            timeout_seconds: Timeout in seconds for waiting for user approval
+        """
+        self._chat_service = chat_service
+        self._display_name = display_name
+        self._config = config
+
+    async def __call__(self, queries: list[str]) -> list[str]:
+        if not self._config.enable_elicitation:
+            return queries
+
+        _LOGGER.info("Creating elicitation...")
+
+        model = QueryElicitationModel.create_model_with_default_queries(queries)
+        elicitation = await self._chat_service.elicitation.create_async(
+            mode=ElicitationMode.FORM,
+            tool_name=self._display_name,
+            message="Web Search Query Approval",
+            json_schema=model.model_json_schema(),
+            expires_in_seconds=self._config.timeout_seconds,
+        )
+        _LOGGER.info(
+            f"Elicitation created: {elicitation.id}. Waiting for user response for {self._config.timeout_seconds} seconds..."
+        )
+
+        for _ in range(self._config.timeout_seconds):
+            await asyncio.sleep(1)
+            elicitation = await self._chat_service.elicitation.get_async(
+                elicitation_id=elicitation.id,
+            )
+            if elicitation.status == ElicitationStatus.ACCEPTED:
+                _LOGGER.info(f"Query elicitation {elicitation.id} accepted")
+                queries = QueryElicitationModel.model_validate(
+                    elicitation.response_content
+                ).queries
+
+                if len(queries) == 0:
+                    raise ElicitationFailedException(
+                        context="The user approved the web search request but removed all search queries from the form, resulting in zero queries to execute.",
+                        instruction="The web search tool did not execute because no search queries were provided. "
+                        "**IMPORTANT INFORMATION TO PROPAGATE TO THE USER:** The user was presented with an approval form (elicitation UI) showing the proposed search queries before execution. "
+                        "They clicked 'Approve' or submitted the form, but all search query fields were either removed or left empty. "
+                        "Because of this, the web search tool cannot perform any searches - it needs at least one search query to execute. "
+                        "Explain this situation clearly to the user and inform them that the search was not performed. "
+                        "Ask if they would like to retry the search with specific queries, or if they can describe what information they're looking for so you can help formulate appropriate search queries for the next approval.",
+                    )
+
+                return queries
+
+            elif elicitation.status == ElicitationStatus.DECLINED:
+                _LOGGER.info(f"Query elicitation {elicitation.id} declined")
+                raise ElicitationDeclinedException(
+                    f"Elicitation triggerd with queries {queries} was declined"
+                )
+
+            elif elicitation.status == ElicitationStatus.CANCELLED:
+                _LOGGER.info(f"Query elicitation {elicitation.id} cancelled")
+                raise ElicitationCancelledException(
+                    f"Elicitation triggerd with queries {queries} was cancelled"
+                )
+
+        raise ElicitationExpiredException(
+            f"Query elicitation {elicitation.id} not accepted"
+        )