aiqtoolkit 1.2.0rc3__py3-none-any.whl → 1.2.0rc5__py3-none-any.whl

aiq/experimental/inference_time_scaling/functions/plan_select_execute_function.py

@@ -1,224 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import logging
-from collections.abc import AsyncGenerator
-
-from pydantic import Field
-
-from aiq.builder.builder import Builder
-from aiq.builder.framework_enum import LLMFrameworkEnum
-from aiq.builder.function_info import FunctionInfo
-from aiq.cli.register_workflow import register_function
-from aiq.data_models.api_server import AIQChatRequest
-from aiq.data_models.component_ref import FunctionRef
-from aiq.data_models.component_ref import ITSStrategyRef
-from aiq.data_models.function import FunctionBaseConfig
-from aiq.experimental.inference_time_scaling.models.its_item import ITSItem
-from aiq.experimental.inference_time_scaling.models.stage_enums import PipelineTypeEnum
-from aiq.experimental.inference_time_scaling.models.stage_enums import StageTypeEnum
-
-logger = logging.getLogger(__name__)
-
-
-class PlanSelectExecuteFunctionConfig(FunctionBaseConfig, name="plan_select_execute_function"):
-    """
-    Defines an aiqtoolkit function that performs reasoning on the input data.
-    Output is passed to the next function in the workflow.
-
-    Designed to be used with an InterceptingFunction.
-    """
-
-    augmented_fn: FunctionRef = Field(description="The name of the function to reason on.")
-
-    planner: ITSStrategyRef = Field(description="The configuration for the planner.")
-    editor: ITSStrategyRef | None = Field(description="The configuration for the editor.", default=None)
-    scorer: ITSStrategyRef | None = Field(description="The configuration for the scorer.", default=None)
-    selector: ITSStrategyRef = Field(description="The configuration for the selector.")
-
-    verbose: bool = Field(default=False, description="Whether to log detailed information.")
-    agent_context_prompt_template: str = Field(
-        description="The template for the agent context prompt. This prompt is used to provide context about the agent",
-        default=("\nThe agent system has the following description:\n"
-                 "{description}\n"
-                 "And has access to the following tools with functionality:\n"
-                 "{tools}\n\n"))
-
-    downstream_template: str = Field(
-        description=("The template for the downstream prompt. This prompt is used to provide the reasoning output to"
-                     " the executing agent"),
-        default=("Answer the following question based on message history: {input_text}"
-                 "\n\nHere is a plan for execution that you could use to guide you if you wanted to:"
-                 "\n\n{reasoning_output}"
-                 "\n\nNOTE: Remember to follow your guidance on how to format output, etc."
-                 "\n\n You must respond with the answer to the original question directly to the user."))
-
-
-@register_function(config_type=PlanSelectExecuteFunctionConfig, framework_wrappers=[LLMFrameworkEnum.LANGCHAIN])
-async def plan_select_execute_function(config: PlanSelectExecuteFunctionConfig, builder: Builder):
-    """
-    Build a ExecutionPlanningFunction from the provided config.
-
-    Args:
-        config (ExecutionPlanningFunctionConfig): The config for the ExecutionPlanningFunction.
-        builder (Builder): The Builder instance to use for building the function.
-
-    Returns:
-        ExecutionPlanningFunction: The built ExecutionPlanningFunction.
-    """
-
-    try:
-        from langchain_core.prompts import PromptTemplate
-    except ImportError:
-        raise ImportError("langchain-core is not installed. Please install it to use SingleShotMultiPlanPlanner.\n"
-                          "This error can be resolved by installing aiqtoolkit-langchain.")
-
-    # Get the augmented function's description
-    augmented_function = builder.get_function(config.augmented_fn)
-
-    # For now, we rely on runtime checking for type conversion
-
-    if augmented_function.description and augmented_function.description != "":
-        augmented_function_desc = augmented_function.description
-    else:
-        raise ValueError(f"Function {config.augmented_fn} does not have a description. Cannot augment "
-                         f"function without a description.")
-
-    # Get the function dependencies of the augmented function
-    function_used_tools = builder.get_function_dependencies(config.augmented_fn).functions
-    tool_list = "Tool: Description\n"
-
-    for tool in function_used_tools:
-        tool_impl = builder.get_function(tool)
-        tool_list += f"- {tool}: {tool_impl.description if hasattr(tool_impl, 'description') else ''}\n"
-
-    # Draft the reasoning prompt for the augmented function
-    template = PromptTemplate(template=config.agent_context_prompt_template,
-                              input_variables=["description", "tools"],
-                              validate_template=True)
-
-    downstream_template = PromptTemplate(template=config.downstream_template,
-                                         input_variables=["input_text", "reasoning_output"],
-                                         validate_template=True)
-
-    planner = await builder.get_its_strategy(strategy_name=config.planner,
-                                             pipeline_type=PipelineTypeEnum.PLANNING,
-                                             stage_type=StageTypeEnum.SEARCH)
-
-    selector = await builder.get_its_strategy(strategy_name=config.selector,
-                                              pipeline_type=PipelineTypeEnum.PLANNING,
-                                              stage_type=StageTypeEnum.SELECTION)
-
-    if config.editor:
-        editor = await builder.get_its_strategy(strategy_name=config.editor,
-                                                pipeline_type=PipelineTypeEnum.PLANNING,
-                                                stage_type=StageTypeEnum.EDITING)
-    else:
-        editor = None
-
-    if config.scorer:
-        scorer = await builder.get_its_strategy(strategy_name=config.scorer,
-                                                pipeline_type=PipelineTypeEnum.PLANNING,
-                                                stage_type=StageTypeEnum.SCORING)
-    else:
-        scorer = None
-
-    async def planning_pipeline(prompt, context):
-
-        plans = await planner.ainvoke([ITSItem()], prompt, context)
-
-        if editor:
-            plans = await editor.ainvoke(plans, prompt, context)
-        if scorer:
-            plans = await scorer.ainvoke(plans, prompt, context)
-
-        selected_plan = (await selector.ainvoke(plans, prompt, context))[0]
-
-        return selected_plan
-
-    streaming_inner_fn = None
-    single_inner_fn = None
-
-    if augmented_function.has_streaming_output:
-
-        async def streaming_inner(
-                input_message: AIQChatRequest) -> AsyncGenerator[augmented_function.streaming_output_type]:
-            """
-            Perform reasoning on the input text.
-
-            Args:
-                input_message (AIQChatRequest): The input text to reason on.
-            """
-
-            input_text = "".join([str(message.model_dump()) + "\n" for message in input_message.messages])
-
-            context_prompt = await template.ainvoke(input={"description": augmented_function_desc, "tools": tool_list})
-
-            context_prompt = context_prompt.to_string()
-
-            # Run the ITS pipeline
-            planning_item: ITSItem = await planning_pipeline(prompt=input_text, context=context_prompt)
-
-            output = await downstream_template.ainvoke(input={
-                "input_text": input_text, "reasoning_output": planning_item.plan
-            })
-
-            output = output.to_string()
-
-            if config.verbose:
-                logger.info("Reasoning plan and input to agent: \n\n%s", output)
-
-            async for chunk in augmented_function.acall_stream(output):
-                yield chunk
-
-        streaming_inner_fn = streaming_inner
-
-    if augmented_function.has_single_output:
-
-        async def single_inner(input_message: AIQChatRequest) -> augmented_function.single_output_type:
-            """
-            Perform reasoning on the input text.
-
-            Args:
-                input_message (AIQChatRequest): The input text to reason on.
-            """
-
-            input_text = "".join([str(message.model_dump()) + "\n" for message in input_message.messages])
-
-            context_prompt = await template.ainvoke(input={"description": augmented_function_desc, "tools": tool_list})
-
-            context_prompt = context_prompt.to_string()
-
-            # Run the ITS pipeline
-            planning_item: ITSItem = await planning_pipeline(prompt=input_text, context=context_prompt)
-
-            output = await downstream_template.ainvoke(input={
-                "input_text": input_text, "reasoning_output": planning_item.plan
-            })
-
-            output = output.to_string()
-
-            if config.verbose:
-                logger.info("Reasoning plan and input to agent: \n\n%s", output)
-
-            return await augmented_function.acall_invoke(output)
-
-        single_inner_fn = single_inner
-
-    yield FunctionInfo.create(
-        single_fn=single_inner_fn,
-        stream_fn=streaming_inner_fn,
-        description=("Function that runs an ITS execution planner on input and sends plan downstream"),
-        converters=augmented_function.converter_list)

aiq/experimental/inference_time_scaling/models/editor_config.py

@@ -1,132 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import typing
-
-from pydantic import Field
-from pydantic import model_validator
-
-from aiq.data_models.component_ref import LLMRef
-from aiq.data_models.its_strategy import ITSStrategyBaseConfig
-
-
-class LLMAsAJudgeEditorConfig(ITSStrategyBaseConfig, name="llm_as_a_judge_editor"):
-    """
-    Configuration for the LLMAsAJudgeEditor.
-    """
-    num_feedback: int = Field(default=10,
-                              description="Number of feedback items to generate for each plan during editing. "
-                              "This can help in refining the plans based on feedback.")
-
-    # If strategy is provided, LLM must be
-    editing_llm: LLMRef | typing.Any | None = Field(
-        default=None,
-        description="The LLM to use for editing the plans. This can be a callable or an instance of an LLM client.")
-
-    # If strategy is LLM_AS_A_JUDGE, ensure that the feedback_llm is provided.
-    feedback_llm: LLMRef | typing.Any | None = Field(default=None,
-                                                     description="The LLM to use for generating feedback on the plans."
-                                                     " This can be a callable or an instance of an LLM client.")
-
-    editor_template: str = Field(default=(
-        "You are an expert at improving execution plans. You will be given a plan and feedback on that plan."
-        " Your task is to create an improved version of the plan that addresses the feedback "
-        "while maintaining its strengths.\n\n"
-        "Here is the context:\n\n"
-        "{context}\n\n"
-        "**Input:** \n{original_prompt}\n\n"
-        "**Original Plan:**\n{plan}\n\n"
-        "**Feedback on the Plan:**\n{feedback}\n\n"
-        "Please provide an improved version of the plan that addresses"
-        " the feedback points. Maintain the same structure and "
-        "step-by-step format, but enhance the content. Do not include explanations of your changes, just provide the "
-        "improved plan directly:\n\n"
-        "Begin the final improve plan with 'EDITED PLAN:'"),
-                                 description="The template to use for editing the planning items based on feedback.")
-
-    feedback_template: str = Field(
-        default=("You are an expert at evaluating execution plans. You will be given a plan and "
-                 "need to provide {num_feedback} "
-                 "specific points of feedback about its strengths and weaknesses.\n\n"
-                 "Your feedback should cover aspects like:\n"
-                 "- Comprehensiveness of the plan\n"
-                 "- Logical flow and sequencing\n"
-                 "- Appropriate use of available tools\n"
-                 "- Potential edge cases or failure points\n"
-                 "- Efficiency and optimization opportunities\n\n"
-                 "Here is the context and plan to evaluate:\n\n"
-                 "{context}\n\n"
-                 "**Objective:** \n{original_prompt}\n\n"
-                 "**Plan to Evaluate:**\n{plan}\n\n"
-                 "Please provide exactly {num_feedback} numbered points of feedback, including "
-                 "both strengths and areas for improvement. Begin the feedback with 'FEEDBACK:' and provide"
-                 "{num_feedback} specific feedback points."),
-        description="The template to use for generating feedback for each planning item.")
-
-    @model_validator(mode="before")
-    def validate_strategies(cls, values: dict[str, typing.Any]) -> dict[str, typing.Any]:
-
-        if values.get('editing_llm') is None:
-            raise ValueError('editing_llm must be provided when editing_strategy is set.')
-        # If editing strategy is LLM_AS_A_JUDGE, feedback_llm must also be provided
-        if (values.get('feedback_llm') is None):
-            raise ValueError('feedback_llm must be provided when editing_strategy is LLM_AS_A_JUDGE.')
-
-        return values
-
-
-class IterativePlanRefinementConfig(ITSStrategyBaseConfig, name="iterative_plan_refinement"):
-    """Configuration for an 'iterative plan refinement' strategy."""
-    editor_llm: LLMRef | typing.Any | None = Field(
-        default=None, description="The LLM to use for generating and refining the plan across multiple iterations.")
-    num_iterations: int = Field(default=3, description="How many refinement steps to perform.")
-    refinement_template: str = Field(
-        default=("You have the current plan:\n{current_plan}\n\n"
-                 "The plan was generated to achieve the following objective:\n{original_prompt}\n\n"
-                 "Using an agent system with the following description:\n{context}\n\n"
-                 "Refine or improve it to achieve the objective better."
-                 "Output the updated plan, beginning with:\nEDITED PLAN:\n"),
-        description="Prompt used in each iteration to refine the plan.")
-
-    @model_validator(mode="before")
-    def validate_iterative_strategies(cls, values: dict) -> dict:
-        if not values.get('editor_llm'):
-            raise ValueError('planning_llm must be provided for iterative plan refinement.')
-        if values.get('num_iterations', 0) < 1:
-            raise ValueError('num_iterations must be >= 1 for iterative plan refinement.')
-        return values
-
-
-class MotivationAwareSummarizationConfig(ITSStrategyBaseConfig, name="motivation_aware_editing"):
-    """
-    Configuration for the MotivationAwareSummarization strategy.
-    """
-    editor_llm: LLMRef | typing.Any | None = Field(
-        default=None,
-        description="The LLM to use for editing the plans. This can be a callable or an instance of an LLM client.")
-
-    editor_template: str = Field(
-        default=("You are an expert at summarizing key information from relevant documents based on an input task"
-                 "and motivation. Given a task and motivation, and documents, your task is to create a concise "
-                 "a summarized response to the task and motivation grounded in the documents .\n\n"
-                 "Here is the task:\n\n"
-                 "{task}\n\n"
-                 "Here is the motivation:\n\n"
-                 "{motivation}\n\n"
-                 "and here are the documents:\n\n"
-                 "{output}\n\n"
-                 "Please respond with a concise summary that addresses the task and motivation, in at most one"
-                 "or two sentences. Do not include any other output except the summary. "),
-        description="The template to use for summarizing documents.")

aiq/experimental/inference_time_scaling/models/its_item.py

@@ -1,48 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import typing
-
-from pydantic import BaseModel
-from pydantic import ConfigDict
-from pydantic import Field
-
-
-class ITSItem(BaseModel):
-    """
-    Represents an item in the Inference Time Scaling (ITS) functions and pipelines
-    """
-    model_config = ConfigDict(extra="allow")
-
-    input: typing.Any | None = Field(default=None,
-                                     description="Input to the function or pipeline. "
-                                     "This can be a structured tool call, or other info.")
-    output: typing.Any | None = Field(default=None,
-                                      description="Output from the function or pipeline. "
-                                      "This can be a structured tool call, or other info.")
-    plan: typing.Any | None = Field(default=None, description="Search plan for downstream agent(s).")
-    feedback: str | None = Field(default=None,
-                                 description="Feedback "
-                                 "provided by feedback steps to improve the plan.")
-    score: float | None = Field(default=None,
-                                description="Score of the plan based on feedback or other evaluation criteria. "
-                                "This can be used to rank plans.")
-    metadata: typing.Any | None = Field(default=None,
-                                        description="Additional information. This can be"
-                                        " a structured tool call, or other info not "
-                                        "in the plan.")
-    name: str | None = Field(default=None,
-                             description="Name of the item or function"
-                             ", used for identification in pipelines.")

aiq/experimental/inference_time_scaling/models/scoring_config.py

@@ -1,112 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import typing
-
-from pydantic import Field
-from pydantic import model_validator
-
-from aiq.data_models.component_ref import LLMRef
-from aiq.data_models.its_strategy import ITSStrategyBaseConfig
-
-
-class LLMBasedPlanScoringConfig(ITSStrategyBaseConfig, name="llm_based_plan_scoring"):
-    """
-    Configuration for LLMBasedScoring.
-    """
-    scoring_llm: LLMRef | typing.Any | None = Field(
-        default=None,
-        description="The LLM to use for scoring the plans. This can be a callable or an instance of an LLM client.")
-
-    scoring_template: str = Field(
-        default=("You are an expert reasoning model tasked with scoring the following execution plan based on its"
-                 "quality and relevance to the provided input to an agent system.\n\n"
-                 "The agent system's role is:\n{context}\n\n"
-                 "It has been tasked with achieving the following goal: \n{original_prompt}\n\n"
-                 "The following plan has been generated to achieve this goal:\n\n{plan}\n\n"
-                 "Score the plan on a scale from 1 to 10, where 10 is the best. "
-                 "Return the final score as a floating point number preceded by `FINAL SCORE:` without any "
-                 "other text before or after it\n"),
-        description="The template to use for scoring the plans.")
-
-    @model_validator(mode="before")
-    def validate_strategies(cls, values: dict[str, typing.Any]) -> dict[str, typing.Any]:
-        """
-        Ensure that the scoring_llm is provided when using LLMBasedScoring.
-        """
-        if values.get('scoring_llm') is None:
-            raise ValueError('scoring_llm must be provided when scorer_type is set to LLM_BASED_SCORING.')
-
-        return values
-
-
-class LLMBasedAgentScoringConfig(ITSStrategyBaseConfig, name="llm_based_agent_scoring"):
-    """
-    Configuration for LLMBasedScoring.
-    """
-    scoring_llm: LLMRef | typing.Any | None = Field(
-        default=None,
-        description="The LLM to use for scoring the plans. This can be a callable or an instance of an LLM client.")
-
-    scoring_template: str = Field(
-        description="Prompt template to use for scoring the function output",
-        default=("You are an expert reasoning model tasked with scoring the following "
-                 "result of an agent system based on its input and objective. Judge"
-                 " the quality and relevance of the answer to score it.\n\n"
-                 "The agent system's objective is:\n{objective}\n\n"
-                 "It has been tasked with achieving the following goal: \n{input}\n\n"
-                 "The following output has been generated by the agent:\n\n{output}\n\n"
-                 "Score the result on a scale from 1 to 10, where 10 is the best. "
-                 "Return the final score as a floating point number preceded by `FINAL SCORE:` without any "
-                 "other text before or after it\n"),
-    )
-
-    @model_validator(mode="before")
-    def validate_strategies(cls, values: dict[str, typing.Any]) -> dict[str, typing.Any]:
-        """
-        Ensure that the scoring_llm is provided when using LLMBasedScoring.
-        """
-        if values.get('scoring_llm') is None:
-            raise ValueError('scoring_llm must be provided when scorer_type is set to LLM_BASED_SCORING.')
-
-        return values
-
-
-class MotivationAwareScoringConfig(ITSStrategyBaseConfig, name="motivation_aware_scoring"):
-    """
-    Configuration for a scoring strategy that considers both the original input (task)
-    and the motivation (from metadata) along with the current output.
-    """
-
-    scoring_llm: LLMRef | None = Field(
-        default=None, description="The LLM used to evaluate how well the output addresses the task plus motivation.")
-
-    scoring_template: str = Field(
-        default=("You are an expert at assessing the quality of an output in relation to its task and motivation.\n"
-                 "Task: {task}\n"
-                 "Motivation: {motivation}\n"
-                 "Output: {output}\n"
-                 "On a scale from 1 to 10 (10 being the best), how well does this output fulfill "
-                 "the original task in the context "
-                 "of the provided motivation? Note that the task might answer one part of a bigger question "
-                 "which should count as a satisfactory response and should not receive a lower score.\n"
-                 "Return the final score as a floating point number preceded by 'FINAL SCORE:'."),
-        description="The prompt template used to evaluate and score the output.")
-
-    @model_validator(mode="before")
-    def validate_scoring_llm(cls, values):
-        if values.get('scoring_llm') is None:
-            raise ValueError("A scoring_llm must be provided for motivation_aware_scoring.")
-        return values

aiq/experimental/inference_time_scaling/models/search_config.py

@@ -1,120 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import typing
-
-from pydantic import Field
-from pydantic import model_validator
-
-from aiq.data_models.component_ref import LLMRef
-from aiq.data_models.its_strategy import ITSStrategyBaseConfig
-
-
-class SingleShotMultiPlanConfig(ITSStrategyBaseConfig, name="single_shot_multi_plan"):
-    num_plans: int = Field(default=4, description="Number of plans to generate.")
-    max_temperature: float = Field(default=1.0,
-                                   description="Maximum temperature to use for sampling when generating plans. "
-                                   "This can help control the randomness of the generated plans.")
-    min_temperature: float = Field(default=0.5,
-                                   description="Minimum temperature to use for sampling when generating plans. "
-                                   "This can help control the randomness of the generated plans.")
-    # If strategy is provided, LLM must be
-    planning_llm: LLMRef | typing.Any | None = Field(
-        default=None,
-        description="The LLM to use for planning. This can be a callable or an "
-        "instance of an LLM client.")
-
-    planning_template: str = Field(
-        default=("You are an expert reasoning model task with creating a detailed execution plan"
-                 " for a system that has the following information to get the result of a given input:\n\n"
-                 "**System Information:**\n {context}"
-                 "**Input:** \n{prompt}\n\n"
-                 "An example plan could look like this:\n\n"
-                 "1. Call tool A with input X\n"
-                 "2. Call tool B with input Y\n"
-                 "3. Interpret the output of tool A and B\n"
-                 "4. Return the final result"
-                 "\n\nBegin the final plan with PLAN:\n"),
-        description="The template to use for generating plans.")
-
-    @model_validator(mode="before")
-    def validate_strategies(cls, values: dict[str, typing.Any]) -> dict[str, typing.Any]:
-        """
-        Ensure that the required LLMs are provided based on the selected strategies.
-        """
-        # Validate planning strategy: planning_llm must be provided if planning_strategy is set
-        if values.get('planning_llm') is None:
-            raise ValueError('planning_llm must be provided when planning_strategy is set.')
-
-        return values
-
-
-class MultiLLMPlanConfig(ITSStrategyBaseConfig, name="multi_llm_plan"):
-    """Configuration for a 'multi LLM plan generation' strategy."""
-    llms: list[LLMRef] = Field(
-        default_factory=list,
-        description="list of LLMs to use for plan generation. Each LLM can generate one or more plans.")
-    plans_per_llm: int = Field(default=2, description="Number of plans each LLM should generate.")
-    max_temperature: float = Field(default=1.0,
-                                   description="Maximum temperature to use for sampling when generating plans. "
-                                   "This can help control the randomness of the generated plans.")
-    min_temperature: float = Field(default=0.5,
-                                   description="Minimum temperature to use for sampling when generating plans. "
-                                   "This can help control the randomness of the generated plans.")
-    planning_template: str = Field(
-        default=("You are an expert reasoning model task with creating a detailed execution plan"
-                 " for a system that has the following information to get the result of a given input:\n\n"
-                 "**System Information:**\n {context}"
-                 "**Input:** \n{prompt}\n\n"
-                 "An example plan could look like this:\n\n"
-                 "1. Call tool A with input X\n"
-                 "2. Call tool B with input Y\n"
-                 "3. Interpret the output of tool A and B\n"
-                 "4. Return the final result"
-                 "\n\nBegin the final plan with PLAN:\n"),
-        description="The template to use for generating plans.")
-
-    @model_validator(mode="before")
-    def validate_multi_llm_strategies(cls, values: dict) -> dict:
-        if not values.get('llms'):
-            raise ValueError('Must provide at least one LLMRef in `llms` for multi-LLM strategy.')
-        return values
-
-
-class MultiQueryRetrievalSearchConfig(ITSStrategyBaseConfig, name="multi_query_retrieval_search"):
-    """
-    Configuration for the MultiQueryRetrievalSearch strategy.
-    This strategy generates multiple new 'ITSItem's per original item,
-    each containing a differently phrased or re-focused version of the original task.
-    """
-    llms: list[LLMRef] = Field(default_factory=list,
-                               description="list of LLM references to use for generating diverse queries.")
-
-    query_generation_template: str = Field(
-        default=("You are an expert at re-framing a user's query to encourage new solution paths. "
-                 "Given the task description and an optional motivation, produce a short alternative query "
-                 "that addresses the same task from a different angle. By generating multiple "
-                 "perspectives on the task, your goal is to help "
-                 "the user overcome some of the limitations of distance-based similarity search.\n\n"
-                 "Task: {task}\n"
-                 "Motivation: {motivation}\n\n"
-                 "Output a concise new query statement below. Only output the revised query and nothing else.\n"),
-        description="Prompt template for rewriting the task from a different perspective.")
-
-    @model_validator(mode="before")
-    def validate_llms(cls, values):
-        if not values.get('llms'):
-            raise ValueError("At least one LLMRef must be provided for multi_query_retrieval_search.")
-        return values