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

fabricatio/actions/article.py

@@ -93,10 +93,11 @@ class CorrectProposal(Action):
             f"{task_input.briefing}\nExtract the path of file, which contains the article briefing that I need to read."
         )
 
-        rprint(article_proposal.display())
         ret = None
         while await confirm("Do you want to correct the Proposal?").ask_async():
-            topic = await text("What is the topic of the proposal?").ask_async()
+            rprint(article_proposal.display())
+            while not (topic := await text("What is the topic of the proposal reviewing?").ask_async()):
+                ...
             ret = await self.correct_obj(
                 article_proposal,
                 safe_text_read(input_path),
@@ -115,11 +116,13 @@ class CorrectOutline(Action):
         self,
         article_outline: ArticleOutline,
         article_proposal: ArticleProposal,
+
         **_,
     ) -> Optional[str]:
-        rprint(article_outline.finalized_dump())
         ret = None
         while await confirm("Do you want to correct the outline?").ask_async():
-            topic = await text("What is the topic of the outline?").ask_async()
+            rprint(article_outline.finalized_dump())
+            while not (topic := await text("What is the topic of the outline reviewing?").ask_async()):
+                ...
             ret = await self.correct_obj(article_outline, article_proposal.display(), topic=topic)
         return ret or article_outline

fabricatio/capabilities/rag.py

@@ -21,7 +21,7 @@ from fabricatio.models.kwargs_types import (
     LLMKwargs,
 )
 from fabricatio.models.usages import EmbeddingUsage
-from fabricatio.models.utils import MilvusData
+from fabricatio.models.utils import MilvusData, ok
 from more_itertools.recipes import flatten, unique
 from pydantic import Field, PrivateAttr
 
@@ -60,7 +60,7 @@ class RAG(EmbeddingUsage):
     ) -> Self:
         """Initialize the Milvus client."""
         self._client = create_client(
-            uri=milvus_uri or (self.milvus_uri or configs.rag.milvus_uri).unicode_string(),
+            uri=milvus_uri or ok(self.milvus_uri or configs.rag.milvus_uri).unicode_string(),
             token=milvus_token
             or (token.get_secret_value() if (token := (self.milvus_token or configs.rag.milvus_token)) else ""),
             timeout=milvus_timeout or self.milvus_timeout,
@@ -315,7 +315,7 @@ class RAG(EmbeddingUsage):
             **kwargs,
         )
 
-    async def arefined_query(self, question: List[str] | str, **kwargs: Unpack[ChooseKwargs]) -> List[str]:
+    async def arefined_query(self, question: List[str] | str, **kwargs: Unpack[ChooseKwargs]) -> Optional[List[str]]:
         """Refines the given question using a template.
 
         Args:

fabricatio/config.py

@@ -66,7 +66,7 @@ class LLMConfig(BaseModel):
     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: Optional[str | List[str]] = Field(default="")
+    stop_sign: Optional[str | List[str]] = Field(default=None)
     """The stop sign of the LLM model. No default stop sign specified."""
 
     top_p: Optional[NonNegativeFloat] = Field(default=0.35)
@@ -78,7 +78,7 @@ class LLMConfig(BaseModel):
     stream: Optional[bool] = Field(default=False)
     """Whether to stream the LLM model's response. Default is False."""
 
-    max_tokens: Optional[PositiveInt] = Field(default=8192)
+    max_tokens: Optional[PositiveInt] = Field(default=None)
     """The maximum number of tokens to generate. Set to 8192 as per request."""
 
     rpm: Optional[PositiveInt] = Field(default=100)
@@ -148,13 +148,13 @@ class DebugConfig(BaseModel):
     log_level: Literal["DEBUG", "INFO", "SUCCESS", "WARNING", "ERROR", "CRITICAL"] = Field(default="INFO")
     """The log level of the application."""
 
-    log_file: FilePath = Field(default=Path(rf"{ROAMING_DIR}\fabricatio.log"))
+    log_file: FilePath = Field(default=Path(rf"{ROAMING_DIR}\fabricatio.log"), frozen=True)
     """The log file of the application."""
 
-    rotation: int = Field(default=1)
+    rotation: int = Field(default=1, frozen=True)
     """The rotation of the log file. in weeks."""
 
-    retention: int = Field(default=2)
+    retention: int = Field(default=2, frozen=True)
     """The retention of the log file. in weeks."""
 
     streaming_visible: bool = Field(default=False)

fabricatio/models/action.py

@@ -10,7 +10,6 @@ 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
@@ -19,7 +18,7 @@ from fabricatio.models.usages import ToolBoxUsage
 from pydantic import Field, PrivateAttr
 
 
-class Action(HandleTask, ProposeTask, Correct, CoValidate):
+class Action(HandleTask, ProposeTask, Correct):
     """Class that represents an action to be executed in a workflow.
 
     Actions are the atomic units of work in a workflow. Each action performs

fabricatio/models/extra.py

@@ -7,157 +7,325 @@ from pydantic import Field
 
 
 class Equation(Base):
-    """Structured representation of mathematical equations (including their physical or conceptual meanings)."""
+    """Mathematical formalism specification for research contributions.
+
+    Encodes equations with dual representation: semantic meaning and typeset-ready notation.
+    """
 
     description: str
-    """A concise explanation of the equation's meaning, purpose, and relevance in the context of the research."""
+    """Equation significance structured in three elements:
+    1. Physical/conceptual meaning
+    2. Role in technical workflow
+    3. Relationship to paper's core contribution
+    Example: 'Defines constrained search space dimensionality reduction. Used in architecture optimization phase (Section 3.2). Enables 40% parameter reduction.'"""
 
     latex_code: str
-    """The LaTeX code used to represent the equation in a publication-ready format."""
+    """LaTeX representation following academic typesetting standards:
+    - Must use equation environment
+    - Multiline equations aligned at '='
+    - Unit annotations where applicable
+    Example: r'\begin{equation} \\mathcal{L}_{NAS} = \alpha \\|\theta\\|_2 + \beta H(p) \\end{equation}'"""
 
 
 class Figure(Base):
-    """Structured representation of figures (including their academic significance and explanatory captions)."""
+    """Visual component specification for technical communication.
+
+    Combines graphical assets with structured academic captioning.
+    """
 
     description: str
-    """A detailed explanation of the figure's content and its role in conveying key insights."""
+    """Figure interpretation guide containing:
+    1. Key visual elements mapping
+    2. Data representation methodology
+    3. Connection to research findings
+    Example: 'Architecture search space topology (left) vs. convergence curves (right). Demonstrates NAS efficiency gains through constrained search.'"""
 
     figure_caption: str
-    """The caption accompanying the figure, summarizing its main points and academic value."""
+    """Complete caption following Nature-style guidelines:
+    1. Brief overview statement (首句总结)
+    2. Technical detail layer
+    3. Result implication
+    Example: 'Figure 3: Differentiable NAS framework. (a) Search space topology with constrained dimensions. (b) Training convergence across language pairs. Dashed lines indicate baseline methods.'"""
 
     figure_path: str
-    """The exact path to the figure file, must exist in the file system, SHALL never be a PLACEHOLDER."""
+    """Filesystem path to high-resolution vector graphic (PDF/EPS/SVG).
+    Strict validation requirements:
+    - Absolute path under /assets/figures/
+    - Naming convention: fig[chapter]-[section]_[description].pdf
+    Example: '/assets/figures/fig3-2_nas_convergence.pdf'"""
 
 
 class Highlightings(Base):
-    """Structured representation of highlighted elements in an academic paper (including equations, algorithms, figures, and tables)."""
+    """Technical showcase aggregator for research artifacts.
+
+    Curates core scientific components with machine-parseable annotations.
+    """
 
-    # Academic Achievements Showcase
     highlighted_equations: List[Equation] = Field(default_factory=list)
-    """Core mathematical equations that represent breakthroughs in the field, accompanied by explanations of their physical or conceptual significance,Should always be in LaTeX format wrapped in $ or $$ signs."""
+    """3-5 pivotal equations representing theoretical contributions.
+    Each must:
+    - Use $$ wrapping for display math
+    - Contain at least one novel operator/symbol
+    - Reference in Methods/Results sections
+    Example: Equation describing proposed loss function"""
 
     highlighted_algorithms: List[str] = Field(default_factory=list)
-    """Pseudocode for key algorithms, annotated to highlight innovative components."""
+    """Algorithm pseudocode following ACM style:
+    1. Numbered steps with bold keywords
+    2. Complexity analysis subsection
+    3. Novel components marked with ※
+    Example:
+    'Algorithm 1: Constrained NAS
+    1. Initialize search space with §3.1 constraints ※
+    2. While not converged:
+        a. Compute gradient ▽θ
+        b. Update architecture parameters...'"""
 
     highlighted_figures: List[Figure] = Field(default_factory=list)
-    """Critical diagrams or illustrations, each accompanied by a caption explaining their academic importance."""
+    """4-6 key figures demonstrating:
+    1. Framework overview (1 required)
+    2. Quantitative results (2-3 required)
+    3. Ablation studies (1 optional)
+    Each must appear in Results/Discussion chapters."""
 
     highlighted_tables: List[str] = Field(default_factory=list)
-    """Important data tables, annotated to indicate statistical significance or other notable findings."""
+    """Critical data presentations using booktabs format:
+    - Minimum 3 comparison baselines
+    - Statistical significance markers (*/†/‡)
+    - Standard deviation in parentheses
+    Example:
+    \begin{tabular}{lcc}
+    \toprule
+    Method & BLEU & Δ Params \\
+    \\midrule
+    Ours & 32.4 & -41\\%† \\
+    \bottomrule
+    \\end{tabular}"""
 
 
 class ArticleEssence(ProposedAble, Display, PrepareVectorization):
-    """Structured representation of the core elements of an academic paper(providing a comprehensive digital profile of the paper's essential information)."""
+    """Semantic fingerprint of academic paper for structured analysis.
+
+    Encodes research artifacts with dual human-machine interpretability.
+    """
 
-    # Basic Metadata
     title: str = Field(...)
-    """The full title of the paper, including any subtitles if applicable."""
+    """Complete title with technical specificity (12-18 words).
+    Must contain:
+    1. Methodology focus
+    2. Application domain
+    3. Performance metric
+    Example: 'EfficientViT: Multi-Scale Linear Attention for High-Resolution Dense Prediction'"""
 
     authors: List[str]
-    """A list of the paper's authors, typically in the order of contribution."""
+    """Author list with institutional annotations.
+    Format: [First Last¹, First Last²]
+    Superscripts mapping to affiliations.
+    Example: ['Yuanhao Zhou¹', 'Lei Chen²']"""
 
     keywords: List[str]
-    """A list of keywords that summarize the paper's focus and facilitate indexing."""
+    """5-8 ACM CCS concepts in camel case.
+    Example: ['Computing methodologies~Neural networks', 'Hardware~Emerging technologies']"""
 
     publication_year: int
-    """The year in which the paper was published."""
+    """Publication timestamp in ISO 8601 (YYYY format).
+    Constraint: 2017 ≤ year ≤ current_year"""
 
-    # Core Content Elements
     highlightings: Highlightings = Field(default_factory=Highlightings)
-    """A collection of highlighted elements in the paper, including equations, algorithms, figures, and tables."""
+    """Technical highlight reel containing:
+    - Core equations (Theory)
+    - Key algorithms (Implementation)
+    - Critical figures (Results)
+    - Benchmark tables (Evaluation)"""
 
     domain: List[str]
-    """The research domains or fields addressed by the paper (e.g., ['Natural Language Processing', 'Computer Vision'])."""
+    """Primary research domains from ACM CCS 2023 taxonomy.
+    Exactly 2-3 categories required.
+    Example: ['Computing methodologies → Machine learning']"""
 
     abstract: str = Field(...)
-    """A structured abstract that outlines the research problem, methodology, and conclusions in three distinct sections."""
+    """Three-paragraph structured abstract:
+    Paragraph 1: Problem & Motivation (2-3 sentences)
+    Paragraph 2: Methodology & Innovations (3-4 sentences)
+    Paragraph 3: Results & Impact (2-3 sentences)
+    Total length: 150-250 words"""
 
     core_contributions: List[str]
-    """Key academic contributions that distinguish the paper from prior work in the field."""
+    """3-5 technical contributions using CRediT taxonomy verbs.
+    Each item starts with action verb.
+    Example:
+    - 'Developed constrained NAS framework'
+    - 'Established cross-lingual transfer metrics'"""
 
     technical_novelty: List[str]
-    """Specific technical innovations introduced by the research, listed as individual points."""
+    """Patent-style claims with technical specificity.
+    Format: 'A [system/method] comprising [novel components]...'
+    Example:
+    'A neural architecture search system comprising:
+     a differentiable constrained search space;
+     multi-lingual transferability predictors...'"""
 
-    # Academic Discussion Dimensions
     research_problems: List[str]
-    """A clearly defined research question or problem addressed by the study."""
+    """Problem statements as how/why questions.
+    Example:
+    - 'How to reduce NAS computational overhead while maintaining search diversity?'
+    - 'Why do existing architectures fail in low-resource cross-lingual transfer?'"""
 
     limitations: List[str]
-    """An analysis of the methodological or experimental limitations of the research."""
+    """Technical limitations analysis containing:
+    1. Constraint source (data/method/theory)
+    2. Impact quantification
+    3. Mitigation pathway
+    Example:
+    'Methodology constraint: Single-objective optimization (affects 5% edge cases),
+    mitigated through future multi-task extension'"""
 
     future_work: List[str]
-    """Suggestions for potential directions or topics for follow-up studies."""
+    """Research roadmap items with 3 horizons:
+    1. Immediate extensions (1 year)
+    2. Mid-term directions (2-3 years)
+    3. Long-term vision (5+ years)
+    Example:
+    'Short-term: Adapt framework for vision transformers (ongoing with CVPR submission)'"""
 
     impact_analysis: List[str]
-    """An assessment of the paper's potential influence on the development of the field."""
+    """Bibliometric impact projections:
+    - Expected citation counts (next 3 years)
+    - Target application domains
+    - Standard adoption potential
+    Example:
+    'Predicted 150+ citations via integration into MMEngine (Alibaba OpenMMLab)'"""
 
     def _prepare_vectorization_inner(self) -> str:
         return self.model_dump_json()
 
 
 class ArticleProposal(ProposedAble, Display):
-    """Structured representation of the proposal for an academic paper."""
+    """Structured proposal for academic paper development with core research elements.
+
+    Guides LLM in generating comprehensive research proposals with clearly defined components.
+    """
 
     title: str = Field(...)
-    """The proposed title of the paper."""
+    """Paper title in academic style (Title Case, 8-15 words). Example: 'Exploring Neural Architecture Search for Low-Resource Machine Translation'"""
 
     focused_problem: List[str] = Field(default_factory=list)
-    """The specific research problem or question that the paper aims to address."""
+    """Specific research problem(s) or question(s) addressed (list of 1-3 concise statements).
+    Example: ['NAS computational overhead in low-resource settings', 'Architecture transferability across language pairs']"""
+
     research_aim: List[str] = Field(default_factory=list)
-    """The main objective or goal of the research, outlining what the study aims to achieve."""
+    """Primary research objectives (list of 2-4 measurable goals).
+    Example: ['Develop parameter-efficient NAS framework', 'Establish cross-lingual architecture transfer metrics']"""
+
     research_methods: List[str] = Field(default_factory=list)
-    """The methods used in the research, including the approach, techniques, and tools employed."""
+    """Methodological components (list of techniques/tools).
+    Example: ['Differentiable architecture search', 'Transformer-based search space', 'Multi-lingual perplexity evaluation']"""
 
 
 class ArticleSubsectionOutline(Base):
-    """Structured representation of the subsections of an academic paper."""
+    """Atomic content unit within academic paper sections.
+
+    Provides structured content specification for LLM-generated subsections.
+    """
 
     title: str = Field(...)
-    """The title of the subsection."""
+    """Subsection title reflecting specific content focus (Title Case, 3-8 words).
+    Example: 'Differentiable Search Space Design'"""
 
     description: str = Field(...)
-    """A brief description of the subsection's content should be, how it fits into the overall structure of the paper, and its significance in the context of the research."""
+    """Content specification with three required elements:
+    1. Core technical content
+    2. Structural purpose in section
+    3. Research significance
+    Example: 'Introduces continuous relaxation method for search space, enabling gradient-based optimization. Forms technical foundation for Section 3. Critical for reducing search complexity.'"""
 
 
 class ArticleSectionOutline(Base):
-    """Structured representation of the sections of an academic paper."""
+    """Primary organizational unit within paper chapters.
+
+    Defines section-level structure with nested subsections for hierarchical content organization.
+    """
 
     title: str = Field(...)
-    """The title of the section."""
+    """Section title indicating methodological phase or conceptual component (Title Case).
+    Example: 'Architecture Search Methodology'"""
+
     description: str = Field(...)
-    """A brief description of the section's content should be, how it fits into the overall structure of the paper, and its significance in the context of the research."""
+    """Functional description covering:
+    1. Section's research stage
+    2. Key contributions
+    3. Flow relationship with adjacent sections
+    Example: 'Presents core NAS framework building on literature from Section 2. Introduces novel constrained search space. Leads to implementation details in Section 4.'"""
+
     subsections: List[ArticleSubsectionOutline]
-    """The subsections of the section, outlining their content and significance."""
+    """Ordered sequence of 3-5 subsections implementing IMRaD structure within section. Maintains logical flow from problem statement to technical solution."""
 
 
 class ArticleChapterOutline(Base):
-    """Structured representation of the chapters of an academic paper."""
+    """Macro-level paper organization unit.
+
+    Represents major paper divisions (Introduction, Methodology, etc.) with hierarchical section structure.
+    """
 
     title: str = Field(...)
-    """The title of the chapter."""
+    """Chapter title reflecting standard academic sections (Title Case).
+    Example: 'Experimental Evaluation', 'Theoretical Framework'"""
+
     description: str = Field(...)
-    """A brief description of the chapter's content should be, how it fits into the overall structure of the paper, and its significance in the context of the research."""
+    """Chapter role specification containing:
+    1. Research phase covered
+    2. Chapter-specific objectives
+    3. Relationship to overall paper thesis
+    Example: 'Validates NAS framework through multilingual experiments. Demonstrates method effectiveness across 10 language pairs. Supports core thesis of parameter-efficient architecture search.'"""
+
     sections: List[ArticleSectionOutline]
-    """The sections of the chapter, outlining their content and significance."""
+    """3-5 sections implementing chapter's main function. Ordered to maintain academic paper logic:
+    Introduction → Related Work → Methods → Experiments → Analysis"""
 
 
 class ArticleOutline(ProposedAble, Display, FinalizedDumpAble):
-    """Structured representation of the outline for an academic paper."""
+    """Complete hierarchical structure for academic paper generation.
+
+    Provides multi-level outline specification for LLM-based paper drafting with strict academic conventions.
+    """
 
     title: str = Field(...)
-    """The proposed title of the paper."""
+    """Full paper title with technical specificity (Title Case, 12-18 words).
+    Example: 'Parameter-Efficient Neural Architecture Search for Low-Resource Machine Translation: A Cross-Lingual Transfer Approach'"""
 
     prospect: str = Field(...)
-    """A brief description of the research problem or question that the paper aims to address manipulating methods or techniques"""
+    """Unified problem-solution statement combining:
+    1. Core research gap
+    2. Proposed methodology
+    3. Expected contribution
+    Example: 'Addressing NAS computational barriers in low-resource NLP through differentiable constrained search spaces and cross-lingual transfer metrics, enabling efficient architecture discovery for 50+ languages.'"""
 
     chapters: List[ArticleChapterOutline]
-    """The chapters of the paper, outlining their content and significance."""
+    """Standard academic structure (5-8 chapters):
+    1. Introduction
+    2. Related Work
+    3. Methodology
+    4. Experiments
+    5. Results
+    6. Discussion
+    7. Conclusion
+    Maintains IMRaD logical flow with clear inter-chapter transitions."""
 
     def finalized_dump(self) -> str:
-        """Finalized dump of the article outline.
+        """Generates standardized hierarchical markup for paper drafting systems.
 
         Returns:
-            str: The finalized dump of the article outline.
+            str: Multi-level outline using academic markup conventions:
+            = Chapter Title
+            == Section Title
+            === Subsection Title
+            ==== Subsubsection Title (if needed)
+
+        Example:
+            = Methodology
+            == Neural Architecture Search Framework
+            === Differentiable Search Space
+            === Constrained Optimization Approach
         """
         lines: List[str] = []
 

fabricatio/models/kwargs_types.py

@@ -81,6 +81,7 @@ class ValidateKwargs[T](GenerateKwargs, total=False):
 
     default: T
     max_validations: int
+    co_extractor: GenerateKwargs
 
 
 # noinspection PyTypedDict

fabricatio/models/role.py

@@ -3,7 +3,6 @@
 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
@@ -13,7 +12,7 @@ from fabricatio.models.tool import ToolBox
 from pydantic import Field
 
 
-class Role(ProposeTask, HandleTask, Correct, CoValidate):
+class Role(ProposeTask, HandleTask, Correct):
     """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

fabricatio/models/usages.py

@@ -12,9 +12,9 @@ from fabricatio.models.generic import ScopedConfig, WithBriefing
 from fabricatio.models.kwargs_types import ChooseKwargs, EmbeddingKwargs, GenerateKwargs, LLMKwargs, ValidateKwargs
 from fabricatio.models.task import Task
 from fabricatio.models.tool import Tool, ToolBox
-from fabricatio.models.utils import Messages
+from fabricatio.models.utils import Messages, ok
 from fabricatio.parser import GenericCapture, JsonCapture
-from litellm import Router, stream_chunk_builder
+from litellm import Router, stream_chunk_builder  # pyright: ignore [reportPrivateImportUsage]
 from litellm.types.router import Deployment, LiteLLM_Params, ModelInfo
 from litellm.types.utils import (
     Choices,
@@ -70,14 +70,22 @@ class LLMUsage(ScopedConfig):
         """
         # Call the underlying asynchronous completion function with the provided and default parameters
         # noinspection PyTypeChecker,PydanticTypeChecker
-
         return await self._deploy(
             Deployment(
-                model_name=(m_name := kwargs.get("model") or self.llm_model or configs.llm.model),
+                model_name=(
+                    m_name := ok(
+                        kwargs.get("model") or self.llm_model or configs.llm.model, "model name is not set at any place"
+                    )
+                ),  # pyright: ignore [reportCallIssue]
                 litellm_params=(
                     p := LiteLLM_Params(
-                        api_key=(self.llm_api_key or configs.llm.api_key).get_secret_value(),
-                        api_base=(self.llm_api_endpoint or configs.llm.api_endpoint).unicode_string(),
+                        api_key=ok(
+                            self.llm_api_key or configs.llm.api_key, "llm api key is not set at any place"
+                        ).get_secret_value(),
+                        api_base=ok(
+                            self.llm_api_endpoint or configs.llm.api_endpoint,
+                            "llm api endpoint is not set at any place",
+                        ).unicode_string(),
                         model=m_name,
                         tpm=self.llm_tpm or configs.llm.tpm,
                         rpm=self.llm_rpm or configs.llm.rpm,
@@ -88,14 +96,14 @@ class LLMUsage(ScopedConfig):
                 model_info=ModelInfo(id=hash(m_name + p.model_dump_json(exclude_none=True))),
             )
         ).acompletion(
-            messages=messages,
+            messages=messages,  # pyright: ignore [reportArgumentType]
             n=n or self.llm_generation_count or configs.llm.generation_count,
             model=m_name,
             temperature=kwargs.get("temperature") or self.llm_temperature or configs.llm.temperature,
             stop=kwargs.get("stop") or self.llm_stop_sign or configs.llm.stop_sign,
             top_p=kwargs.get("top_p") or self.llm_top_p or configs.llm.top_p,
             max_tokens=kwargs.get("max_tokens") or self.llm_max_tokens or configs.llm.max_tokens,
-            stream=kwargs.get("stream") or self.llm_stream or configs.llm.stream,
+            stream=ok(kwargs.get("stream") or self.llm_stream or configs.llm.stream, "stream is not set at any place"),
             cache={
                 "no-cache": kwargs.get("no_cache"),
                 "no-store": kwargs.get("no_store"),
@@ -196,15 +204,15 @@ class LLMUsage(ScopedConfig):
                         for q, sm in zip(q_seq, sm_seq, strict=True)
                     ]
                 )
-                return [r[0].message.content for r in res]
+                return [r[0].message.content for r in res]  # pyright: ignore [reportReturnType, reportAttributeAccessIssue]
             case (list(q_seq), str(sm)):
                 res = await gather(*[self.ainvoke(n=1, question=q, system_message=sm, **kwargs) for q in q_seq])
-                return [r[0].message.content for r in res]
+                return [r[0].message.content for r in res]  # pyright: ignore [reportReturnType, reportAttributeAccessIssue]
             case (str(q), list(sm_seq)):
                 res = await gather(*[self.ainvoke(n=1, question=q, system_message=sm, **kwargs) for sm in sm_seq])
-                return [r[0].message.content for r in res]
+                return [r[0].message.content for r in res]  # pyright: ignore [reportReturnType, reportAttributeAccessIssue]
             case (str(q), str(sm)):
-                return ((await self.ainvoke(n=1, question=q, system_message=sm, **kwargs))[0]).message.content
+                return ((await self.ainvoke(n=1, question=q, system_message=sm, **kwargs))[0]).message.content  # pyright: ignore [reportReturnType, reportAttributeAccessIssue]
             case _:
                 raise RuntimeError("Should not reach here.")
 
@@ -215,6 +223,7 @@ class LLMUsage(ScopedConfig):
         validator: Callable[[str], T | None],
         default: T = ...,
         max_validations: PositiveInt = 2,
+        co_extractor: Optional[GenerateKwargs] = None,
         **kwargs: Unpack[GenerateKwargs],
     ) -> T: ...
     @overload
@@ -224,6 +233,7 @@ class LLMUsage(ScopedConfig):
         validator: Callable[[str], T | None],
         default: T = ...,
         max_validations: PositiveInt = 2,
+        co_extractor: Optional[GenerateKwargs] = None,
         **kwargs: Unpack[GenerateKwargs],
     ) -> List[T]: ...
     @overload
@@ -233,6 +243,7 @@ class LLMUsage(ScopedConfig):
         validator: Callable[[str], T | None],
         default: None = None,
         max_validations: PositiveInt = 2,
+        co_extractor: Optional[GenerateKwargs] = None,
         **kwargs: Unpack[GenerateKwargs],
     ) -> Optional[T]: ...
 
@@ -243,6 +254,7 @@ class LLMUsage(ScopedConfig):
         validator: Callable[[str], T | None],
         default: None = None,
         max_validations: PositiveInt = 2,
+        co_extractor: Optional[GenerateKwargs] = None,
         **kwargs: Unpack[GenerateKwargs],
     ) -> List[Optional[T]]: ...
 
@@ -252,6 +264,7 @@ class LLMUsage(ScopedConfig):
         validator: Callable[[str], T | None],
         default: Optional[T] = None,
         max_validations: PositiveInt = 2,
+        co_extractor: Optional[GenerateKwargs] = None,
         **kwargs: Unpack[GenerateKwargs],
     ) -> Optional[T] | List[Optional[T]] | List[T] | T:
         """Asynchronously asks a question and validates the response using a given validator.
@@ -261,6 +274,7 @@ class LLMUsage(ScopedConfig):
             validator (Callable[[str], T | None]): A function to validate the response.
             default (T | None): Default value to return if validation fails. Defaults to None.
             max_validations (PositiveInt): Maximum number of validation attempts. Defaults to 2.
+            co_extractor (Optional[GenerateKwargs]): Keyword arguments for the co-extractor, if provided will enable co-extraction.
             **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
@@ -274,6 +288,23 @@ class LLMUsage(ScopedConfig):
                     if (response := await self.aask(question=q, **kwargs)) and (validated := validator(response)):
                         logger.debug(f"Successfully validated the response at {lap}th attempt.")
                         return validated
+
+                    if co_extractor and (
+                        (
+                            co_response := await self.aask(
+                                question=(
+                                    TEMPLATE_MANAGER.render_template(
+                                        configs.templates.co_validation_template,
+                                        {"original_q": q, "original_a": response},
+                                    )
+                                ),
+                                **co_extractor,
+                            )
+                        )
+                        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
@@ -291,7 +322,7 @@ class LLMUsage(ScopedConfig):
 
     async def aliststr(
         self, requirement: str, k: NonNegativeInt = 0, **kwargs: Unpack[ValidateKwargs[List[str]]]
-    ) -> List[str]:
+    ) -> Optional[List[str]]:
         """Asynchronously generates a list of strings based on a given requirement.
 
         Args:
@@ -311,7 +342,7 @@ class LLMUsage(ScopedConfig):
             **kwargs,
         )
 
-    async def apathstr(self, requirement: str, **kwargs: Unpack[ChooseKwargs[List[str]]]) -> List[str]:
+    async def apathstr(self, requirement: str, **kwargs: Unpack[ChooseKwargs[List[str]]]) -> Optional[List[str]]:
         """Asynchronously generates a list of strings based on a given requirement.
 
         Args:
@@ -339,7 +370,7 @@ class LLMUsage(ScopedConfig):
         Returns:
             str: The validated response as a single string.
         """
-        return (
+        return ok(
             await self.apathstr(
                 requirement,
                 k=1,
@@ -347,7 +378,7 @@ class LLMUsage(ScopedConfig):
             )
         ).pop()
 
-    async def ageneric_string(self, requirement: str, **kwargs: Unpack[ValidateKwargs[str]]) -> str:
+    async def ageneric_string(self, requirement: str, **kwargs: Unpack[ValidateKwargs[str]]) -> Optional[str]:
         """Asynchronously generates a generic string based on a given requirement.
 
         Args:
@@ -357,7 +388,7 @@ class LLMUsage(ScopedConfig):
         Returns:
             str: The generated string.
         """
-        return await self.aask_validate(
+        return await self.aask_validate(  # pyright: ignore [reportReturnType]
             TEMPLATE_MANAGER.render_template(
                 configs.templates.generic_string_template,
                 {"requirement": requirement, "language": GenericCapture.capture_type},
@@ -372,7 +403,7 @@ class LLMUsage(ScopedConfig):
         choices: List[T],
         k: NonNegativeInt = 0,
         **kwargs: Unpack[ValidateKwargs[List[T]]],
-    ) -> List[T]:
+    ) -> Optional[List[T]]:
         """Asynchronously executes a multi-choice decision-making process, generating a prompt based on the instruction and options, and validates the returned selection results.
 
         Args:
@@ -437,13 +468,13 @@ class LLMUsage(ScopedConfig):
         Raises:
             ValueError: If validation fails after maximum attempts or if no valid selection is made.
         """
-        return (
+        return ok(
             await self.achoose(
                 instruction=instruction,
                 choices=choices,
                 k=1,
                 **kwargs,
-            )
+            ),
         )[0]
 
     async def ajudge(
@@ -500,7 +531,7 @@ class EmbeddingUsage(LLMUsage):
         """
         # check seq length
         max_len = self.embedding_max_sequence_length or configs.embedding.max_sequence_length
-        if any(len(t) > max_len for t in input_text):
+        if max_len and any(len(t) > max_len for t in input_text):
             logger.error(err := f"Input text exceeds maximum sequence length {max_len}.")
             raise ValueError(err)
 
@@ -514,10 +545,10 @@ class EmbeddingUsage(LLMUsage):
             or configs.embedding.timeout
             or self.llm_timeout
             or configs.llm.timeout,
-            api_key=(
+            api_key=ok(
                 self.embedding_api_key or configs.embedding.api_key or self.llm_api_key or configs.llm.api_key
             ).get_secret_value(),
-            api_base=(
+            api_base=ok(
                 self.embedding_api_endpoint
                 or configs.embedding.api_endpoint
                 or self.llm_api_endpoint
@@ -566,7 +597,7 @@ class ToolBoxUsage(LLMUsage):
         self,
         task: Task,
         **kwargs: Unpack[ChooseKwargs[List[ToolBox]]],
-    ) -> List[ToolBox]:
+    ) -> Optional[List[ToolBox]]:
         """Asynchronously executes a multi-choice decision-making process to choose toolboxes.
 
         Args:
@@ -591,7 +622,7 @@ class ToolBoxUsage(LLMUsage):
         task: Task,
         toolbox: ToolBox,
         **kwargs: Unpack[ChooseKwargs[List[Tool]]],
-    ) -> List[Tool]:
+    ) -> Optional[List[Tool]]:
         """Asynchronously executes a multi-choice decision-making process to choose tools.
 
         Args:
@@ -631,11 +662,11 @@ class ToolBoxUsage(LLMUsage):
         tool_choose_kwargs = tool_choose_kwargs or {}
 
         # Choose the toolboxes
-        chosen_toolboxes = await self.choose_toolboxes(task, **box_choose_kwargs)
+        chosen_toolboxes = ok(await self.choose_toolboxes(task, **box_choose_kwargs))
         # Choose the tools
         chosen_tools = []
         for toolbox in chosen_toolboxes:
-            chosen_tools.extend(await self.choose_tools(task, toolbox, **tool_choose_kwargs))
+            chosen_tools.extend(ok(await self.choose_tools(task, toolbox, **tool_choose_kwargs)))
         return chosen_tools
 
     async def gather_tools(self, task: Task, **kwargs: Unpack[ChooseKwargs]) -> List[Tool]:

fabricatio/models/utils.py

@@ -165,3 +165,24 @@ async def ask_edit(
         if edited:
             res.append(edited)
     return res
+
+
+def override_kwargs[T](kwargs: Dict[str, T], **overrides) -> Dict[str, T]:
+    """Override the values in kwargs with the provided overrides."""
+    kwargs.update({k: v for k, v in overrides.items() if v is not None})
+    return kwargs
+
+
+def ok[T](val: Optional[T], msg:str="Value is None") -> T:
+    """Check if a value is None and raise a ValueError with the provided message if it is.
+
+    Args:
+        val: The value to check.
+        msg: The message to include in the ValueError if val is None.
+
+    Returns:
+        T: The value if it is not None.
+    """
+    if val is None:
+        raise ValueError(msg)
+    return val

fabricatio/parser.py

@@ -52,6 +52,7 @@ class Capture(BaseModel):
             case _:
                 return text
 
+
     def capture(self, text: str) -> Tuple[str, ...] | str | None:
         """Capture the first occurrence of the pattern in the given text.
 

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

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

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

@@ -1,18 +1,18 @@
-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-0.2.6.dev6.dist-info/METADATA,sha256=9pqI0pxZslMJl25ehrBbGfOGeCikqwFGDVWNYwaAYXs,13693
+fabricatio-0.2.6.dev6.dist-info/WHEEL,sha256=7FgAcpQES0h1xhfN9Ugve9FTUilU6sRAr1WJ5ph2cuw,108
+fabricatio-0.2.6.dev6.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=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=SvfASbO_nqbZ1fvn-dTMldjQetFcin3ADwVC8xmN-nQ,28019
+fabricatio/models/role.py,sha256=UgIfGdfIBu4cOug8Nm1a04JCEwjXR_MDZUQhumwMptk,2710
+fabricatio/models/extra.py,sha256=tP58nLHlwgkM9F9EzVoDV7JP2n_1h-10uo2WRFouXuw,13448
+fabricatio/models/kwargs_types.py,sha256=VB_2X2cUdhD0syVl_5vPi0GU3qH5MjO7GiS44we9OO8,4468
+fabricatio/models/utils.py,sha256=snRuH81CQfTr9GZMSV_cW0JZocwfttgsKAqFWPk_Vc8,5480
+fabricatio/models/usages.py,sha256=ovuvDab9wvn9no4_a93HVcdo8Da1kF_eOnMoqph7LcY,30145
 fabricatio/models/events.py,sha256=UvOc6V3vfjKuvh7irDezJ8EGpsNo5yzLdq4xQexVonw,4063
 fabricatio/models/task.py,sha256=-EnzpEyM6Z687gF1lPcmA2szEUw6dFpu3lOtseaz95o,10193
-fabricatio/models/action.py,sha256=C8zyrZbJdMmspJFFbsoXK1B5R0WCbY46G3CLAarxnWo,8062
+fabricatio/models/action.py,sha256=Y8fYLWi28edtmi9KZIlE9E7M9_G4GcWMeraTLPVjp_c,7992
 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,24 +20,23 @@ 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=vRCDnCyBgQoNCiwMEVdlD8_ij9Q7rykdpsod3XHtD-8,16191
+fabricatio/config.py,sha256=6BXaIUZsfxuIvNOt74lmlBYoS_uBQhcCwGAmmxdvKZk,16232
 fabricatio/journal.py,sha256=Op0wC-JlZumnAc_aDmYM4ljnSNLoKEEMfcIRbCF69ow,455
 fabricatio/__init__.py,sha256=6EjK4SxbnvFxdO9ftkXD9rxSuoPEIITNzUkuMO9s3yU,1092
 fabricatio/actions/output.py,sha256=wNyLNxjqBlms0hyxap8XUPgN53izipJrCOtpX6aluFQ,626
 fabricatio/actions/rag.py,sha256=xCCNPM4pgjGlKaIl1J4SpWoNx3oWlSMxq6pQRSquXmc,788
-fabricatio/actions/article.py,sha256=dQ0Ca83v8yhO2n-IGtm4gIojXfsYD8s-HWRpPO5a7a4,4338
+fabricatio/actions/article.py,sha256=m3ejPgLX7WXcg-CfqRjQmanc5qSvCsT_u02wW9Jb23w,4435
 fabricatio/_rust_instances.py,sha256=bQmlhUCcxTmRgvw1SfzYzNNpgW_UCjmkYw5f-VPAyg8,304
 fabricatio/workflows/articles.py,sha256=oHNV5kNKEcOKP55FA7I1SlxQRlk6N26cpem_QYu05g0,1021
 fabricatio/workflows/rag.py,sha256=uOZXprD479fUhLA6sYvEM8RWcVcUZXXtP0xRbTMPdHE,509
-fabricatio/parser.py,sha256=Jr2ELtcmiRNAyz76TCWoJuUpG7zrJoRn3GfaX9vZSJM,6099
+fabricatio/parser.py,sha256=OV6bIAfLJ-GfaKoTeIOqS3X3GqCgyvzSJsgYMO3ogj4,6100
 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/rag.py,sha256=hyQMgpFrefwMT84Huh728xsVQXNEYkUH2-98KJyfOas,15420
 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=llFFKh8MAaTjsp8DtAGD_UUONROfFNxorh6NLys973U,4496
 fabricatio/_rust.pyi,sha256=1TvnaXK_QKM8Et05LkZ_vOGR4WISVd9X8lU6OTwFFaU,3376
 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,,
+fabricatio-0.2.6.dev6.data/scripts/tdown,sha256=h7dazHQEgymw8fXo1ROyyUfwLMMw7l4JyMlt2xJyN-4,4576688
+fabricatio-0.2.6.dev6.dist-info/RECORD,,

{fabricatio-0.2.6.dev5.dist-info → fabricatio-0.2.6.dev6.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (1.8.2)
+Generator: maturin (1.8.3)
 Root-Is-Purelib: false
 Tag: cp312-cp312-manylinux_2_34_x86_64

fabricatio/capabilities/covalidate.py

@@ -1,160 +0,0 @@
-"""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])