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

fabricatio/capabilities/rag.py

@@ -15,7 +15,7 @@ from fabricatio.config import configs
 from fabricatio.journal import logger
 from fabricatio.models.kwargs_types import (
     ChooseKwargs,
-    CollectionSimpleConfigKwargs,
+    CollectionConfigKwargs,
     EmbeddingKwargs,
     FetchKwargs,
     LLMKwargs,
@@ -102,14 +102,14 @@ class RAG(EmbeddingUsage):
         ]
 
     def view(
-        self, collection_name: Optional[str], create: bool = False, **kwargs: Unpack[CollectionSimpleConfigKwargs]
+        self, collection_name: Optional[str], create: bool = False, **kwargs: Unpack[CollectionConfigKwargs]
     ) -> Self:
         """View the specified collection.
 
         Args:
             collection_name (str): The name of the collection.
             create (bool): Whether to create the collection if it does not exist.
-            **kwargs (Unpack[CollectionSimpleConfigKwargs]): Additional keyword arguments for collection configuration.
+            **kwargs (Unpack[CollectionConfigKwargs]): Additional keyword arguments for collection configuration.
         """
         if create and collection_name and self.client.has_collection(collection_name):
             kwargs["dimension"] = kwargs.get("dimension") or self.milvus_dimensions or configs.rag.milvus_dimensions

fabricatio/models/extra.py

@@ -1,11 +1,12 @@
 """Extra models for built-in actions."""
 
-from typing import List
+from typing import List, Self
 
 from fabricatio.models.generic import Base, Display, FinalizedDumpAble, PrepareVectorization, ProposedAble
 from pydantic import Field
 
 
+# <editor-fold desc="ArticleEssence">
 class Equation(Base):
     """Mathematical formalism specification for research contributions.
 
@@ -200,6 +201,9 @@ class ArticleEssence(ProposedAble, Display, PrepareVectorization):
         return self.model_dump_json()
 
 
+# </editor-fold>
+
+
 class ArticleProposal(ProposedAble, Display):
     """Structured proposal for academic paper development with core research elements.
 
@@ -221,119 +225,434 @@ class ArticleProposal(ProposedAble, Display):
     """Methodological components (list of techniques/tools).
     Example: ['Differentiable architecture search', 'Transformer-based search space', 'Multi-lingual perplexity evaluation']"""
 
+    technical_approaches: List[str] = Field(default_factory=list)
 
-class ArticleSubsectionOutline(Base):
-    """Atomic content unit within academic paper sections.
 
-    Provides structured content specification for LLM-generated subsections.
-    """
+# <editor-fold desc="ArticleOutline">
+class ArticleSubsectionOutline(Base):
+    """Atomic research component specification for academic paper generation."""
 
     title: str = Field(...)
-    """Subsection title reflecting specific content focus (Title Case, 3-8 words).
-    Example: 'Differentiable Search Space Design'"""
+    """Technical focus descriptor following ACL title conventions:
+    - Title Case with 4-8 word limit
+    - Contains method and domain components
+    Example: 'Differentiable Search Space Optimization'"""
 
     description: str = Field(...)
-    """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.'"""
+    """Tripartite content specification with strict structure:
+    1. Technical Core: Method/algorithm/formalism (1 sentence)
+    2. Structural Role: Placement rationale in section (1 clause)
+    3. Research Value: Contribution to paper's thesis (1 clause)
 
+    Example: 'Introduces entropy-constrained architecture parameters enabling
+    gradient-based NAS. Serves as foundation for Section 3.2. Critical for
+    maintaining search space diversity while ensuring convergence.'"""
 
-class ArticleSectionOutline(Base):
-    """Primary organizational unit within paper chapters.
 
-    Defines section-level structure with nested subsections for hierarchical content organization.
-    """
+class ArticleSectionOutline(Base):
+    """Methodological unit organizing related technical components."""
 
     title: str = Field(...)
-    """Section title indicating methodological phase or conceptual component (Title Case).
-    Example: 'Architecture Search Methodology'"""
+    """Process-oriented header with phase identification:
+    - Title Case with 5-10 word limit
+    - Indicates research stage/methodological focus
+    Example: 'Cross-Lingual Evaluation Protocol'"""
 
     description: str = Field(...)
-    """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]
-    """Ordered sequence of 3-5 subsections implementing IMRaD structure within section. Maintains logical flow from problem statement to technical solution."""
+    """Functional specification with four required elements:
+    1. Research Stage: Paper progression position
+    2. Technical Innovations: Novel components
+    3. Scholarly Context: Relationship to prior work
+    4. Forward Flow: Connection to subsequent sections
+
+    Example: 'Implements constrained NAS framework building on Section 2's
+    theoretical foundations. Introduces dynamic resource allocation mechanism.
+    Directly supports Results section through ablation study parameters.'"""
+
+    subsections: List[ArticleSubsectionOutline] = Field(..., min_length=3, max_length=5)
+    """IMRaD-compliant substructure with technical progression:
+    1. Conceptual Framework
+    2. Methodological Details
+    3. Implementation Strategy
+    4. Validation Approach
+    5. Transition Logic
+
+    Example Flow:
+    [
+        'Search Space Constraints',
+        'Gradient Optimization Protocol',
+        'Multi-GPU Implementation',
+        'Convergence Validation',
+        'Cross-Lingual Extension'
+    ]"""
 
 
 class ArticleChapterOutline(Base):
-    """Macro-level paper organization unit.
-
-    Represents major paper divisions (Introduction, Methodology, etc.) with hierarchical section structure.
-    """
+    """Macro-structural unit implementing standard academic paper organization."""
 
     title: str = Field(...)
-    """Chapter title reflecting standard academic sections (Title Case).
-    Example: 'Experimental Evaluation', 'Theoretical Framework'"""
+    """IMRaD-compliant chapter title with domain specification:
+    - Title Case with 2-4 word limit
+    - Matches standard paper sections
+    Example: 'Multilingual Evaluation Results'"""
 
     description: str = Field(...)
-    """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]
-    """3-5 sections implementing chapter's main function. Ordered to maintain academic paper logic:
-    Introduction → Related Work → Methods → Experiments → Analysis"""
+    """Strategic chapter definition containing:
+    1. Research Phase: Introduction/Methods/Results/etc.
+    2. Chapter Objectives: 3-5 specific goals
+    3. Thesis Alignment: Supported claims/contributions
+    4. Structural Flow: Adjacent chapter relationships
+
+    Example: 'Presents cross-lingual NAS results across 10 language pairs.
+    Validates efficiency claims from Introduction. Provides empirical basis
+    for Discussion chapter. Contrasts with single-language baselines.'"""
+
+    sections: List[ArticleSectionOutline] = Field(..., min_length=3, max_length=5)
+    """Standard academic progression implementing chapter goals:
+    1. Context Establishment
+    2. Technical Presentation
+    3. Empirical Validation
+    4. Comparative Analysis
+    5. Synthesis
+
+    Example Structure:
+    [
+        'Experimental Setup',
+        'Monolingual Baselines',
+        'Cross-Lingual Transfer',
+        'Low-Resource Scaling',
+        'Error Analysis'
+    ]"""
 
 
 class ArticleOutline(ProposedAble, Display, FinalizedDumpAble):
-    """Complete hierarchical structure for academic paper generation.
-
-    Provides multi-level outline specification for LLM-based paper drafting with strict academic conventions.
-    """
+    """Complete academic paper blueprint with hierarchical validation."""
 
     title: str = Field(...)
-    """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'"""
+    """Full technical title following ACL 2024 guidelines:
+    - Title Case with 12-18 word limit
+    - Structure: [Method] for [Task] via [Approach] in [Domain]
+    Example: 'Efficient Differentiable NAS for Low-Resource MT Through
+    Parameter-Sharing: A Cross-Lingual Study'"""
 
     prospect: str = Field(...)
-    """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]
-    """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."""
+    """Consolidated research statement with four pillars:
+    1. Problem Identification: Current limitations
+    2. Methodological Response: Technical approach
+    3. Empirical Validation: Evaluation strategy
+    4. Scholarly Impact: Field contributions
+
+    Example: 'Addressing NAS computational barriers through constrained
+    differentiable search spaces, validated via cross-lingual MT experiments
+    across 50+ languages, enabling efficient architecture discovery with
+    60% reduced search costs.'"""
+
+    chapters: List[ArticleChapterOutline] = Field(..., min_length=5, max_length=8)
+    """IMRaD structure with enhanced academic validation:
+    1. Introduction: Problem Space & Contributions
+    2. Background: Theoretical Foundations
+    3. Methods: Technical Innovations
+    4. Experiments: Protocol Design
+    5. Results: Empirical Findings
+    6. Discussion: Interpretation & Limitations
+    7. Conclusion: Synthesis & Future Work
+    8. Appendices: Supplementary Materials"""
 
     def finalized_dump(self) -> str:
-        """Generates standardized hierarchical markup for paper drafting systems.
+        """Generates standardized hierarchical markup for academic publishing systems.
+
+        Implements ACL 2024 outline conventions with four-level structure:
+        = Chapter Title (Level 1)
+        == Section Title (Level 2)
+        === Subsection Title (Level 3)
+        ==== Subsubsection Title (Level 4)
 
         Returns:
-            str: Multi-level outline using academic markup conventions:
-            = Chapter Title
-            == Section Title
-            === Subsection Title
-            ==== Subsubsection Title (if needed)
+            str: Strictly formatted outline with academic sectioning
 
         Example:
             = Methodology
             == Neural Architecture Search Framework
             === Differentiable Search Space
-            === Constrained Optimization Approach
+            ==== Constrained Optimization Parameters
+            === Implementation Details
+            == Evaluation Protocol
         """
         lines: List[str] = []
+        for i, chapter in enumerate(self.chapters, 1):
+            lines.append(f"= Chapter {i}: {chapter.title}")
+            for j, section in enumerate(chapter.sections, 1):
+                lines.append(f"== {i}.{j} {section.title}")
+                for k, subsection in enumerate(section.subsections, 1):
+                    lines.append(f"=== {i}.{j}.{k} {subsection.title}")
+        return "\n".join(lines)
+
+
+# </editor-fold>
+
+
+# <editor-fold desc="Article">
+class Paragraph(ProposedAble):
+    """Structured academic paragraph blueprint for controlled content generation."""
+
+    description: str
+    """Functional summary of the paragraph's role in document structure.
+    Example: 'Establishes NAS efficiency improvements through differentiable methods'"""
+
+    writing_aim: List[str]
+    """Specific communicative objectives for this paragraph's content.
+    Example: ['Introduce gradient-based NAS', 'Compare computational costs',
+             'Link efficiency to practical applications']"""
+
+    lines: List[str]
+    """Hierarchically structured content with enforced rhetorical elements:
+    1. Topic Sentence: Principal claim/position (1 sentence)
+    2. Development: Evidence chain with citations (2-4 sentences)
+    3. Synthesis: Interpretation & significance (1 sentence)
+    4. Transition: Logical bridge to next paragraph (optional)
+
+    Example: [
+        'Differentiable NAS revolutionized architecture search efficiency.',
+        'DARTS reduced search costs from 2000+ to 4 GPU days (Liu et al., 2019) while maintaining competitive ImageNet accuracy.',
+        'This order-of-magnitude improvement enables NAS deployment in resource-constrained research contexts.',
+        'These efficiency gains directly impact our framework's design choices as detailed in Section 3.'
+    ]"""
+
+
+class SectionRef(ProposedAble):
+    """Cross-component reference system for maintaining document consistency."""
+
+    ref_chapter_title: str
+    """Title of referenced chapter (e.g., 'Methodology')"""
+
+    ref_section_title: str
+    """Exact section header text (e.g., '3.2 Gradient Optimization')"""
 
-        for chapter in self.chapters:
-            lines.append(f"= {chapter.title}")
-            for section in chapter.sections:
-                lines.append(f"== {section.title}")
-                for subsection in section.subsections:
-                    lines.append(f"=== {subsection.title}")
+    ref_subsection_title: str
+    """Specific subsection identifier (e.g., '3.2.1 Learning Rate Scheduling')"""
 
-        return "\n\n".join(lines)
+
+class ArticleBase(ProposedAble, Display):
+    """Foundation for hierarchical document components with dependency tracking."""
+
+    description: str
+    """Functional purpose statement for this component's role in the paper.
+    Example: 'Defines evaluation metrics for cross-lingual transfer experiments'"""
+
+    writing_aim: List[str]
+    """Author intentions mapped to rhetorical moves:
+    Example: ['Establish metric validity', 'Compare with baseline approaches',
+             'Justify threshold selection']"""
+
+    title: str = Field(...)
+    """Standardized academic header following ACL style guidelines:
+    - Title Case with maximal 12-word length
+    - No abbreviations without prior definition
+    Example: 'Multilingual Benchmark Construction'"""
+
+    support_to: List[SectionRef]
+    """Upstream dependencies requiring this component's validation.
+    Format: List of hierarchical references to supported claims/sections
+    Example: [SectionRef(chapter='Results', section='4.1', subsection='4.1.2')]"""
+
+    depend_on: List[SectionRef]
+    """Downstream prerequisites for content validity.
+    Format: List of references to foundational components
+    Example: [SectionRef(chapter='Methods', section='2.3', subsection='2.3.4')]"""
+
+
+class ArticleSubsection(ArticleBase):
+    """Atomic argumentative unit with technical specificity."""
+
+    title: str = Field(...)
+    """Technical descriptor with maximal information density:
+    Format: [Method]-[Domain]-[Innovation]
+    Example: 'Transformer-Based Architecture Search Space'"""
+
+    support_to: List[SectionRef]
+    """Immediate parent components and supported hypotheses.
+    Example: [SectionRef(chapter='Methods', section='3', subsection='3.1')]"""
+
+    depend_on: List[SectionRef]
+    """Technical dependencies including equations, algorithms, and datasets.
+    Example: [SectionRef(chapter='Background', section='2.2', subsection='2.2.3')]"""
+
+    paragraphs: List[Paragraph] = Field(..., min_length=3, max_length=5)
+    """Technical exposition following ACM writing guidelines:
+    1. Contextualization: Position in research design
+    2. Technical Detail: Equations/algorithms/code
+    3. Validation: Citations/experimental confirmation
+    4. Interpretation: Scholarly significance
+    5. Transition: Logical connection to subsequent content
+
+    Example Paragraph Chain:
+    [
+        'Our search space builds on standard CNN architectures...',
+        'Formally, we define architecture parameters $\\alpha \\in R^d$ where...',
+        'This parameterization reduces search complexity by 42% compared to...',
+        'The efficiency gains validate our approach to...'
+    ]"""
+
+
+class ArticleSection(ArticleBase):
+    """Methodological complete unit presenting cohesive research phase."""
+
+    title: str = Field(...)
+    """Process-oriented header indicating methodological scope.
+    Example: 'Cross-Lingual Transfer Evaluation Protocol'"""
+
+    support_to: List[SectionRef]
+    """Supported research questions and paper-level claims.
+    Example: [SectionRef(chapter='Introduction', section='1', subsection='1.2')]"""
+
+    depend_on: List[SectionRef]
+    """Required methodological components and theoretical frameworks.
+    Example: [SectionRef(chapter='Background', section='2', subsection='2.4')]"""
+
+    subsections: List[ArticleSubsection] = Field(..., min_length=3, max_length=5)
+    """Thematic progression implementing section's research function:
+    1. Conceptual Framework
+    2. Technical Implementation
+    3. Experimental Validation
+    4. Comparative Analysis
+    5. Synthesis
+
+    Example Subsection Flow:
+    [
+        'Evaluation Metrics',
+        'Dataset Preparation',
+        'Baseline Comparisons',
+        'Ablation Studies',
+        'Interpretation Framework'
+    ]"""
+
+
+class ArticleChapter(ArticleBase):
+    """Macro-structural unit implementing IMRaD document architecture."""
+
+    title: str = Field(...)
+    """Standard IMRaD chapter title with domain specification.
+    Example: 'Neural Architecture Search for Low-Resource Languages'"""
+
+    support_to: List[SectionRef]
+    """Supported thesis statements and paper-level contributions.
+    Example: [SectionRef(chapter='Abstract', section='', subsection='')]"""
+
+    depend_on: List[SectionRef]
+    """Foundational chapters and external knowledge prerequisites.
+    Example: [SectionRef(chapter='Related Work', section='2', subsection='2.3')]"""
+
+    sections: List[ArticleSection] = Field(..., min_length=3, max_length=5)
+    """Complete research narrative implementing chapter objectives:
+    1. Context Establishment
+    2. Methodology Exposition
+    3. Results Presentation
+    4. Critical Analysis
+    5. Synthesis
+
+    Example Section Hierarchy:
+    [
+        'Theoretical Framework',
+        'Experimental Design',
+        'Results Analysis',
+        'Threats to Validity',
+        'Comparative Discussion'
+    ]"""
+
+
+class Article(ProposedAble, Display):
+    """Complete academic paper specification with validation constraints."""
+
+    title: str = Field(...)
+    """Full technical descriptor following ACL 2024 guidelines:
+    Structure: [Method] for [Task] in [Domain]: [Subtitle with Technical Focus]
+    Example: 'Efficient Differentiable NAS for Low-Resource MT:
+             A Parameter-Sharing Approach to Cross-Lingual Transfer'"""
+
+    abstract: str = Field(...)
+    """Structured summary with controlled natural language:
+    1. Context: 2 clauses (problem + gap)
+    2. Methods: 3 clauses (approach + innovation + implementation)
+    3. Results: 3 clauses (metrics + comparisons + significance)
+    4. Impact: 2 clauses (theoretical + practical)
+
+    Example: 'Neural architecture search (NAS) faces prohibitive... [150 words]'"""
+
+    chapters: List[ArticleChapter] = Field(..., min_length=5, max_length=8)
+    """IMRaD-compliant document structure with enhanced validation:
+    1. Introduction: Motivation & Contributions
+    2. Background: Literature & Theory
+    3. Methods: Technical Implementation
+    4. Experiments: Protocols & Setup
+    5. Results: Empirical Findings
+    6. Discussion: Interpretation & Limitations
+    7. Conclusion: Summary & Future Work
+
+    Additional: Appendices, Ethics Review, Reproducibility Statements"""
+
+    def init_from_outline(self, outline: ArticleOutline) -> Self:
+        """Initialize the article from a given outline.
+
+        Args:
+            outline (ArticleOutline): The outline to initialize from.
+
+        Returns:
+            Self: The current instance of the article.
+        """
+        # Set the title from the outline
+        self.title = outline.title
+
+        # Initialize chapters based on outline's chapters
+        self.chapters = []
+
+        for chapter_outline in outline.chapters:
+            # Create a new chapter
+            chapter = ArticleChapter(
+                title=chapter_outline.title,
+                description=chapter_outline.description,
+                writing_aim=["Implement " + chapter_outline.description],
+                support_to=[],
+                depend_on=[],
+                sections=[],
+            )
+
+            # Create sections for each chapter
+            for section_outline in chapter_outline.sections:
+                section = ArticleSection(
+                    title=section_outline.title,
+                    description=section_outline.description,
+                    writing_aim=["Address " + section_outline.description],
+                    support_to=[],
+                    depend_on=[],
+                    subsections=[],
+                )
+
+                # Create subsections for each section
+                for subsection_outline in section_outline.subsections:
+                    subsection = ArticleSubsection(
+                        title=subsection_outline.title,
+                        description=subsection_outline.description,
+                        writing_aim=["Explain " + subsection_outline.description],
+                        support_to=[],
+                        depend_on=[],
+                        paragraphs=[
+                            Paragraph(
+                                description=f"Implementation of {subsection_outline.title}",
+                                writing_aim=["Present key concepts", "Support main arguments"],
+                                lines=[],
+                            )
+                        ],
+                    )
+                    section.subsections.append(subsection)
+
+                chapter.sections.append(section)
+
+            self.chapters.append(chapter)
+
+        # Generate a placeholder abstract from the outline's prospect
+        self.abstract = f"Abstract: {outline.prospect}"
+
+        return self
+
+
+# </editor-fold>

fabricatio/models/kwargs_types.py

@@ -1,19 +1,29 @@
 """This module contains the types for the keyword arguments of the methods in the models module."""
 
+from importlib.util import find_spec
 from typing import Any, Required, TypedDict
 
 from litellm.caching.caching import CacheMode
 from litellm.types.caching import CachingSupportedCallTypes
 
+if find_spec("pymilvus"):
+    from pymilvus import CollectionSchema
+    from pymilvus.milvus_client import IndexParams
 
-class CollectionSimpleConfigKwargs(TypedDict, total=False):
-    """Configuration parameters for a vector collection.
+    class CollectionConfigKwargs(TypedDict, total=False):
+        """Configuration parameters for a vector collection.
 
-    These arguments are typically used when configuring connections to vector databases.
-    """
+        These arguments are typically used when configuring connections to vector databases.
+        """
 
-    dimension: int | None
-    timeout: float
+        dimension: int | None
+        primary_field_name: str
+        id_type: str
+        vector_field_name: str
+        metric_type: str
+        timeout: float | None
+        schema: CollectionSchema | None
+        index_params: IndexParams | None
 
 
 class FetchKwargs(TypedDict, total=False):

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

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

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

@@ -1,13 +1,13 @@
-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-0.2.6.dev7.dist-info/METADATA,sha256=uKqLHzycJi0fHhq9xKJUCiO-DzWApY-ZBPI4xUmNTek,13693
+fabricatio-0.2.6.dev7.dist-info/WHEEL,sha256=7FgAcpQES0h1xhfN9Ugve9FTUilU6sRAr1WJ5ph2cuw,108
+fabricatio-0.2.6.dev7.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=UgIfGdfIBu4cOug8Nm1a04JCEwjXR_MDZUQhumwMptk,2710
-fabricatio/models/extra.py,sha256=tP58nLHlwgkM9F9EzVoDV7JP2n_1h-10uo2WRFouXuw,13448
-fabricatio/models/kwargs_types.py,sha256=VB_2X2cUdhD0syVl_5vPi0GU3qH5MjO7GiS44we9OO8,4468
+fabricatio/models/extra.py,sha256=JXrLJWOapiu5HwkhJTtvK8bD50IImpRi19DB3HVbsQ0,25605
+fabricatio/models/kwargs_types.py,sha256=rqhCG2QLj4iyZ5WnLU4IT0xPdzFWvgsz9g6qau3bD1E,4839
 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
@@ -31,12 +31,12 @@ fabricatio/workflows/articles.py,sha256=oHNV5kNKEcOKP55FA7I1SlxQRlk6N26cpem_QYu0
 fabricatio/workflows/rag.py,sha256=uOZXprD479fUhLA6sYvEM8RWcVcUZXXtP0xRbTMPdHE,509
 fabricatio/parser.py,sha256=OV6bIAfLJ-GfaKoTeIOqS3X3GqCgyvzSJsgYMO3ogj4,6100
 fabricatio/capabilities/correct.py,sha256=BiLEAk6e1KbwUMhTexmDfgtlPUct_bG0igDK7CwHqao,5107
-fabricatio/capabilities/rag.py,sha256=hyQMgpFrefwMT84Huh728xsVQXNEYkUH2-98KJyfOas,15420
+fabricatio/capabilities/rag.py,sha256=psRCuKo7vLJXBGrm48FsFIzrawZ2JO5OJsvH05CJ8Tg,15402
 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.dev6.data/scripts/tdown,sha256=h7dazHQEgymw8fXo1ROyyUfwLMMw7l4JyMlt2xJyN-4,4576688
-fabricatio-0.2.6.dev6.dist-info/RECORD,,
+fabricatio-0.2.6.dev7.data/scripts/tdown,sha256=h7dazHQEgymw8fXo1ROyyUfwLMMw7l4JyMlt2xJyN-4,4576688
+fabricatio-0.2.6.dev7.dist-info/RECORD,,