fabricatio 0.2.6.dev4__cp312-cp312-manylinux_2_34_x86_64.whl → 0.2.6.dev5__cp312-cp312-manylinux_2_34_x86_64.whl

fabricatio/capabilities/covalidate.py

@@ -0,0 +1,160 @@
+"""Co-validation capability for LLMs."""
+
+from asyncio import gather
+from typing import Callable, List, Optional, Union, Unpack, overload
+
+from fabricatio import TEMPLATE_MANAGER
+from fabricatio.config import configs
+from fabricatio.journal import logger
+from fabricatio.models.kwargs_types import GenerateKwargs
+from fabricatio.models.usages import LLMUsage
+
+
+class CoValidate(LLMUsage):
+    """Class that represents a co-validation capability using multiple LLMs.
+
+    This class provides methods to validate responses by attempting multiple approaches:
+    1. Using the primary LLM to generate a response
+    2. Using a secondary (co-) model to refine responses that fail validation
+    3. Trying multiple times if needed
+    """
+
+    @overload
+    async def aask_covalidate[T](
+        self,
+        question: str,
+        validator: Callable[[str], T | None],
+        co_model: Optional[str] = None,
+        co_temperature: Optional[float] = None,
+        co_top_p: Optional[float] = None,
+        co_max_tokens: Optional[int] = None,
+        max_validations: int = 2,
+        default: None = None,
+        **kwargs: Unpack[GenerateKwargs],
+    ) -> T | None: ...
+
+    @overload
+    async def aask_covalidate[T](
+        self,
+        question: str,
+        validator: Callable[[str], T | None],
+        co_model: Optional[str] = None,
+        co_temperature: Optional[float] = None,
+        co_top_p: Optional[float] = None,
+        co_max_tokens: Optional[int] = None,
+        max_validations: int = 2,
+        default: T = ...,
+        **kwargs: Unpack[GenerateKwargs],
+    ) -> T: ...
+
+    @overload
+    async def aask_covalidate[T](
+        self,
+        question: List[str],
+        validator: Callable[[str], T | None],
+        co_model: Optional[str] = None,
+        co_temperature: Optional[float] = None,
+        co_top_p: Optional[float] = None,
+        co_max_tokens: Optional[int] = None,
+        max_validations: int = 2,
+        default: None = None,
+        **kwargs: Unpack[GenerateKwargs],
+    ) -> List[T | None]: ...
+
+    @overload
+    async def aask_covalidate[T](
+        self,
+        question: List[str],
+        validator: Callable[[str], T | None],
+        co_model: Optional[str] = None,
+        co_temperature: Optional[float] = None,
+        co_top_p: Optional[float] = None,
+        co_max_tokens: Optional[int] = None,
+        max_validations: int = 2,
+        default: T = ...,
+        **kwargs: Unpack[GenerateKwargs],
+    ) -> List[T]: ...
+
+    async def aask_covalidate[T](
+        self,
+        question: Union[str, List[str]],
+        validator: Callable[[str], T | None],
+        co_model: Optional[str] = None,
+        co_temperature: Optional[float] = None,
+        co_top_p: Optional[float] = None,
+        co_max_tokens: Optional[int] = None,
+        max_validations: int = 2,
+        default: Optional[T] = None,
+        **kwargs: Unpack[GenerateKwargs],
+    ) -> Union[T | None, List[T | None]]:
+        """Ask the LLM with co-validation to obtain a validated response.
+
+        This method attempts to generate a response that passes validation using two approaches:
+        1. First, it asks the primary LLM using the original question
+        2. If validation fails, it uses a secondary (co-) model with a template to improve the response
+        3. The process repeats up to max_validations times
+
+        Args:
+            question: String question or list of questions to ask
+            validator: Function that validates responses, returns result or None if invalid
+            co_model: Optional model name for the co-validator
+            co_temperature: Optional temperature setting for the co-validator
+            co_top_p: Optional top_p setting for the co-validator
+            co_max_tokens: Optional maximum tokens for the co-validator response
+            max_validations: Maximum number of validation attempts
+            default: Default value to return if validation fails
+            **kwargs: Additional keyword arguments passed to aask method
+
+        Returns:
+            The validated result (T) or default if validation fails.
+            If input is a list of questions, returns a list of results.
+        """
+
+        async def validate_single_question(q: str) -> Optional[T]:
+            """Process a single question with validation attempts."""
+            validation_kwargs = kwargs.copy()
+
+            for lap in range(max_validations):
+                try:
+                    # First attempt: direct question to primary model
+                    response = await self.aask(question=q, **validation_kwargs)
+                    if response and (validated := validator(response)):
+                        logger.debug(f"Successfully validated the primary response at {lap}th attempt.")
+                        return validated
+
+                    # Second attempt: use co-model with validation template
+                    co_prompt = TEMPLATE_MANAGER.render_template(
+                        configs.templates.co_validation_template,
+                        {"original_q": q, "original_a": response},
+                    )
+                    co_response = await self.aask(
+                        question=co_prompt,
+                        model=co_model,
+                        temperature=co_temperature,
+                        top_p=co_top_p,
+                        max_tokens=co_max_tokens,
+                    )
+
+                    if co_response and (validated := validator(co_response)):
+                        logger.debug(f"Successfully validated the co-response at {lap}th attempt.")
+                        return validated
+
+                except Exception as e:  # noqa: BLE001
+                    logger.error(f"Error during validation: \n{e}")
+                    break
+
+                # Disable caching for subsequent attempts
+                if not validation_kwargs.get("no_cache"):
+                    validation_kwargs["no_cache"] = True
+                    logger.debug("Disabled cache for the next attempt")
+
+            if default is None:
+                logger.error(f"Failed to validate the response after {max_validations} attempts.")
+            return default
+
+        # Handle single question or list of questions
+        if isinstance(question, str):
+            return await validate_single_question(question)
+
+        # Process multiple questions in parallel
+        return await gather(*[validate_single_question(q) for q in question])

fabricatio/capabilities/task.py

@@ -84,7 +84,7 @@ class HandleTask(WithBriefing, ToolBoxUsage):
             **self.prepend(cast(Dict[str, Any], kwargs)),
         )
 
-    async def handle_fin_grind(
+    async def handle_fine_grind(
         self,
         task: Task,
         data: Dict[str, Any],
@@ -110,4 +110,4 @@ class HandleTask(WithBriefing, ToolBoxUsage):
 
     async def handle(self, task: Task, data: Dict[str, Any], **kwargs: Unpack[ValidateKwargs]) -> Optional[Tuple]:
         """Asynchronously handles a task based on a given task object and parameters."""
-        return await self.handle_fin_grind(task, data, **kwargs)
+        return await self.handle_fine_grind(task, data, **kwargs)

fabricatio/config.py

@@ -48,37 +48,37 @@ class LLMConfig(BaseModel):
     """
 
     model_config = ConfigDict(use_attribute_docstrings=True)
-    api_endpoint: HttpUrl = Field(default=HttpUrl("https://api.openai.com"))
+    api_endpoint: Optional[HttpUrl] = Field(default=HttpUrl("https://api.openai.com"))
     """OpenAI API Endpoint."""
 
-    api_key: SecretStr = Field(default=SecretStr(""))
+    api_key: Optional[SecretStr] = Field(default=SecretStr("sk-setyourkey"))
     """OpenAI API key. Empty by default for security reasons, should be set before use."""
 
-    timeout: PositiveInt = Field(default=300)
+    timeout: Optional[PositiveInt] = Field(default=300)
     """The timeout of the LLM model in seconds. Default is 300 seconds as per request."""
 
-    max_retries: PositiveInt = Field(default=3)
+    max_retries: Optional[PositiveInt] = Field(default=3)
     """The maximum number of retries. Default is 3 retries."""
 
-    model: str = Field(default="gpt-3.5-turbo")
+    model: Optional[str] = Field(default="gpt-3.5-turbo")
     """The LLM model name. Set to 'gpt-3.5-turbo' as per request."""
 
-    temperature: NonNegativeFloat = Field(default=1.0)
+    temperature: Optional[NonNegativeFloat] = Field(default=1.0)
     """The temperature of the LLM model. Controls randomness in generation. Set to 1.0 as per request."""
 
-    stop_sign: str | List[str] = Field(default_factory=lambda: ["\n\n\n", "User:"])
+    stop_sign: Optional[str | List[str]] = Field(default="")
     """The stop sign of the LLM model. No default stop sign specified."""
 
-    top_p: NonNegativeFloat = Field(default=0.35)
+    top_p: Optional[NonNegativeFloat] = Field(default=0.35)
     """The top p of the LLM model. Controls diversity via nucleus sampling. Set to 0.35 as per request."""
 
-    generation_count: PositiveInt = Field(default=1)
+    generation_count: Optional[PositiveInt] = Field(default=1)
     """The number of generations to generate. Default is 1."""
 
-    stream: bool = Field(default=False)
+    stream: Optional[bool] = Field(default=False)
     """Whether to stream the LLM model's response. Default is False."""
 
-    max_tokens: PositiveInt = Field(default=8192)
+    max_tokens: Optional[PositiveInt] = Field(default=8192)
     """The maximum number of tokens to generate. Set to 8192 as per request."""
 
     rpm: Optional[PositiveInt] = Field(default=100)
@@ -93,7 +93,7 @@ class EmbeddingConfig(BaseModel):
 
     model_config = ConfigDict(use_attribute_docstrings=True)
 
-    model: str = Field(default="text-embedding-ada-002")
+    model: Optional[str] = Field(default="text-embedding-ada-002")
     """The embedding model name. """
 
     dimensions: Optional[PositiveInt] = Field(default=None)
@@ -102,10 +102,10 @@ class EmbeddingConfig(BaseModel):
     timeout: Optional[PositiveInt] = Field(default=None)
     """The timeout of the embedding model in seconds."""
 
-    max_sequence_length: PositiveInt = Field(default=8192)
+    max_sequence_length: Optional[PositiveInt] = Field(default=8192)
     """The maximum sequence length of the embedding model. Default is 8192 as per request."""
 
-    caching: bool = Field(default=False)
+    caching: Optional[bool] = Field(default=False)
     """Whether to cache the embedding. Default is False."""
 
     api_endpoint: Optional[HttpUrl] = None
@@ -232,6 +232,9 @@ class TemplateConfig(BaseModel):
     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."""
+
 
 class MagikaConfig(BaseModel):
     """Magika configuration class."""
@@ -272,7 +275,7 @@ class RagConfig(BaseModel):
 
     model_config = ConfigDict(use_attribute_docstrings=True)
 
-    milvus_uri: HttpUrl = Field(default=HttpUrl("http://localhost:19530"))
+    milvus_uri: Optional[HttpUrl] = Field(default=HttpUrl("http://localhost:19530"))
     """The URI of the Milvus server."""
     milvus_timeout: Optional[PositiveFloat] = Field(default=None)
     """The timeout of the Milvus server."""

fabricatio/models/action.py

@@ -1,4 +1,8 @@
-"""Module that contains the classes for actions and workflows."""
+"""Module that contains the classes for actions and workflows.
+
+This module defines the Action and WorkFlow classes, which are used for
+creating and executing sequences of actions in a task-based context.
+"""
 
 import traceback
 from abc import abstractmethod
@@ -6,6 +10,7 @@ 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.covalidate import CoValidate
 from fabricatio.capabilities.task import HandleTask, ProposeTask
 from fabricatio.journal import logger
 from fabricatio.models.generic import WithBriefing
@@ -14,21 +19,28 @@ from fabricatio.models.usages import ToolBoxUsage
 from pydantic import Field, PrivateAttr
 
 
-class Action(HandleTask, ProposeTask, Correct):
-    """Class that represents an action to be executed in a workflow."""
+class Action(HandleTask, ProposeTask, Correct, CoValidate):
+    """Class that represents an action to be executed in a workflow.
+
+    Actions are the atomic units of work in a workflow. Each action performs
+    a specific operation and can modify the shared context data.
+    """
 
     name: str = Field(default="")
     """The name of the action."""
+
     description: str = Field(default="")
     """The description of the action."""
+
     personality: str = Field(default="")
-    """The personality of whom the action belongs to."""
+    """The personality traits or context for the action executor."""
+
     output_key: str = Field(default="")
-    """The key of the output data."""
+    """The key used to store this action's output in the context dictionary."""
 
     @final
     def model_post_init(self, __context: Any) -> None:
-        """Initialize the action by setting the name if not provided.
+        """Initialize the action by setting default name and description if not provided.
 
         Args:
             __context: The context to be used for initialization.
@@ -38,121 +50,170 @@ class Action(HandleTask, ProposeTask, Correct):
 
     @abstractmethod
     async def _execute(self, **cxt) -> Any:
-        """Execute the action with the provided arguments.
+        """Execute the action logic with the provided context arguments.
+
+        This method must be implemented by subclasses to define the actual behavior.
 
         Args:
             **cxt: The context dictionary containing input and output data.
 
         Returns:
-            The result of the action execution.
+            Any: The result of the action execution.
         """
         pass
 
     @final
     async def act(self, cxt: Dict[str, Any]) -> Dict[str, Any]:
-        """Perform the action by executing it and setting the output data.
+        """Perform the action and update the context with results.
 
         Args:
             cxt: The context dictionary containing input and output data.
+
+        Returns:
+            Dict[str, Any]: The updated context dictionary.
         """
         ret = await self._execute(**cxt)
+
         if self.output_key:
             logger.debug(f"Setting output: {self.output_key}")
             cxt[self.output_key] = ret
+
         return cxt
 
     @property
     def briefing(self) -> str:
-        """Return a brief description of the action."""
+        """Return a formatted description of the action including personality context if available.
+
+        Returns:
+            str: Formatted briefing text with personality and action description.
+        """
         if self.personality:
             return f"## Your personality: \n{self.personality}\n# The action you are going to perform: \n{super().briefing}"
         return f"# The action you are going to perform: \n{super().briefing}"
 
 
 class WorkFlow(WithBriefing, ToolBoxUsage):
-    """Class that represents a workflow to be executed in a task."""
+    """Class that represents a sequence of actions to be executed for a task.
+
+    A workflow manages the execution of multiple actions in sequence, passing
+    a shared context between them and handling task lifecycle events.
+    """
 
     _context: Queue[Dict[str, Any]] = PrivateAttr(default_factory=lambda: Queue(maxsize=1))
-    """ The context dictionary to be used for workflow execution."""
+    """Queue for storing the workflow execution context."""
 
     _instances: Tuple[Action, ...] = PrivateAttr(default_factory=tuple)
-    """ The instances of the workflow steps."""
+    """Instantiated action objects to be executed in this workflow."""
 
     steps: Tuple[Union[Type[Action], Action], ...] = Field(...)
-    """ The steps to be executed in the workflow, actions or action classes."""
+    """The sequence of actions to be executed, can be action classes or instances."""
+
     task_input_key: str = Field(default="task_input")
-    """ The key of the task input data."""
+    """Key used to store the input task in the context dictionary."""
+
     task_output_key: str = Field(default="task_output")
-    """ The key of the task output data."""
+    """Key used to extract the final result from the context dictionary."""
+
     extra_init_context: Dict[str, Any] = Field(default_factory=dict, frozen=True)
-    """ The extra context dictionary to be used for workflow initialization."""
+    """Additional initial context values to be included at workflow start."""
 
     def model_post_init(self, __context: Any) -> None:
-        """Initialize the workflow by setting fallbacks for each step.
+        """Initialize the workflow by instantiating any action classes.
 
         Args:
             __context: The context to be used for initialization.
         """
-        temp = []
-        for step in self.steps:
-            temp.append(step if isinstance(step, Action) else step())
-        self._instances = tuple(temp)
+        # Convert any action classes to instances
+        self._instances = tuple(step if isinstance(step, Action) else step() for step in self.steps)
 
     def inject_personality(self, personality: str) -> Self:
-        """Inject the personality of the workflow.
+        """Set the personality for all actions that don't have one defined.
 
         Args:
-            personality: The personality to be injected.
+            personality: The personality text to inject.
 
         Returns:
-            Self: The instance of the workflow with the injected personality.
+            Self: The workflow instance for method chaining.
         """
-        for a in filter(lambda action: not action.personality, self._instances):
-            a.personality = personality
+        for action in filter(lambda a: not a.personality, self._instances):
+            action.personality = personality
         return self
 
     async def serve(self, task: Task) -> None:
-        """Serve the task by executing the workflow steps.
+        """Execute the workflow to fulfill the given task.
+
+        This method manages the complete lifecycle of processing a task through
+        the workflow's sequence of actions.
 
         Args:
-            task: The task to be served.
+            task: The task to be processed.
         """
         await task.start()
         await self._init_context(task)
+
         current_action = None
         try:
+            # Process each action in sequence
             for step in self._instances:
-                logger.debug(f"Executing step: {(current_action := step.name)}")
-                act_task = create_task(step.act(await self._context.get()))
+                current_action = step.name
+                logger.debug(f"Executing step: {current_action}")
+
+                # Get current context and execute action
+                context = await self._context.get()
+                act_task = create_task(step.act(context))
+
+                # Handle task cancellation
                 if task.is_cancelled():
                     act_task.cancel(f"Cancelled by task: {task.name}")
                     break
+
+                # Update context with modified values
                 modified_ctx = await act_task
                 await self._context.put(modified_ctx)
+
             logger.info(f"Finished executing workflow: {self.name}")
 
-            if self.task_output_key not in (final_ctx := await self._context.get()):
+            # Get final context and extract result
+            final_ctx = await self._context.get()
+            result = final_ctx.get(self.task_output_key)
+
+            if self.task_output_key not in final_ctx:
                 logger.warning(
-                    f"Task output key: {self.task_output_key} not found in the context, None will be returned. You can check if `Action.output_key` is set the same as `WorkFlow.task_output_key`."
+                    f"Task output key: {self.task_output_key} not found in the context, None will be returned. "
+                    f"You can check if `Action.output_key` is set the same as `WorkFlow.task_output_key`."
                 )
 
-            await task.finish(final_ctx.get(self.task_output_key, None))
+            await task.finish(result)
+
         except RuntimeError as e:
-            logger.error(f"Error during task: {current_action} execution: {e}")  # Log the exception
-            logger.error(traceback.format_exc())  # Add this line to log the traceback
-            await task.fail()  # Mark the task as failed
+            logger.error(f"Error during task: {current_action} execution: {e}")
+            logger.error(traceback.format_exc())
+            await task.fail()
 
     async def _init_context[T](self, task: Task[T]) -> None:
-        """Initialize the context dictionary for workflow execution."""
+        """Initialize the context dictionary for workflow execution.
+
+        Args:
+            task: The task being served by this workflow.
+        """
         logger.debug(f"Initializing context for workflow: {self.name}")
-        await self._context.put({self.task_input_key: task, **dict(self.extra_init_context)})
+        initial_context = {self.task_input_key: task, **dict(self.extra_init_context)}
+        await self._context.put(initial_context)
 
     def steps_fallback_to_self(self) -> Self:
-        """Set the fallback for each step to the workflow itself."""
+        """Configure all steps to use this workflow's configuration as fallback.
+
+        Returns:
+            Self: The workflow instance for method chaining.
+        """
         self.hold_to(self._instances)
         return self
 
     def steps_supply_tools_from_self(self) -> Self:
-        """Supply the tools from the workflow to each step."""
+        """Provide this workflow's tools to all steps in the workflow.
+
+        Returns:
+            Self: The workflow instance for method chaining.
+        """
         self.provide_tools_to(self._instances)
         return self

fabricatio/models/extra.py

@@ -26,7 +26,7 @@ class Figure(Base):
     """The caption accompanying the figure, summarizing its main points and academic value."""
 
     figure_path: str
-    """The file path to the figure"""
+    """The exact path to the figure file, must exist in the file system, SHALL never be a PLACEHOLDER."""
 
 
 class Highlightings(Base):

fabricatio/models/role.py

@@ -1,8 +1,9 @@
-"""Module that contains the Role class."""
+"""Module that contains the Role class for managing workflows and their event registrations."""
 
 from typing import Any, Self, Set
 
 from fabricatio.capabilities.correct import Correct
+from fabricatio.capabilities.covalidate import CoValidate
 from fabricatio.capabilities.task import HandleTask, ProposeTask
 from fabricatio.core import env
 from fabricatio.journal import logger
@@ -12,20 +13,37 @@ from fabricatio.models.tool import ToolBox
 from pydantic import Field
 
 
-class Role(ProposeTask, HandleTask, Correct):
-    """Class that represents a role with a registry of events and workflows."""
+class Role(ProposeTask, HandleTask, Correct, CoValidate):
+    """Class that represents a role with a registry of events and workflows.
+
+    A Role serves as a container for workflows, managing their registration to events
+    and providing them with shared configuration like tools and personality.
+
+    Attributes:
+        registry: Mapping of events to workflows that handle them
+        toolboxes: Set of toolboxes available to this role and its workflows
+    """
 
     registry: dict[Event | str, WorkFlow] = Field(default_factory=dict)
-    """ The registry of events and workflows."""
+    """The registry of events and workflows."""
 
     toolboxes: Set[ToolBox] = Field(default_factory=set)
+    """Collection of tools available to this role."""
 
     def model_post_init(self, __context: Any) -> None:
-        """Register the workflows in the role to the event bus."""
+        """Initialize the role by resolving configurations and registering workflows.
+
+        Args:
+            __context: The context used for initialization
+        """
         self.resolve_configuration().register_workflows()
 
     def register_workflows(self) -> Self:
-        """Register the workflows in the role to the event bus."""
+        """Register each workflow in the registry to its corresponding event in the event bus.
+
+        Returns:
+            Self: The role instance for method chaining
+        """
         for event, workflow in self.registry.items():
             logger.debug(
                 f"Registering workflow: `{workflow.name}` for event: `{Event.instantiate_from(event).collapse()}`"
@@ -34,7 +52,14 @@ class Role(ProposeTask, HandleTask, Correct):
         return self
 
     def resolve_configuration(self) -> Self:
-        """Resolve the configuration of the role."""
+        """Apply role-level configuration to all workflows in the registry.
+
+        This includes setting up fallback configurations, injecting personality traits,
+        and providing tool access to workflows and their steps.
+
+        Returns:
+            Self: The role instance for method chaining
+        """
         for workflow in self.registry.values():
             logger.debug(f"Resolving config for workflow: `{workflow.name}`")
             (

fabricatio/models/usages.py

@@ -213,7 +213,7 @@ class LLMUsage(ScopedConfig):
         self,
         question: str,
         validator: Callable[[str], T | None],
-        default: T,
+        default: T = ...,
         max_validations: PositiveInt = 2,
         **kwargs: Unpack[GenerateKwargs],
     ) -> T: ...
@@ -222,7 +222,7 @@ class LLMUsage(ScopedConfig):
         self,
         question: List[str],
         validator: Callable[[str], T | None],
-        default: T,
+        default: T = ...,
         max_validations: PositiveInt = 2,
         **kwargs: Unpack[GenerateKwargs],
     ) -> List[T]: ...
@@ -277,8 +277,9 @@ class LLMUsage(ScopedConfig):
                 except Exception as e:  # noqa: BLE001
                     logger.error(f"Error during validation: \n{e}")
                     break
-                kwargs["no_cache"] = True
-                logger.debug("Closed the cache for the next attempt")
+                if not kwargs.get("no_cache"):
+                    kwargs["no_cache"] = True
+                    logger.debug("Closed the cache for the next attempt")
             if default is None:
                 logger.error(f"Failed to validate the response after {max_validations} attempts.")
             return default

{fabricatio-0.2.6.dev4.dist-info → fabricatio-0.2.6.dev5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.6.dev4
+Version: 0.2.6.dev5
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12

{fabricatio-0.2.6.dev4.dist-info → fabricatio-0.2.6.dev5.dist-info}/RECORD

@@ -1,18 +1,18 @@
-fabricatio-0.2.6.dev4.dist-info/METADATA,sha256=x15F4qzX0H3HfdNwW2hgbB5SVkkKWumhDAgpM1evTzE,13693
-fabricatio-0.2.6.dev4.dist-info/WHEEL,sha256=RIvmwLDYujv60MYBx2jxyP4vdn1DD7X0kBgz1TQvZuc,108
-fabricatio-0.2.6.dev4.dist-info/licenses/LICENSE,sha256=yDZaTLnOi03bi3Dk6f5IjhLUc5old2yOsihHWU0z-i0,1067
+fabricatio-0.2.6.dev5.dist-info/METADATA,sha256=fDyrjLOMA7hb-NFEGY3jM5sMjkDDfHQ-PIYRHqjQvO0,13693
+fabricatio-0.2.6.dev5.dist-info/WHEEL,sha256=RIvmwLDYujv60MYBx2jxyP4vdn1DD7X0kBgz1TQvZuc,108
+fabricatio-0.2.6.dev5.dist-info/licenses/LICENSE,sha256=yDZaTLnOi03bi3Dk6f5IjhLUc5old2yOsihHWU0z-i0,1067
 fabricatio/decorators.py,sha256=cJHsxxbnMhc4SzPl4454CPLuDP3H0qbTrzV_U2rLPrs,6372
 fabricatio/core.py,sha256=MaEKZ6DDmbdScAY-7F1gwGA6fr7ADX6Mz5rNVi2msFA,6277
 fabricatio/models/generic.py,sha256=WxT4KBGGZTpqGPSPVwD5mkmhYBjxggZ7n-HKi-Hed4M,13619
 fabricatio/models/tool.py,sha256=ATwbOyvOTzrfAKcbOmCqdG3je4-T5jrM6FIw4cDPRDY,6863
-fabricatio/models/role.py,sha256=pQUHj5jx5OqbbDufhvoqqF72R0dJ6aIrREieASe96Ls,1794
-fabricatio/models/extra.py,sha256=wOEJueEwSCfcnCvgITnl0lM8IrWwmtxmksjtBcYueKk,7151
+fabricatio/models/role.py,sha256=m-orT8xtiI9t0MvCzwVnfnPXPoocS2z6Twaim_nSmNE,2780
+fabricatio/models/extra.py,sha256=2TyrlYOfTe-Z-9eZxV8K7lXQLHz3y5Ze97JYZnnqg9U,7219
 fabricatio/models/kwargs_types.py,sha256=7MjoTtGfSUx4jws_DlvK2ud7au6Y2z50Umr3PFtmSTc,4435
 fabricatio/models/utils.py,sha256=KmsTQcBCTYgnsZz7U1ECSfLRdswWPkKtGg8mBMaXrwA,4850
-fabricatio/models/usages.py,sha256=DiCiS1_YsHyB1-cQJdevyVxAn5_B9x0717mis8DNG9s,27952
+fabricatio/models/usages.py,sha256=SvfASbO_nqbZ1fvn-dTMldjQetFcin3ADwVC8xmN-nQ,28019
 fabricatio/models/events.py,sha256=UvOc6V3vfjKuvh7irDezJ8EGpsNo5yzLdq4xQexVonw,4063
 fabricatio/models/task.py,sha256=-EnzpEyM6Z687gF1lPcmA2szEUw6dFpu3lOtseaz95o,10193
-fabricatio/models/action.py,sha256=S4PLBK5mmgdcJnWg12ZjWKc_8c8uuimxc9scyfSompQ,6290
+fabricatio/models/action.py,sha256=C8zyrZbJdMmspJFFbsoXK1B5R0WCbY46G3CLAarxnWo,8062
 fabricatio/toolboxes/fs.py,sha256=OQMdeokYxSNVrCZJAweJ0cYiK4k2QuEiNdIbS5IHIV8,705
 fabricatio/toolboxes/__init__.py,sha256=dYm_Gd8XolSU_h4wnkA09dlaLDK146eeFz0CUgPZ8_c,380
 fabricatio/toolboxes/arithmetic.py,sha256=sSTPkKI6-mb278DwQKFO9jKyzc9kCx45xNH7V6bGBpE,1307
@@ -20,7 +20,7 @@ fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fabricatio/fs/readers.py,sha256=5bLlpqcdhIwWfysh7gvfVv0PPPVAeDlTPGwNTio6j9M,1156
 fabricatio/fs/curd.py,sha256=FuG75qco4dX8vhIK27gKz9rKUXbWHOFg5yK3nGLB25s,4469
 fabricatio/fs/__init__.py,sha256=hTuYtzmvIGtbg7PTdoqLEQJ0E63hOzZltCIrLlDKaSE,559
-fabricatio/config.py,sha256=qoPSAlXfaKk3nGP3lQa6wy1YvnRSnNrmdJz6iOdFMCY,15902
+fabricatio/config.py,sha256=vRCDnCyBgQoNCiwMEVdlD8_ij9Q7rykdpsod3XHtD-8,16191
 fabricatio/journal.py,sha256=Op0wC-JlZumnAc_aDmYM4ljnSNLoKEEMfcIRbCF69ow,455
 fabricatio/__init__.py,sha256=6EjK4SxbnvFxdO9ftkXD9rxSuoPEIITNzUkuMO9s3yU,1092
 fabricatio/actions/output.py,sha256=wNyLNxjqBlms0hyxap8XUPgN53izipJrCOtpX6aluFQ,626
@@ -32,11 +32,12 @@ fabricatio/workflows/rag.py,sha256=uOZXprD479fUhLA6sYvEM8RWcVcUZXXtP0xRbTMPdHE,5
 fabricatio/parser.py,sha256=Jr2ELtcmiRNAyz76TCWoJuUpG7zrJoRn3GfaX9vZSJM,6099
 fabricatio/capabilities/correct.py,sha256=BiLEAk6e1KbwUMhTexmDfgtlPUct_bG0igDK7CwHqao,5107
 fabricatio/capabilities/rag.py,sha256=ghctqjIf6KDe6PP8-SDzKN1zxh94rXk5Y5hHFtG_46Y,15404
+fabricatio/capabilities/covalidate.py,sha256=uEpZNpzsQoIM5ZP4sntUhBveNhhqrAzQ6Q9-2WDlpPg,6461
 fabricatio/capabilities/rating.py,sha256=ZQrKKmmIgnN4zgNnG_GmWa5Nyxpk03JYW32RJ4R5vvQ,14067
 fabricatio/capabilities/review.py,sha256=TX7av4b2N7MRDHMowsIZfiujXRRNxjUMNHtCFVA1UTM,10824
 fabricatio/capabilities/propose.py,sha256=4QvONVVUp1rs34Te2Rjams6NioEt6FhEAxDWiveQnSg,1544
-fabricatio/capabilities/task.py,sha256=uAp4tC9cbq3Ux-VQHjYdEzKLE3Jr8vhB6HKLPbhozIo,4494
+fabricatio/capabilities/task.py,sha256=llFFKh8MAaTjsp8DtAGD_UUONROfFNxorh6NLys973U,4496
 fabricatio/_rust.pyi,sha256=1TvnaXK_QKM8Et05LkZ_vOGR4WISVd9X8lU6OTwFFaU,3376
-fabricatio/_rust.cpython-312-x86_64-linux-gnu.so,sha256=3fbtHUY9vCdKAyhn-ZoTII7ddg-G33HXGTCD5BvrfF0,1910296
-fabricatio-0.2.6.dev4.data/scripts/tdown,sha256=xtxnxCR31GJEl1qF0Z1UDI43FK7kzGxzpRkMnVaZSP0,4575216
-fabricatio-0.2.6.dev4.dist-info/RECORD,,
+fabricatio/_rust.cpython-312-x86_64-linux-gnu.so,sha256=Qv4F28dducNx2GS8L8TmMWuk3MgBivQbzH_UmC-1P2w,1911376
+fabricatio-0.2.6.dev5.data/scripts/tdown,sha256=h7dazHQEgymw8fXo1ROyyUfwLMMw7l4JyMlt2xJyN-4,4576688
+fabricatio-0.2.6.dev5.dist-info/RECORD,,