aiqtoolkit 1.2.0.dev0__py3-none-any.whl → 1.2.0rc2__py3-none-any.whl

aiq/experimental/inference_time_scaling/editing/llm_as_a_judge_editor.py

@@ -0,0 +1,204 @@
+# 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 asyncio
+import logging
+import re
+
+from aiq.builder.builder import Builder
+from aiq.builder.framework_enum import LLMFrameworkEnum
+from aiq.cli.register_workflow import register_its_strategy
+from aiq.data_models.its_strategy import ITSStrategyBaseConfig
+from aiq.experimental.inference_time_scaling.models.editor_config import LLMAsAJudgeEditorConfig
+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
+from aiq.experimental.inference_time_scaling.models.strategy_base import StrategyBase
+from aiq.utils.io.model_processing import remove_r1_think_tags
+
+logger = logging.getLogger(__name__)
+
+
+class LLMAsAJudgeEditor(StrategyBase):
+    """
+    Given a list of PlanningItems, uses a feedback LLM to generate feedback on each plan
+    Then edits the plan based on feedback.
+    """
+
+    def __init__(self, config: ITSStrategyBaseConfig) -> None:
+        super().__init__(config)
+        self.feedback_llm = None
+        self.editing_llm = None
+
+    async def build_components(self, builder: Builder) -> None:
+        """
+        Build the components required for the editor.
+        """
+        # Get the feedback LLM
+        self.feedback_llm = await builder.get_llm(self.config.feedback_llm, wrapper_type=LLMFrameworkEnum.LANGCHAIN)
+
+        self.editing_llm = await builder.get_llm(self.config.editing_llm, wrapper_type=LLMFrameworkEnum.LANGCHAIN)
+
+    def supported_pipeline_types(self) -> [PipelineTypeEnum]:
+        return [PipelineTypeEnum.PLANNING]
+
+    def stage_type(self) -> StageTypeEnum:
+        return StageTypeEnum.EDITING
+
+    async def generate_feedback(self, llm, template, context: str, prompt: str, item: ITSItem) -> ITSItem:
+        """
+        Helper function to generate feedback for a given planning item using the provided prompt.
+        """
+
+        prompt = await template.ainvoke(
+            input={
+                "context": context,
+                "original_prompt": prompt,  # Original prompt used to generate the plans
+                "plan": item.plan,
+                "num_feedback": self.config.num_feedback
+            })
+
+        feedback_result = await llm.ainvoke(prompt.to_string())
+        if not feedback_result:
+            logger.warning(f"No feedback generated for plan: {item.plan}.")
+            return item
+
+        # Update the planning item with the generated feedback
+        cleaned = remove_r1_think_tags(
+            feedback_result.content if hasattr(feedback_result, 'content') else str(feedback_result))
+
+        # Feedback is the string following 'FEEDBACK:'. Use Regex to extract
+        cleaned = re.sub(r'(?i)^\s*FEEDBACK:\s*', '', cleaned).strip()
+        if not cleaned:
+            logger.warning(f"Feedback was empty for plan: {item.plan}.")
+            return item
+
+        item.feedback = cleaned  # Set the feedback in the ITSItem
+
+        return item
+
+    async def edit_plan(self, llm, template, context: str, prompt: str, item: ITSItem) -> ITSItem:
+        """
+        Helper function to edit a plan based on feedback using the provided prompt.
+        """
+
+        if not item.feedback:
+            logger.warning(f"No feedback available for plan: {item.plan}. Cannot edit.")
+            return item
+
+        prompt = await template.ainvoke(
+            input={
+                "context": context,
+                "original_prompt": prompt,  # Original prompt used to generate the plans
+                "plan": item.plan,
+                "feedback": item.feedback
+            })
+
+        editing_result = await llm.ainvoke(prompt.to_string())
+        if not editing_result:
+            logger.warning(f"No editing result generated for plan: {item.plan}.")
+            return item
+
+        # Update the planning item with the edited plan
+        cleaned = remove_r1_think_tags(
+            editing_result.content if hasattr(editing_result, 'content') else str(editing_result))
+
+        # Plan is the string following 'EDITED PLAN:'. Use Regex to extract
+        cleaned = re.sub(r'(?i)^\s*EDITED PLAN:\s*', '', cleaned).strip()
+        if not cleaned:
+            logger.warning(f"Edited plan was empty for plan: {item.plan}. Returning original.")
+            return item
+
+        # Update the plan in the PlanningItem
+        item.plan = cleaned
+
+        return item
+
+    async def ainvoke(self,
+                      items: list[ITSItem],
+                      original_prompt: str | None = None,
+                      agent_context: str | None = None,
+                      **kwargs) -> list[ITSItem]:
+        """
+        Edit the provided planning items using a feedback LLM.
+        """
+        from langchain_core.language_models import BaseChatModel
+        from langchain_core.prompts import PromptTemplate
+
+        # assert self.config.feedback_llm is a BaseChatModel
+        if not isinstance(self.feedback_llm, BaseChatModel):
+            raise ValueError("The `feedback_llm` must be an instance of `BaseChatModel`.")
+
+        # assert self.config.editing_llm is a BaseChatModel
+        if not isinstance(self.editing_llm, BaseChatModel):
+            raise ValueError("The `editing_llm` must be an instance of `BaseChatModel`.")
+
+        feedback_model: BaseChatModel = self.feedback_llm
+        editing_model: BaseChatModel = self.editing_llm
+
+        feedback_template = PromptTemplate(template=self.config.feedback_template,
+                                           input_variables=["context", "original_prompt", "plan", "num_feedback"],
+                                           validate_template=True)
+
+        editing_template = PromptTemplate(template=self.config.editor_template,
+                                          input_variables=["context", "original_prompt", "plan", "feedback"],
+                                          validate_template=True)
+
+        # Generate feedback for each planning item concurrently
+        feedback_tasks = [
+            self.generate_feedback(
+                llm=feedback_model,
+                template=feedback_template,
+                context=agent_context,
+                prompt=original_prompt,  # Original prompt used to generate the plans
+                item=item) for item in items
+        ]
+        # Run the feedback tasks concurrently and gather results
+        planning_items_with_feedback = await asyncio.gather(*feedback_tasks)
+
+        if not planning_items_with_feedback:
+            raise ValueError("No feedback was generated for the planning items. Please check the LLM response.")
+
+        logger.info("Generated feedback for %d plans.", len(planning_items_with_feedback))
+
+        # Now edit each planning item based on the feedback concurrently
+        editing_tasks = [
+            self.edit_plan(
+                llm=editing_model,
+                template=editing_template,
+                context=agent_context,
+                prompt=original_prompt,  # Original prompt used to generate the plans
+                item=item) for item in planning_items_with_feedback
+        ]
+        # Run the editing tasks concurrently and gather results
+        edited_planning_items = await asyncio.gather(*editing_tasks)
+
+        if not edited_planning_items:
+            raise ValueError("No plans were edited. Please check the LLM response.")
+
+        logger.info("Edited %d plans based on feedback.", len(edited_planning_items))
+        return edited_planning_items
+
+
+@register_its_strategy(config_type=LLMAsAJudgeEditorConfig)
+async def register_llm_as_a_judge_editor(config: ITSStrategyBaseConfig, builder: Builder):
+    """
+    Register the LLMAsAJudgeEditor strategy with the provided configuration and builder.
+    """
+
+    editor = LLMAsAJudgeEditor(config)
+    await editor.build_components(builder)
+
+    yield editor

aiq/experimental/inference_time_scaling/editing/motivation_aware_summarization.py

@@ -0,0 +1,107 @@
+# 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 aiq.builder.builder import Builder
+from aiq.builder.framework_enum import LLMFrameworkEnum
+from aiq.cli.register_workflow import register_its_strategy
+from aiq.experimental.inference_time_scaling.models.editor_config import MotivationAwareSummarizationConfig
+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
+from aiq.experimental.inference_time_scaling.models.strategy_base import StrategyBase
+from aiq.utils.io.model_processing import remove_r1_think_tags
+
+logger = logging.getLogger(__name__)
+
+
+class MotivationAwareSummarization(StrategyBase):
+    """
+    A strategy that, for each incoming ITSItem, summarizes the output based on input
+    and motivation.
+    """
+
+    def __init__(self, config: MotivationAwareSummarizationConfig) -> None:
+        super().__init__(config)
+        self.config = config
+        self.llm_bound = None
+
+    async def build_components(self, builder: Builder) -> None:
+        """
+        Binds each LLMRef in self.config.llms to an actual LLM client.
+        """
+        bound_llm = await builder.get_llm(self.config.editor_llm, wrapper_type=LLMFrameworkEnum.LANGCHAIN)
+        self.llm_bound = bound_llm
+
+    def supported_pipeline_types(self) -> list[PipelineTypeEnum]:
+        return [PipelineTypeEnum.TOOL_USE]
+
+    def stage_type(self) -> StageTypeEnum:
+        return StageTypeEnum.EDITING
+
+    async def ainvoke(self,
+                      items: list[ITSItem],
+                      original_prompt: str | None = None,
+                      agent_context: str | None = None,
+                      **kwargs) -> list[ITSItem]:
+        """
+        For each ITSItem, rewrite the 'input' using each LLM to create a new perspective.
+        The new ITSItems' 'output' field will store the newly generated query.
+        """
+        try:
+            from langchain_core.prompts import PromptTemplate
+        except ImportError:
+            raise ImportError("langchain-core is required for MultiQueryRetrievalSearch. "
+                              "Install aiqtoolkit-langchain or similar.")
+
+        new_its_items: list[ITSItem] = []
+
+        # Create a single PromptTemplate object for rewriting the query
+        template_vars = ["task", "motivation", "output"]
+        query_template = PromptTemplate(template=self.config.editor_template,
+                                        input_variables=template_vars,
+                                        validate_template=True)
+
+        for item in items:
+            original_task = str(item.input) or ""
+            motivation = str(item.metadata) if item.metadata else ""
+            output = str(item.output) if item.output else ""
+
+            prompt = await (query_template.ainvoke(input={
+                "task": original_task, "motivation": motivation, "output": output
+            }))
+
+            llm_response = await self.llm_bound.ainvoke(prompt.to_string())
+            llm_response = remove_r1_think_tags(llm_response.content)
+
+            logger.info("LLM response from summarization: %s", llm_response)
+
+            new_its_items.append(
+                ITSItem(
+                    input=item.input,
+                    output=remove_r1_think_tags(llm_response),
+                    metadata=item.metadata,
+                    name=item.name,  # keep the original tool name
+                ))
+
+        return new_its_items
+
+
+@register_its_strategy(config_type=MotivationAwareSummarizationConfig)
+async def register_multi_query_retrieval_search(config: MotivationAwareSummarizationConfig, builder: Builder):
+    strategy = MotivationAwareSummarization(config)
+    await strategy.build_components(builder)
+    yield strategy

aiq/experimental/inference_time_scaling/functions/execute_score_select_function.py

@@ -0,0 +1,105 @@
+# 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 pydantic import Field
+
+from aiq.builder.builder import Builder
+from aiq.builder.function import Function
+from aiq.builder.function_info import FunctionInfo
+from aiq.cli.register_workflow import register_function
+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 ExecuteScoreSelectFunctionConfig(FunctionBaseConfig, name="execute_score_select_function"):
+    scorer: ITSStrategyRef | None = Field(description="Strategy to score the output of the function", default=None)
+    selector: ITSStrategyRef = Field(description="Strategy to select the best output of the function")
+    augmented_fn: FunctionRef = Field(description="Function that will be executed")
+
+    num_executions: int = Field(3, description="Number of times to execute the function")
+
+
+@register_function(config_type=ExecuteScoreSelectFunctionConfig)
+async def execute_score_select_function(config: ExecuteScoreSelectFunctionConfig, builder: Builder):
+    import asyncio
+    import warnings
+
+    from pydantic import BaseModel
+
+    executable_fn: Function = builder.get_function(name=config.augmented_fn)
+
+    if config.scorer:
+        scorer = await builder.get_its_strategy(strategy_name=config.scorer,
+                                                pipeline_type=PipelineTypeEnum.AGENT_EXECUTION,
+                                                stage_type=StageTypeEnum.SCORING)
+    else:
+        scorer = None
+
+    selector = await builder.get_its_strategy(strategy_name=config.selector,
+                                              pipeline_type=PipelineTypeEnum.AGENT_EXECUTION,
+                                              stage_type=StageTypeEnum.SELECTION)
+
+    if executable_fn.has_streaming_output:
+        warnings.warn("Streaming output is not supported for this function. "
+                      "The function will be executed in non-streaming mode.")
+
+    def convert_to_str(arg):
+        if isinstance(arg, BaseModel):
+            return str(arg.model_dump())
+        return str(arg)
+
+    async def execute_fn(input_msg: executable_fn.input_type) -> executable_fn.single_output_type:
+
+        logger.info("Executing function %d times", config.num_executions)
+        tasks = [executable_fn.ainvoke(input_msg) for _ in range(config.num_executions)]
+        results = await asyncio.gather(*tasks)
+
+        input_str = convert_to_str(input_msg)
+        function_outputs = [convert_to_str(out) for out in results]
+        its_items = [ITSItem(
+            input=input_str,
+            output=out,
+        ) for out in function_outputs]
+
+        if scorer:
+            logger.info("Beginning scoring")
+            its_items = await scorer.ainvoke(items=its_items)
+
+        logger.info("Beginning selection")
+        selected_item = (await selector.ainvoke(items=its_items, original_prompt=its_items[0].input))[0]
+
+        # Find the index of selected item in its_items by matching the output
+        selected_output = selected_item.output
+        selected_index = -1
+        for i, item in enumerate(its_items):
+            if item.output == selected_output:
+                selected_index = i
+                break
+
+        return results[selected_index] if selected_index != -1 else selected_output
+
+    yield FunctionInfo.from_fn(
+        fn=execute_fn,
+        description=("This function executes a given function multiple times, scores the outputs, "
+                     "and selects the best output based on the specified scoring and selection strategies."),
+    )

aiq/experimental/inference_time_scaling/functions/its_tool_orchestration_function.py

@@ -0,0 +1,205 @@
+# 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 asyncio
+import logging
+
+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.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
+from aiq.experimental.inference_time_scaling.models.tool_use_config import ToolUseInputSchema
+from aiq.experimental.inference_time_scaling.models.tool_use_config import ToolUselist
+
+logger = logging.getLogger(__name__)
+
+
+class ITSToolOrchestrationFunctionConfig(FunctionBaseConfig, name="its_tool_orchestration"):
+    """
+    Configuration for the ITSToolOrchestrationFunction, which is used to orchestrate multiple functions.
+    """
+
+    augmented_fns: list[FunctionRef] = Field(
+        description="list of FunctionRefs for the functions to be orchestrated. Must be wrapped in `its_tool_wrapper`.")
+
+    search_strategy: ITSStrategyRef | None = Field(
+        description="The ITS search strategy to use for orchestrating invocation of the functions."
+        " If None, no search will be performed.",
+        default=None,
+    )
+
+    editing_strategy: ITSStrategyRef | None = Field(
+        default=None,
+        description="The ITS editing strategy to use for orchestrating invocation of the functions. "
+        "If None, no editing will be performed.",
+    )
+
+    scoring_strategy: ITSStrategyRef | None = Field(
+        default=None,
+        description="The ITS scoring strategy to use for orchestrating invocation of the functions. "
+        "If None, no scoring will be performed.",
+    )
+
+    selection_strategy: ITSStrategyRef = Field(
+        description="The ITS selection strategy to use for orchestrating invocation of the functions.")
+
+
+@register_function(config_type=ITSToolOrchestrationFunctionConfig, framework_wrappers=[LLMFrameworkEnum.LANGCHAIN])
+async def register_its_tool_orchestration_function(
+    config: ITSToolOrchestrationFunctionConfig,
+    builder: Builder,
+):
+    """
+    Registers an ITS-based orchestration function that:
+     1. Instantiates all relevant strategies (search, editing, scoring, selection).
+     2. Accepts a ToolUselist, converts each item to an ITSItem, optionally runs search/editing.
+     3. Calls the correct augmented_fn per item using name=tool name.
+     4. If configured, runs scoring and selection on the result.
+     5. Returns a new ToolUselist with each output set.
+    """
+
+    # 1) Gather references to all augmented (wrapped) functions
+    function_map = {}
+    for fn_ref in config.augmented_fns:
+        # Retrieve the actual function from the builder
+        fn_obj = builder.get_function(fn_ref)
+        function_map[fn_ref] = fn_obj
+
+    # 2) Instantiate search, editing, scoring, selection strategies (if any)
+    search = None
+    if config.search_strategy is not None:
+        search = await builder.get_its_strategy(
+            strategy_name=config.search_strategy,
+            pipeline_type=PipelineTypeEnum.TOOL_USE,
+            stage_type=StageTypeEnum.SEARCH,
+        )
+
+    editing = None
+    if config.editing_strategy is not None:
+        editing = await builder.get_its_strategy(
+            strategy_name=config.editing_strategy,
+            pipeline_type=PipelineTypeEnum.TOOL_USE,
+            stage_type=StageTypeEnum.EDITING,
+        )
+
+    scoring = None
+    if config.scoring_strategy is not None:
+        scoring = await builder.get_its_strategy(
+            strategy_name=config.scoring_strategy,
+            pipeline_type=PipelineTypeEnum.TOOL_USE,
+            stage_type=StageTypeEnum.SCORING,
+        )
+
+    selection = await builder.get_its_strategy(
+        strategy_name=config.selection_strategy,
+        pipeline_type=PipelineTypeEnum.TOOL_USE,
+        stage_type=StageTypeEnum.SELECTION,
+    )
+
+    fn_description = ("\n".join(f"- **{fn_ref}**: {function_map[fn_ref].description or 'No description provided.'}"
+                                for fn_ref in config.augmented_fns))
+
+    # 3) Create the inner function to handle single (non-streaming) calls.
+    async def single_inner(tool_list: ToolUselist) -> ToolUselist:
+        """
+        Orchestrates multiple tool usages, optionally using search/editing/scoring/selection steps.
+        """
+        # Convert each ToolUseInputSchema to ITSItem
+        its_items = []
+        for t in tool_list.tools:
+            item = ITSItem(
+                input=t.task_description,  # The user "task"
+                output=None,
+                name=t.tool_name,  # The "tool name"
+                metadata=t.motivation,  # The "justification"
+            )
+            its_items.append(item)
+
+        # Run search strategy if present
+        if search is not None:
+            its_items = await search.ainvoke(its_items)
+
+        logger.info("ITS orchestration function: %d items after search", len(its_items))
+
+        # Invoke the correct augmented function for each item concurrently
+        # Helper coroutine to invoke a tool function and capture result or error
+        async def _invoke_tool(item: ITSItem, fn):
+            try:
+                result = await fn.acall_invoke(item.output)
+                return item, result, None
+            except Exception as e:
+                logger.error(f"Error invoking function '{item.name}': {e}")
+                return item, None, str(e)
+
+        tasks = []
+        for item in its_items:
+            if item.name not in function_map:
+                logger.error(f"Function '{item.name}' not found in function map.")
+                item.output = f"Error: Function '{item.name}' not found in function map. Check your input"
+            else:
+                fn = function_map[item.name]
+                tasks.append(_invoke_tool(item, fn))
+
+        # Await all tasks and assign outputs
+        if tasks:
+            results = await asyncio.gather(*tasks)
+            for item, result, error in results:
+                if error:
+                    item.output = f"Error invoking function '{item.name}': {error}"
+                else:
+                    item.output = result
+
+        if editing:
+            its_items = await editing.ainvoke(its_items)
+
+        # Run scoring strategy if present
+        if scoring is not None:
+            its_items = await scoring.ainvoke(its_items)
+
+        # Run selection strategy
+        if selection is not None:
+            its_items = await selection.ainvoke(its_items)
+
+        logger.info("ITS orchestration function: %d items after selection", len(its_items))
+
+        # Convert final results from ITSItems back to a ToolUselist
+        final_list = ToolUselist(tools=[])
+        for item in its_items:
+            # Compose a new ToolUseInputSchema with final output
+            new_tool = ToolUseInputSchema(
+                tool_name=item.name,
+                task_description=str(item.input),
+                motivation=item.metadata if item.metadata else None,
+                output=str(item.output) if item.output is not None else None,
+            )
+            final_list.tools.append(new_tool)
+
+        return final_list
+
+    # 4) Return the function info (only a single_fn is needed; no streaming)
+    yield FunctionInfo.create(
+        single_fn=single_inner,
+        stream_fn=None,  # No streaming required
+        input_schema=ToolUselist,
+        single_output_schema=ToolUselist,
+        description=fn_description)