fabricatio 0.2.8.dev2__cp312-cp312-win_amd64.whl → 0.2.8.dev4__cp312-cp312-win_amd64.whl

fabricatio/capabilities/rating.py

@@ -7,16 +7,16 @@ from typing import Dict, List, Optional, Set, Tuple, Union, Unpack, overload
 from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.config import configs
 from fabricatio.journal import logger
-from fabricatio.models.generic import WithBriefing
-from fabricatio.models.kwargs_types import ValidateKwargs
+from fabricatio.models.generic import Display
+from fabricatio.models.kwargs_types import CompositeScoreKwargs, ValidateKwargs
 from fabricatio.models.usages import LLMUsage
-from fabricatio.models.utils import override_kwargs
 from fabricatio.parser import JsonCapture
+from fabricatio.utils import ok, override_kwargs
 from more_itertools import flatten, windowed
 from pydantic import NonNegativeInt, PositiveInt
 
 
-class Rating(WithBriefing, LLMUsage):
+class Rating(LLMUsage):
     """A class that provides functionality to rate tasks based on a rating manual and score range.
 
     References:
@@ -87,6 +87,7 @@ class Rating(WithBriefing, LLMUsage):
         to_rate: str,
         topic: str,
         criteria: Set[str],
+        manual: Optional[Dict[str, str]],
         score_range: Tuple[float, float] = (0.0, 1.0),
         **kwargs: Unpack[ValidateKwargs],
     ) -> Dict[str, float]: ...
@@ -97,6 +98,7 @@ class Rating(WithBriefing, LLMUsage):
         to_rate: List[str],
         topic: str,
         criteria: Set[str],
+        manual: Optional[Dict[str, str]],
         score_range: Tuple[float, float] = (0.0, 1.0),
         **kwargs: Unpack[ValidateKwargs],
     ) -> List[Dict[str, float]]: ...
@@ -106,6 +108,7 @@ class Rating(WithBriefing, LLMUsage):
         to_rate: Union[str, List[str]],
         topic: str,
         criteria: Set[str],
+        manual: Optional[Dict[str, str]],
         score_range: Tuple[float, float] = (0.0, 1.0),
         **kwargs: Unpack[ValidateKwargs],
     ) -> Optional[Dict[str, float] | List[Dict[str, float]]]:
@@ -115,6 +118,7 @@ class Rating(WithBriefing, LLMUsage):
             to_rate (Union[str, List[str]]): The string or sequence of strings to be rated.
             topic (str): The topic related to the task.
             criteria (Set[str]): A set of criteria for rating.
+            manual (Optional[Dict[str, str]]): A dictionary containing the rating criteria. If not provided, then this method will draft the criteria automatically.
             score_range (Tuple[float, float], optional): A tuple representing the valid score range. Defaults to (0.0, 1.0).
             **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
 
@@ -122,7 +126,11 @@ class Rating(WithBriefing, LLMUsage):
             Union[Dict[str, float], List[Dict[str, float]]]: A dictionary with the ratings for each criterion if a single string is provided,
             or a list of dictionaries with the ratings for each criterion if a sequence of strings is provided.
         """
-        manual = await self.draft_rating_manual(topic, criteria, **kwargs) or dict(zip(criteria, criteria, strict=True))
+        manual = (
+            manual
+            or await self.draft_rating_manual(topic, criteria, **override_kwargs(kwargs, default=None))
+            or dict(zip(criteria, criteria, strict=True))
+        )
 
         return await self.rate_fine_grind(to_rate, manual, score_range, **kwargs)
 
@@ -149,9 +157,7 @@ class Rating(WithBriefing, LLMUsage):
                 return json_data
             return None
 
-        criteria = criteria or await self.draft_rating_criteria(
-            topic, **self.prepend_sys_msg(override_kwargs(dict(kwargs), default=None))
-        )
+        criteria = criteria or await self.draft_rating_criteria(topic, **override_kwargs(dict(kwargs), default=None))
 
         if criteria is None:
             logger.error(f"Failed to draft rating criteria for topic {topic}")
@@ -168,7 +174,7 @@ class Rating(WithBriefing, LLMUsage):
                 )
             ),
             validator=_validator,
-            **self.prepend_sys_msg(kwargs),
+            **kwargs,
         )
 
     async def draft_rating_criteria(
@@ -200,7 +206,7 @@ class Rating(WithBriefing, LLMUsage):
             validator=lambda resp: set(out)
             if (out := JsonCapture.validate_with(resp, list, str, criteria_count)) is not None
             else out,
-            **self.prepend_sys_msg(kwargs),
+            **kwargs,
         )
 
     async def draft_rating_criteria_from_examples(
@@ -253,7 +259,7 @@ class Rating(WithBriefing, LLMUsage):
                 validator=lambda resp: JsonCapture.validate_with(
                     resp, target_type=list, elements_type=str, length=reasons_count
                 ),
-                **self.prepend_sys_msg(kwargs),
+                **kwargs,
             )
         )
         # extract certain mount of criteria from reasons according to their importance and frequency
@@ -310,9 +316,9 @@ class Rating(WithBriefing, LLMUsage):
                 for pair in windows
             ],
             validator=lambda resp: JsonCapture.validate_with(resp, target_type=float),
-            **self.prepend_sys_msg(kwargs),
+            **kwargs,
         )
-        weights = [1]
+        weights = [1.0]
         for rw in relative_weights:
             weights.append(weights[-1] * rw)
         total = sum(weights)
@@ -322,27 +328,66 @@ class Rating(WithBriefing, LLMUsage):
         self,
         topic: str,
         to_rate: List[str],
-        reasons_count: PositiveInt = 2,
-        criteria_count: PositiveInt = 5,
-        **kwargs: Unpack[ValidateKwargs],
+        criteria: Optional[Set[str]] = None,
+        weights: Optional[Dict[str, float]] = None,
+        manual: Optional[Dict[str, str]] = None,
+        **kwargs: Unpack[ValidateKwargs[List[Dict[str, float]]]],
     ) -> List[float]:
         """Calculates the composite scores for a list of items based on a given topic and criteria.
 
         Args:
             topic (str): The topic for the rating.
             to_rate (List[str]): A list of strings to be rated.
-            reasons_count (PositiveInt, optional): The number of reasons to extract from each pair of examples. Defaults to 2.
-            criteria_count (PositiveInt, optional): The number of criteria to draft. Defaults to 5.
+            criteria (Optional[Set[str]]): A set of criteria for the rating. Defaults to None.
+            weights (Optional[Dict[str, float]]): A dictionary of rating weights for each criterion. Defaults to None.
+            manual (Optional[Dict[str, str]]): A dictionary of manual ratings for each item. Defaults to None.
             **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
             List[float]: A list of composite scores for the items.
         """
-        criteria = await self.draft_rating_criteria_from_examples(
-            topic, to_rate, reasons_count, criteria_count, **kwargs
+        criteria = ok(
+            criteria
+            or await self.draft_rating_criteria_from_examples(topic, to_rate, **override_kwargs(kwargs, default=None))
+        )
+        weights = ok(
+            weights or await self.drafting_rating_weights_klee(topic, criteria, **override_kwargs(kwargs, default=None))
         )
-        weights = await self.drafting_rating_weights_klee(topic, criteria, **kwargs)
         logger.info(f"Criteria: {criteria}\nWeights: {weights}")
-        ratings_seq = await self.rate(to_rate, topic, criteria, **kwargs)
+        ratings_seq = await self.rate(to_rate, topic, criteria, manual, **kwargs)
 
         return [sum(ratings[c] * weights[c] for c in criteria) for ratings in ratings_seq]
+
+    @overload
+    async def best(self, candidates: List[str], k: int=1, **kwargs: Unpack[CompositeScoreKwargs]) -> List[str]: ...
+    @overload
+    async def best[T: Display](
+        self, candidates: List[T], k: int=1, **kwargs: Unpack[CompositeScoreKwargs]
+    ) -> List[T]: ...
+
+    async def best[T: Display](
+        self, candidates: List[str] | List[T], k: int=1, **kwargs: Unpack[CompositeScoreKwargs]
+    ) -> Optional[List[str] | List[T]]:
+        """Choose the best candidates from the list of candidates based on the composite score.
+
+        Args:
+            k (int): The number of best candidates to choose.
+            candidates (List[str]): A list of candidates to choose from.
+            **kwargs (CompositeScoreKwargs): Additional keyword arguments for the composite score calculation.
+
+        Returns:
+            List[str]: The best candidates.
+        """
+        if (leng := len(candidates)) == 0:
+            logger.warning(f"No candidates, got {leng}, return None.")
+            return None
+
+        if leng == 1:
+            logger.warning(f"Only one candidate, got {leng}, return it.")
+            return candidates
+        logger.info(f"Choose best {k} from {leng} candidates.")
+
+        rating_seq = await self.composite_score(
+            to_rate=[c.display() if isinstance(c, Display) else c for c in candidates], **kwargs
+        )
+        return [a[0] for a in sorted(zip(candidates, rating_seq, strict=True), key=lambda x: x[1], reverse=True)[:k]]  # pyright: ignore [reportReturnType]

fabricatio/capabilities/review.py

@@ -1,178 +1,16 @@
 """A module that provides functionality to rate tasks based on a rating manual and score range."""
 
-from typing import Dict, List, Optional, Self, Set, Unpack, cast
+from typing import Dict, Optional, Set, Unpack
 
 from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.capabilities.propose import Propose
 from fabricatio.capabilities.rating import Rating
 from fabricatio.config import configs
-from fabricatio.models.generic import Base, Display, ProposedAble, WithBriefing
+from fabricatio.models.extra.problem import Improvement
+from fabricatio.models.generic import Display, WithBriefing
 from fabricatio.models.kwargs_types import ReviewKwargs, ValidateKwargs
 from fabricatio.models.task import Task
-from fabricatio.models.utils import ask_edit
-from questionary import Choice, checkbox, text
-from questionary import print as q_print
-from rich import print as r_print
-
-
-class ProblemSolutions(Base):
-    """Represents a problem-solution pair identified during a review process.
-
-    This class encapsulates a single problem with its corresponding potential solutions,
-    providing a structured way to manage review findings.
-
-    Attributes:
-        problem (str): The problem statement identified during review.
-        solutions (List[str]): A collection of potential solutions to address the problem.
-    """
-
-    problem: str
-    """The problem identified in the review."""
-    solutions: List[str]
-    """A collection of potential solutions to address the problem."""
-
-    def update_problem(self, problem: str) -> Self:
-        """Update the problem description.
-
-        Args:
-            problem (str): The new problem description to replace the current one.
-
-        Returns:
-            Self: The current instance with updated problem description.
-        """
-        self.problem = problem
-        return self
-
-    def update_solutions(self, solutions: List[str]) -> Self:
-        """Update the list of potential solutions.
-
-        Args:
-            solutions (List[str]): The new collection of solutions to replace the current ones.
-
-        Returns:
-            Self: The current instance with updated solutions.
-        """
-        self.solutions = solutions
-        return self
-
-    async def edit_problem(self) -> Self:
-        """Interactively edit the problem description using a prompt.
-
-        Returns:
-            Self: The current instance with updated problem description.
-        """
-        self.problem = await text("Please edit the problem below:", default=self.problem).ask_async()
-        return self
-
-    async def edit_solutions(self) -> Self:
-        """Interactively edit the list of potential solutions using a prompt.
-
-        Returns:
-            Self: The current instance with updated solutions.
-        """
-        q_print(self.problem, style="bold cyan")
-        self.solutions = await ask_edit(self.solutions)
-        return self
-
-
-class ReviewResult[T](ProposedAble, Display):
-    """Represents the outcome of a review process with identified problems and solutions.
-
-    This class maintains a structured collection of problems found during a review,
-    their proposed solutions, and a reference to the original reviewed object.
-
-    Attributes:
-        review_topic (str): The subject or focus area of the review.
-        problem_solutions (List[ProblemSolutions]): Collection of problems identified
-            during review along with their potential solutions.
-
-    Type Parameters:
-        T: The type of the object being reviewed.
-    """
-
-    review_topic: str
-    """The subject or focus area of the review."""
-
-    problem_solutions: List[ProblemSolutions]
-    """Collection of problems identified during review along with their potential solutions."""
-
-    _ref: T
-    """Reference to the original object that was reviewed."""
-
-    def update_topic(self, topic: str) -> Self:
-        """Update the review topic.
-
-        Args:
-            topic (str): The new topic to be associated with this review.
-
-        Returns:
-            Self: The current instance with updated review topic.
-        """
-        self.review_topic = topic
-        return self
-
-    def update_ref[K](self, ref: K) -> "ReviewResult[K]":
-        """Update the reference to the reviewed object.
-
-        Args:
-            ref (K): The new reference object to be associated with this review.
-
-        Returns:
-            ReviewResult[K]: The current instance with updated reference type.
-        """
-        self._ref = ref  # pyright: ignore [reportAttributeAccessIssue]
-        return cast("ReviewResult[K]", self)
-
-    def deref(self) -> T:
-        """Retrieve the referenced object that was reviewed.
-
-        Returns:
-            T: The original object that was reviewed.
-        """
-        return self._ref
-
-    async def supervisor_check(self, check_solutions: bool = True) -> Self:
-        """Perform an interactive review session to filter problems and solutions.
-
-        Presents an interactive prompt allowing a supervisor to select which
-        problems (and optionally solutions) should be retained in the final review.
-
-        Args:
-            check_solutions (bool, optional): When True, also prompts for filtering
-                individual solutions for each retained problem. Defaults to False.
-
-        Returns:
-            Self: The current instance with filtered problems and solutions.
-        """
-        if isinstance(self._ref, str):
-            display = self._ref
-        elif isinstance(self._ref, WithBriefing):
-            display = self._ref.briefing
-        elif isinstance(self._ref, Display):
-            display = self._ref.display()
-        else:
-            raise TypeError(f"Unsupported type for review: {type(self._ref)}")
-        # Choose the problems to retain
-        r_print(display)
-        chosen_ones: List[ProblemSolutions] = await checkbox(
-            f"Please choose the problems you want to retain.(Default: retain all)\n\t`{self.review_topic}`",
-            choices=[Choice(p.problem, p, checked=True) for p in self.problem_solutions],
-        ).ask_async()
-        self.problem_solutions = [await p.edit_problem() for p in chosen_ones]
-        if not check_solutions:
-            return self
-
-        # Choose the solutions to retain
-        for to_exam in self.problem_solutions:
-            to_exam.update_solutions(
-                await checkbox(
-                    f"Please choose the solutions you want to retain.(Default: retain all)\n\t`{to_exam.problem}`",
-                    choices=[Choice(s, s, checked=True) for s in to_exam.solutions],
-                ).ask_async()
-            )
-            await to_exam.edit_solutions()
-
-        return self
+from fabricatio.utils import ok
 
 
 class Review(Rating, Propose):
@@ -185,7 +23,7 @@ class Review(Rating, Propose):
     appropriate topic and criteria.
     """
 
-    async def review_task[T](self, task: Task[T], **kwargs: Unpack[ReviewKwargs]) -> ReviewResult[Task[T]]:
+    async def review_task[T](self, task: Task[T], **kwargs: Unpack[ReviewKwargs]) -> Optional[Improvement]:
         """Review a task using specified review criteria.
 
         This method analyzes a task object to identify problems and propose solutions
@@ -197,10 +35,10 @@ class Review(Rating, Propose):
                 including topic and optional criteria.
 
         Returns:
-            ReviewResult[Task[T]]: A review result containing identified problems and proposed solutions,
+            Improvement[Task[T]]: A review result containing identified problems and proposed solutions,
                 with a reference to the original task.
         """
-        return cast("ReviewResult[Task[T]]", await self.review_obj(task, **kwargs))
+        return await self.review_obj(task, **kwargs)
 
     async def review_string(
         self,
@@ -208,8 +46,8 @@ class Review(Rating, Propose):
         topic: str,
         criteria: Optional[Set[str]] = None,
         rating_manual: Optional[Dict[str, str]] = None,
-        **kwargs: Unpack[ValidateKwargs[ReviewResult[str]]],
-    ) -> ReviewResult[str]:
+        **kwargs: Unpack[ValidateKwargs[Improvement]],
+    ) -> Optional[Improvement]:
         """Review a string based on specified topic and criteria.
 
         This method analyzes a text string to identify problems and propose solutions
@@ -224,7 +62,7 @@ class Review(Rating, Propose):
             **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
-            ReviewResult[str]: A review result containing identified problems and proposed solutions,
+            Improvement: A review result containing identified problems and proposed solutions,
                 with a reference to the original text.
         """
         default = None
@@ -232,28 +70,21 @@ class Review(Rating, Propose):
             # this `default` is the default for the `propose` method
             default = kwargs.pop("default")
 
-        criteria = criteria or (await self.draft_rating_criteria(topic, **kwargs))
-        if not criteria:
-            raise ValueError("No criteria provided for review.")
+        criteria = ok(criteria or (await self.draft_rating_criteria(topic, **kwargs))," No criteria could be use.")
         manual = rating_manual or await self.draft_rating_manual(topic, criteria, **kwargs)
 
         if default is not None:
             kwargs["default"] = default
-        res = await self.propose(
-            ReviewResult,
+        return await self.propose(
+            Improvement,
             TEMPLATE_MANAGER.render_template(
                 configs.templates.review_string_template,
                 {"text": input_text, "topic": topic, "criteria_manual": manual},
             ),
             **kwargs,
         )
-        if not res:
-            raise ValueError("Failed to generate review result.")
-        return res.update_ref(input_text).update_topic(topic)
 
-    async def review_obj[M: (Display, WithBriefing)](
-        self, obj: M, **kwargs: Unpack[ReviewKwargs[ReviewResult[str]]]
-    ) -> ReviewResult[M]:
+    async def review_obj[M: (Display, WithBriefing)](self, obj: M, **kwargs: Unpack[ReviewKwargs[Improvement]]) -> Optional[Improvement]:
         """Review an object that implements Display or WithBriefing interface.
 
         This method extracts displayable text from the object and performs a review
@@ -268,14 +99,14 @@ class Review(Rating, Propose):
             TypeError: If the object does not implement Display or WithBriefing.
 
         Returns:
-            ReviewResult[M]: A review result containing identified problems and proposed solutions,
+            Improvement: A review result containing identified problems and proposed solutions,
                 with a reference to the original object.
         """
         if isinstance(obj, Display):
-            text = obj.display()
+            text_to_review = obj.display()
         elif isinstance(obj, WithBriefing):
-            text = obj.briefing
+            text_to_review = obj.briefing
         else:
             raise TypeError(f"Unsupported type for review: {type(obj)}")
 
-        return (await self.review_string(text, **kwargs)).update_ref(obj)
+        return await self.review_string(text_to_review, **kwargs)

fabricatio/capabilities/task.py

@@ -1,14 +1,13 @@
 """A module for the task capabilities of the Fabricatio library."""
 
 from types import CodeType
-from typing import Any, Dict, List, Optional, Tuple, Unpack, cast
+from typing import Any, Dict, List, Optional, Tuple, Unpack
 
 import orjson
 from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.capabilities.propose import Propose
 from fabricatio.config import configs
 from fabricatio.journal import logger
-from fabricatio.models.generic import WithBriefing
 from fabricatio.models.kwargs_types import ChooseKwargs, ValidateKwargs
 from fabricatio.models.task import Task
 from fabricatio.models.tool import Tool, ToolExecutor
@@ -16,7 +15,7 @@ from fabricatio.models.usages import ToolBoxUsage
 from fabricatio.parser import JsonCapture, PythonCapture
 
 
-class ProposeTask(WithBriefing, Propose):
+class ProposeTask(Propose):
     """A class that proposes a task based on a prompt."""
 
     async def propose_task[T](
@@ -34,13 +33,13 @@ class ProposeTask(WithBriefing, Propose):
             A Task object based on the proposal result.
         """
         if not prompt:
-            logger.error(err := f"{self.name}: Prompt must be provided.")
+            logger.error(err := "Prompt must be provided.")
             raise ValueError(err)
 
-        return await self.propose(Task, prompt, **self.prepend_sys_msg(cast("Dict[str, Any]", kwargs)))
+        return await self.propose(Task, prompt, **kwargs)
 
 
-class HandleTask(WithBriefing, ToolBoxUsage):
+class HandleTask(ToolBoxUsage):
     """A class that handles a task based on a task object."""
 
     async def draft_tool_usage_code(
@@ -54,7 +53,7 @@ class HandleTask(WithBriefing, ToolBoxUsage):
         logger.info(f"Drafting tool usage code for task: {task.briefing}")
 
         if not tools:
-            err = f"{self.name}: Tools must be provided to draft the tool usage code."
+            err = "Tools must be provided to draft the tool usage code."
             logger.error(err)
             raise ValueError(err)
 
@@ -81,7 +80,7 @@ class HandleTask(WithBriefing, ToolBoxUsage):
         return await self.aask_validate(
             question=q,
             validator=_validator,
-            **self.prepend_sys_msg(cast("Dict[str, Any]", kwargs)),
+            **kwargs,
         )
 
     async def handle_fine_grind(
@@ -96,7 +95,7 @@ class HandleTask(WithBriefing, ToolBoxUsage):
         logger.info(f"Handling task: \n{task.briefing}")
 
         tools = await self.gather_tools_fine_grind(task, box_choose_kwargs, tool_choose_kwargs)
-        logger.info(f"{self.name} have gathered {[t.name for t in tools]}")
+        logger.info(f"Gathered {[t.name for t in tools]}")
 
         if tools and (pack := await self.draft_tool_usage_code(task, tools, data, **kwargs)):
             executor = ToolExecutor(candidates=tools, data=data)

fabricatio/config.py

@@ -229,15 +229,23 @@ class TemplateConfig(BaseModel):
     generic_string_template: str = Field(default="generic_string")
     """The name of the generic string template which will be used to review a string."""
 
-    correct_template: str = Field(default="correct")
-    """The name of the correct template which will be used to correct a string."""
-
     co_validation_template: str = Field(default="co_validation")
     """The name of the co-validation template which will be used to co-validate a string."""
 
     as_prompt_template: str = Field(default="as_prompt")
     """The name of the as prompt template which will be used to convert a string to a prompt."""
 
+    check_string_template: str = Field(default="check_string")
+    """The name of the check string template which will be used to check a string."""
+
+    ruleset_requirement_breakdown_template: str = Field(default="ruleset_requirement_breakdown")
+    """The name of the ruleset requirement breakdown template which will be used to breakdown a ruleset requirement."""
+
+    fix_troubled_obj_template: str = Field(default="fix_troubled_obj")
+    """The name of the fix troubled object template which will be used to fix a troubled object."""
+
+    fix_troubled_string_template: str = Field(default="fix_troubled_string")
+    """The name of the fix troubled string template which will be used to fix a troubled string."""
 
 class MagikaConfig(BaseModel):
     """Magika configuration class."""

fabricatio/models/action.py

@@ -9,16 +9,14 @@ from abc import abstractmethod
 from asyncio import Queue, create_task
 from typing import Any, Dict, Self, Tuple, Type, Union, final
 
-from fabricatio.capabilities.correct import Correct
-from fabricatio.capabilities.task import HandleTask, ProposeTask
 from fabricatio.journal import logger
 from fabricatio.models.generic import WithBriefing
 from fabricatio.models.task import Task
-from fabricatio.models.usages import ToolBoxUsage
+from fabricatio.models.usages import LLMUsage, ToolBoxUsage
 from pydantic import Field, PrivateAttr
 
 
-class Action(HandleTask, ProposeTask, Correct):
+class Action(WithBriefing, LLMUsage):
     """Class that represents an action to be executed in a workflow.
 
     Actions are the atomic units of work in a workflow. Each action performs
@@ -98,13 +96,18 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
     a shared context between them and handling task lifecycle events.
     """
 
+    description: str = ""
+    """The description of the workflow, which describes the workflow's purpose and requirements."""
+
     _context: Queue[Dict[str, Any]] = PrivateAttr(default_factory=lambda: Queue(maxsize=1))
     """Queue for storing the workflow execution context."""
 
     _instances: Tuple[Action, ...] = PrivateAttr(default_factory=tuple)
     """Instantiated action objects to be executed in this workflow."""
 
-    steps: Tuple[Union[Type[Action], Action], ...] = Field(frozen=True,)
+    steps: Tuple[Union[Type[Action], Action], ...] = Field(
+        frozen=True,
+    )
     """The sequence of actions to be executed, can be action classes or instances."""
 
     task_input_key: str = Field(default="task_input")

fabricatio/models/adv_kwargs_types.py

@@ -0,0 +1,25 @@
+"""A module containing kwargs types for content correction and checking operations."""
+from fabricatio.models.extra.problem import Improvement
+from fabricatio.models.extra.rule import RuleSet
+from fabricatio.models.generic import SketchedAble
+from fabricatio.models.kwargs_types import ReferencedKwargs
+
+
+class CorrectKwargs[T: SketchedAble](ReferencedKwargs[T], total=False):
+    """Arguments for content correction operations.
+
+    Extends GenerateKwargs with parameters for correcting content based on
+    specific criteria and templates.
+    """
+
+    improvement: Improvement
+
+
+class CheckKwargs(ReferencedKwargs[Improvement], total=False):
+    """Arguments for content checking operations.
+
+    Extends GenerateKwargs with parameters for checking content against
+    specific criteria and templates.
+    """
+
+    ruleset: RuleSet

fabricatio/models/extra/advanced_judge.py

@@ -2,23 +2,26 @@
 
 from typing import List
 
-from fabricatio.models.generic import ProposedAble
+from fabricatio.models.generic import Display, ProposedAble
 
 
-class JudgeMent(ProposedAble):
+class JudgeMent(ProposedAble, Display):
     """Represents a judgment result containing supporting/denying evidence and final verdict.
 
-    The class stores both affirmative and denies evidence lists along with the final boolean judgment.
+    The class stores both affirmative and denies evidence, truth and reasons lists along with the final boolean judgment.
     """
 
-    affirm_evidence: List[str]
-    """List of evidence supporting the affirmation."""
+    issue_to_judge: str
+    """The issue to be judged"""
 
     deny_evidence: List[str]
-    """List of evidence supporting the denial."""
+    """List of clues supporting the denial."""
+
+    affirm_evidence: List[str]
+    """List of clues supporting the affirmation."""
 
     final_judgement: bool
-    """The final judgment made according to all extracted evidence."""
+    """The final judgment made according to all extracted clues."""
 
     def __bool__(self) -> bool:
         """Return the final judgment value.