nvidia-nat 1.2.0__py3-none-any.whl

nat/eval/utils/weave_eval.py

@@ -0,0 +1,184 @@
+# 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 typing import Any
+
+from nat.eval.evaluator.evaluator_model import EvalInput
+from nat.eval.evaluator.evaluator_model import EvalInputItem
+from nat.eval.evaluator.evaluator_model import EvalOutput
+from nat.eval.usage_stats import UsageStats
+from nat.eval.usage_stats import UsageStatsItem
+from nat.profiler.data_models import ProfilerResults
+
+logger = logging.getLogger(__name__)
+
+
+class WeaveEvaluationIntegration:  # pylint: disable=too-many-public-methods
+    """
+    Class to handle all Weave integration functionality.
+    """
+
+    def __init__(self):
+        self.available = False
+        self.client = None
+        self.eval_logger = None
+        self.pred_loggers = {}
+
+        try:
+            from weave.flow.eval_imperative import EvaluationLogger
+            from weave.flow.eval_imperative import ScoreLogger
+            from weave.trace.context import weave_client_context
+            self.EvaluationLogger = EvaluationLogger
+            self.ScoreLogger = ScoreLogger
+            self.weave_client_context = weave_client_context
+            self.available = True
+        except ImportError:
+            self.available = False
+            # we simply don't do anything if weave is not available
+            pass
+
+    def initialize_client(self):
+        """Initialize the Weave client if available."""
+        if not self.available:
+            return False
+
+        try:
+            self.client = self.weave_client_context.require_weave_client()
+            return self.client is not None
+        except Exception:
+            self.client = None
+            return False
+
+    def _get_prediction_inputs(self, item: EvalInputItem):
+        """Get the inputs for displaying in the UI.
+        The following fields are excluded as they are too large to display in the UI:
+        - full_dataset_entry
+        - expected_trajectory
+        - trajectory
+
+        output_obj is excluded because it is displayed separately.
+        """
+        include = {"id", "input_obj", "expected_output_obj"}
+        return item.model_dump(include=include)
+
+    def _get_weave_dataset(self, eval_input: EvalInput):
+        """Get the full dataset for Weave."""
+        return [item.full_dataset_entry for item in eval_input.eval_input_items]
+
+    def initialize_logger(self, workflow_alias: str, eval_input: EvalInput, config: Any):
+        """Initialize the Weave evaluation logger."""
+        if not self.client and not self.initialize_client():
+            # lazy init the client
+            return False
+
+        try:
+            weave_dataset = self._get_weave_dataset(eval_input)
+            config_dict = config.model_dump(mode="json")
+            config_dict["name"] = workflow_alias
+            self.eval_logger = self.EvaluationLogger(model=config_dict, dataset=weave_dataset)
+            self.pred_loggers = {}
+
+            return True
+        except Exception as e:
+            self.eval_logger = None
+            logger.warning("Failed to initialize Weave `EvaluationLogger`: %s", e)
+
+            return False
+
+    def log_prediction(self, item: EvalInputItem, output: Any):
+        """Log a prediction to Weave."""
+        if not self.eval_logger:
+            return
+
+        pred_logger = self.eval_logger.log_prediction(inputs=self._get_prediction_inputs(item), output=output)
+        self.pred_loggers[item.id] = pred_logger
+
+    async def log_usage_stats(self, item: EvalInputItem, usage_stats_item: UsageStatsItem):
+        """Log usage stats to Weave."""
+        if not self.eval_logger:
+            return
+
+        # log each usage stat as a score
+        await self.pred_loggers[item.id].alog_score(scorer="wf_runtime", score=usage_stats_item.runtime)
+
+        # log the total tokens for this item, per-llm tokens can be exported later if needed
+        await self.pred_loggers[item.id].alog_score(scorer="wf_tokens", score=usage_stats_item.total_tokens)
+
+    async def alog_score(self, eval_output: EvalOutput, evaluator_name: str):
+        """Log scores for evaluation outputs."""
+        if not self.eval_logger:
+            return
+
+        # Create coroutines for all score logging operations
+        coros = []
+        for eval_output_item in eval_output.eval_output_items:
+            if eval_output_item.id in self.pred_loggers:
+                coros.append(self.pred_loggers[eval_output_item.id].alog_score(
+                    scorer=evaluator_name,
+                    score=eval_output_item.score,
+                ))
+
+        # Execute all coroutines concurrently
+        if coros:
+            await asyncio.gather(*coros)
+
+    async def afinish_loggers(self):
+        """Finish all prediction loggers."""
+        if not self.eval_logger:
+            return
+
+        async def _finish_one(pred_logger):
+            if hasattr(pred_logger, '_has_finished') and not pred_logger._has_finished:
+                return
+            # run the *blocking* finish() in a thread so we don't nest loops
+            await asyncio.to_thread(pred_logger.finish)
+
+        await asyncio.gather(*[_finish_one(pl) for pl in self.pred_loggers.values()])
+
+    def _log_profiler_metrics(self, profiler_results: ProfilerResults, usage_stats: UsageStats) -> dict[str, Any]:
+        """Log profiler metrics to Weave."""
+        profile_metrics = {}
+        if profiler_results.llm_latency_ci:
+            profile_metrics["llm_latency_p95"] = profiler_results.llm_latency_ci.p95
+        if profiler_results.workflow_runtime_metrics:
+            profile_metrics["wf_runtime_p95"] = profiler_results.workflow_runtime_metrics.p95
+
+        # TODO:get the LLM tokens from the usage stats and log them
+        profile_metrics["total_runtime"] = usage_stats.total_runtime
+
+        return profile_metrics
+
+    def log_summary(self,
+                    usage_stats: UsageStats,
+                    evaluation_results: list[tuple[str, EvalOutput]],
+                    profiler_results: ProfilerResults):
+        """Log summary statistics to Weave."""
+        if not self.eval_logger:
+            return
+
+        summary = {}
+        # add evaluation results to the summary
+        for evaluator_name, eval_output in evaluation_results:
+            summary[evaluator_name] = eval_output.average_score
+
+        # add profiler metrics to the summary
+        profile_metrics = self._log_profiler_metrics(profiler_results, usage_stats)
+        summary.update(profile_metrics)
+
+        # Log the summary to finish the evaluation, disable auto-summarize
+        # as we will be adding profiler metrics to the summary
+        self.eval_logger.log_summary(summary, auto_summarize=False)

nat/experimental/decorators/experimental_warning_decorator.py

@@ -0,0 +1,134 @@
+# 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 functools
+import inspect
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+BASE_WARNING_MESSAGE = ("is experimental and the API may change in future releases. "
+                        "Future versions may introduce breaking changes without notice.")
+
+_warning_issued = set()
+
+
+def issue_experimental_warning(function_name: str,
+                               feature_name: str | None = None,
+                               metadata: dict[str, Any] | None = None):
+    """
+    Log a warning message that the function is experimental.
+
+    A warning is emitted only once per function.  When a ``metadata`` dict
+    is supplied, it is appended to the log entry to provide extra context
+    (e.g., version, author, feature flag).
+    """
+    if function_name not in _warning_issued:
+        if (feature_name):
+            warning_message = f"The {feature_name} feature {BASE_WARNING_MESSAGE}"
+        else:
+            warning_message = f"This function {BASE_WARNING_MESSAGE}"
+
+        warning_message += f" Function: {function_name}"
+
+        if (metadata):
+            warning_message += f" | Metadata: {metadata}"
+
+        # Issue warning and save function name to avoid duplicate warnings
+        logger.warning(warning_message)
+
+        _warning_issued.add(function_name)
+
+
+def experimental(func: Any = None, *, feature_name: str | None = None, metadata: dict[str, Any] | None = None):
+    """
+    Decorator that can wrap any type of function (sync, async, generator,
+    async generator) and logs a warning that the function is experimental.
+
+    Args:
+        func: The function to be decorated.
+        feature_name: Optional name of the feature that is experimental. If provided, the warning will be
+        prefixed with "The <feature_name> feature is experimental".
+        metadata: Optional dictionary of metadata to log with the warning. This can include information
+        like version, author, etc. If provided, the metadata will be
+        logged alongside the experimental warning.
+    """
+    function_name: str = f"{func.__module__}.{func.__qualname__}" if func else "<unknown_function>"
+
+    # If called as @track_function(...) but not immediately passed a function
+    if func is None:
+
+        def decorator_wrapper(actual_func):
+            return experimental(actual_func, feature_name=feature_name, metadata=metadata)
+
+        return decorator_wrapper
+
+    # --- Validate metadata ---
+    if metadata is not None:
+        if not isinstance(metadata, dict):
+            raise TypeError("metadata must be a dict[str, Any].")
+        if any(not isinstance(k, str) for k in metadata.keys()):
+            raise TypeError("All metadata keys must be strings.")
+
+    # --- Now detect the function type and wrap accordingly ---
+    if inspect.isasyncgenfunction(func):
+        # ---------------------
+        # ASYNC GENERATOR
+        # ---------------------
+
+        @functools.wraps(func)
+        async def async_gen_wrapper(*args, **kwargs):
+            issue_experimental_warning(function_name, feature_name, metadata)
+            async for item in func(*args, **kwargs):
+                yield item  # yield the original item
+
+        return async_gen_wrapper
+
+    if inspect.iscoroutinefunction(func):
+        # ---------------------
+        # ASYNC FUNCTION
+        # ---------------------
+        @functools.wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            issue_experimental_warning(function_name, feature_name, metadata)
+            result = await func(*args, **kwargs)
+            return result
+
+        return async_wrapper
+
+    if inspect.isgeneratorfunction(func):
+        # ---------------------
+        # SYNC GENERATOR
+        # ---------------------
+        @functools.wraps(func)
+        def sync_gen_wrapper(*args, **kwargs):
+            issue_experimental_warning(function_name, feature_name, metadata)
+            for item in func(*args, **kwargs):
+                yield item  # yield the original item
+
+        return sync_gen_wrapper
+
+    @functools.wraps(func)
+    def sync_wrapper(*args, **kwargs):
+        issue_experimental_warning(function_name, feature_name, metadata)
+        result = func(*args, **kwargs)
+        return result
+
+    return sync_wrapper
+
+
+# Compatibility aliases with previous releases
+aiq_experimental = experimental

nat/experimental/test_time_compute/editing/iterative_plan_refinement_editor.py

@@ -0,0 +1,147 @@
+# 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 nat.builder.builder import Builder
+from nat.builder.framework_enum import LLMFrameworkEnum
+from nat.cli.register_workflow import register_ttc_strategy
+from nat.data_models.ttc_strategy import TTCStrategyBaseConfig
+from nat.experimental.test_time_compute.models.editor_config import IterativePlanRefinementConfig
+from nat.experimental.test_time_compute.models.stage_enums import PipelineTypeEnum
+from nat.experimental.test_time_compute.models.stage_enums import StageTypeEnum
+from nat.experimental.test_time_compute.models.strategy_base import StrategyBase
+from nat.experimental.test_time_compute.models.ttc_item import TTCItem
+from nat.utils.io.model_processing import remove_r1_think_tags
+
+logger = logging.getLogger(__name__)
+
+
+class IterativePlanRefinementEditor(StrategyBase):
+    """
+    A planner that generates an initial plan, then refines it multiple times
+    using the same LLM. Each iteration updates the plan to (hopefully) be better.
+    """
+
+    def __init__(self, config: TTCStrategyBaseConfig) -> None:
+        super().__init__(config)
+        self.llm_bound = None
+
+    def supported_pipeline_types(self) -> [PipelineTypeEnum]:
+        return [PipelineTypeEnum.PLANNING]
+
+    def stage_type(self) -> StageTypeEnum:
+        return StageTypeEnum.EDITING
+
+    async def build_components(self, builder: Builder) -> None:
+        """
+        Build the components required for the iterative planner.
+        """
+        logger.debug("Building components for IterativePlanRefinementEditor")
+        self.llm_bound = await builder.get_llm(self.config.editor_llm, wrapper_type=LLMFrameworkEnum.LANGCHAIN)
+
+    async def refine_single(self, prompt: str, context: str, ttc_item: TTCItem, prompt_idx: int) -> TTCItem:
+        from langchain_core.language_models import BaseChatModel
+        from langchain_core.prompts import PromptTemplate
+
+        if not isinstance(self.llm_bound, BaseChatModel):
+            raise ValueError("editor_llm must be a BaseChatModel instance for iterative plan refinement.")
+
+        llm: BaseChatModel = self.llm_bound
+
+        # Refinement loop
+        refinement_template = PromptTemplate(
+            template=self.config.refinement_template,
+            input_variables=["current_plan", "context", "original_prompt"],
+            validate_template=True,
+        )
+
+        current_plan = ttc_item.plan
+        for iteration in range(1, self.config.num_iterations + 1):
+            logger.info("Refinement iteration %d / %d for prompt %d", iteration, self.config.num_iterations, prompt_idx)
+            refine_prompt = (await refinement_template.ainvoke({
+                "current_plan": current_plan, "context": context, "original_prompt": prompt
+            })).to_string()
+
+            refine_response = await llm.ainvoke(refine_prompt)
+            refined_plan = remove_r1_think_tags(
+                refine_response.content if hasattr(refine_response, 'content') else str(refine_response))
+            refined_plan = re.sub(r'(?i)^\s*EDITED PLAN:\s*', '', refined_plan).strip()
+            if refined_plan:
+                current_plan = refined_plan
+            else:
+                logger.warning("Refinement iteration %d for prompt %d produced an empty plan; keeping existing plan.",
+                               iteration,
+                               prompt_idx)
+
+        logger.info("IterativePlanRefinementPlanner produced a final plan after %d iterations.",
+                    self.config.num_iterations)
+
+        ttc_item.plan = current_plan
+        # Return a single final plan
+        return ttc_item
+
+    async def ainvoke(self,
+                      items: list[TTCItem],
+                      original_prompt: str | None = None,
+                      agent_context: str | None = None,
+                      **kwargs) -> list[TTCItem]:
+        """
+        Runs the iterative plan refinement process on the provided planning items.
+
+        Each planning item is refined in parallel the configured number of times. Default is 3.
+
+        Args:
+            items (list[TTCItem]): The planning items to refine.
+            original_prompt (str): The original prompt used to generate the plans.
+            agent_context (str): The context for the agent.
+
+        Returns:
+            list[TTCItem]: The refined planning items.
+        """
+
+        if not original_prompt or not agent_context:
+            raise ValueError("Arguments original_prompt and agent_context must be provdied.")
+
+        # Generate feedback for each planning item concurrently
+        tasks = [
+            self.refine_single(prompt=original_prompt, context=agent_context, ttc_item=item, prompt_idx=i + 1)
+            for i, item in enumerate(items)
+        ]
+
+        # Run the tasks concurrently and gather results
+        refined_planning_items = await asyncio.gather(*tasks)
+
+        return refined_planning_items
+
+
+@register_ttc_strategy(config_type=IterativePlanRefinementConfig)
+async def register_iterative_plan_refinement_editor(config: IterativePlanRefinementConfig, builder: Builder):
+    """
+    Register the IterativePlanRefinementEditor strategy.
+
+    Args:
+        config (IterativePlanRefinementConfig): The configuration for the strategy.
+
+    Returns:
+        IterativePlanRefinementEditor: The registered strategy instance.
+    """
+
+    editor = IterativePlanRefinementEditor(config)
+    await editor.build_components(builder=builder)
+
+    yield editor

nat/experimental/test_time_compute/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 nat.builder.builder import Builder
+from nat.builder.framework_enum import LLMFrameworkEnum
+from nat.cli.register_workflow import register_ttc_strategy
+from nat.data_models.ttc_strategy import TTCStrategyBaseConfig
+from nat.experimental.test_time_compute.models.editor_config import LLMAsAJudgeEditorConfig
+from nat.experimental.test_time_compute.models.stage_enums import PipelineTypeEnum
+from nat.experimental.test_time_compute.models.stage_enums import StageTypeEnum
+from nat.experimental.test_time_compute.models.strategy_base import StrategyBase
+from nat.experimental.test_time_compute.models.ttc_item import TTCItem
+from nat.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: TTCStrategyBaseConfig) -> 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: TTCItem) -> TTCItem:
+        """
+        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 TTCItem
+
+        return item
+
+    async def edit_plan(self, llm, template, context: str, prompt: str, item: TTCItem) -> TTCItem:
+        """
+        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[TTCItem],
+                      original_prompt: str | None = None,
+                      agent_context: str | None = None,
+                      **kwargs) -> list[TTCItem]:
+        """
+        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_ttc_strategy(config_type=LLMAsAJudgeEditorConfig)
+async def register_llm_as_a_judge_editor(config: TTCStrategyBaseConfig, builder: Builder):
+    """
+    Register the LLMAsAJudgeEditor strategy with the provided configuration and builder.
+    """
+
+    editor = LLMAsAJudgeEditor(config)
+    await editor.build_components(builder)
+
+    yield editor