fabricatio 0.2.11.dev2__cp312-cp312-manylinux_2_34_x86_64.whl → 0.2.12.dev1__cp312-cp312-manylinux_2_34_x86_64.whl

fabricatio/actions/article.py

@@ -149,10 +149,10 @@ class GenerateInitialOutline(Action, Extract):
     async def _execute(
         self,
         article_proposal: ArticleProposal,
+        supervisor: Optional[bool] = None,
         **_,
     ) -> Optional[ArticleOutline]:
-        raw_outline = await self.aask(
-            f"{(article_proposal.as_prompt())}\n"
+        req = (
             f"Design each chapter of a proper and academic and ready for release manner.\n"
             f"You Must make sure every chapter have sections, and every section have subsections.\n"
             f"Make the chapter and sections and subsections bing divided into a specific enough article component.\n"
@@ -160,14 +160,16 @@ class GenerateInitialOutline(Action, Extract):
             f"Note that you SHALL use `{article_proposal.language}` as written language",
         )
 
-        if self.supervisor:
+        raw_outline = await self.aask(f"{(article_proposal.as_prompt())}\n{req}")
+
+        if supervisor or (supervisor is None and self.supervisor):
             from questionary import confirm, text
 
             r_print(raw_outline)
             while not await confirm("Accept this version and continue?", default=True).ask_async():
                 imp = await text("Enter the improvement:").ask_async()
                 raw_outline = await self.aask(
-                    f"{article_proposal.as_prompt()}\n{wrapp_in_block(raw_outline, 'Previous ArticleOutline')}\n{imp}"
+                    f"{article_proposal.as_prompt()}\n{wrapp_in_block(raw_outline, 'Previous ArticleOutline')}\n{req}\n{wrapp_in_block(imp, title='Improvement')}"
                 )
                 r_print(raw_outline)
 
@@ -177,6 +179,20 @@ class GenerateInitialOutline(Action, Extract):
         ).update_ref(article_proposal)
 
 
+class ExtractOutlineFromRaw(Action, Extract):
+    """Extract the outline from the raw outline."""
+
+    output_key: str = "article_outline_from_raw"
+
+    async def _execute(self, article_outline_raw_path: str | Path, **cxt) -> ArticleOutline:
+        logger.info(f"Extracting outline from raw: {Path(article_outline_raw_path).as_posix()}")
+
+        return ok(
+            await self.extract(ArticleOutline, safe_text_read(article_outline_raw_path)),
+            "Could not extract the outline from raw.",
+        )
+
+
 class FixIntrospectedErrors(Action, Censor):
     """Fix introspected errors in the article outline."""
 

fabricatio/actions/article_rag.py

@@ -4,6 +4,8 @@ from asyncio import gather
 from pathlib import Path
 from typing import List, Optional
 
+from pydantic import PositiveInt
+
 from fabricatio import BibManager
 from fabricatio.capabilities.censor import Censor
 from fabricatio.capabilities.extract import Extract
@@ -18,13 +20,35 @@ from fabricatio.models.extra.article_outline import ArticleOutline
 from fabricatio.models.extra.rule import RuleSet
 from fabricatio.utils import ask_retain, ok
 
+TYPST_CITE_USAGE = (
+    "citation number is REQUIRED to cite any reference!,for example in Auther Pattern: 'Doe et al.[[1]], Jack et al.[[2]]' or in Sentence Suffix Sattern: 'Global requirement is incresing[[1]].'\n"
+    "Everything is build upon the typst language, which is similar to latex, \n"
+    "Legal citing syntax examples(seperated by |): [[1]]|[[1,2]]|[[1-3]]|[[12,13-15]]|[[1-3,5-7]]\n"
+    "Illegal citing syntax examples(seperated by |): [[1],[2],[3]]|[[1],[1-2]]\n"
+    "Those reference mark shall not be omitted during the extraction\n"
+    "It's recommended to cite multiple references that supports your conclusion at a time.\n"
+    "Wrapp inline expression using $ $,like '$>5m$' '$89%$' , and wrapp block equation using $$ $$. if you are using '$' as the money unit, you should add a '\\' before it to avoid being interpreted as a inline equation. For example 'The pants worths 5\\$.'\n"
+    "In addition to that, you can add a label outside the block equation which can be used as a cross reference identifier, the label is a string wrapped in `<` and `>` like `<energy-release-rate-equation>`.Note that the label string should be a summarizing title for the equation being labeled.\n"
+    "you can refer to that label by using the syntax with prefix of `@eqt:`, which indicate that this notation is citing a label from the equations. For example ' @eqt:energy-release-rate-equation ' DO remember that the notation shall have both suffixed and prefixed space char which enable the compiler to distinguish the notation from the plaintext."
+    "Below is a usage example:\n"
+    "```typst\n"
+    "See @eqt:mass-energy-equation , it's the foundation of physics.\n"
+    "$$\n"
+    "E = m c^2\n"
+    "$$  <mass-energy-equation>\n\n\n"
+    "In @eqt:mass-energy-equation , $m$ stands for mass, $c$ stands for speed of light, and $E$ stands for energy. \n"
+    "```"
+)
+
 
 class WriteArticleContentRAG(Action, RAG, Extract):
     """Write an article based on the provided outline."""
 
+    search_increment_multiplier: float = 1.6
+    """The increment multiplier of the search increment."""
     ref_limit: int = 35
     """The limit of references to be retrieved"""
-    threshold: float = 0.55
+    threshold: float = 0.62
     """The threshold of relevance"""
     extractor_model: str
     """The model to use for extracting the content from the retrieved references."""
@@ -32,43 +56,24 @@ class WriteArticleContentRAG(Action, RAG, Extract):
     """The model to use for querying the database"""
     supervisor: bool = False
     """Whether to use supervisor mode"""
-    req: str = (
-        "citation number is REQUIRED to cite any reference!\n"
-        "Everything is build upon the typst language, which is similar to latex, \n"
-        "Legal citing syntax examples(seperated by |): [[1]]|[[1,2]]|[[1-3]]|[[12,13-15]]|[[1-3,5-7]]\n"
-        "Illegal citing syntax examples(seperated by |): [[1],[2],[3]]|[[1],[1-2]]\n"
-        "Those reference mark shall not be omitted during the extraction\n"
-        "It's recommended to cite multiple references that supports your conclusion at a time.\n"
-        "Wrapp inline expression using $ $, and wrapp block equation using $$ $$."
-        "In addition to that, you can add a label outside the block equation which can be used as a cross reference identifier, the label is a string wrapped in `<` and `>`,"
-        "you can refer to that label by using the syntax with prefix of `@eqt:`"
-        "Below is a usage example:\n"
-        "```typst\n"
-        "See @eqt:mass-energy-equation , it's the foundation of physics.\n"
-        "$$\n"
-        "E = m c^2"
-        "$$\n"
-        "<mass-energy-equation>\n\n"
-        "In @eqt:mass-energy-equation , $m$ stands for mass, $c$ stands for speed of light, and $E$ stands for energy. \n"
-        "```"
-    )
+    result_per_query: PositiveInt = 4
+    """The number of results to be returned per query."""
+    req: str = TYPST_CITE_USAGE
+    """The req of the write article content."""
 
     async def _execute(
         self,
         article_outline: ArticleOutline,
-        writing_ruleset: RuleSet,
-        collection_name: str = "article_chunks",
+        collection_name: Optional[str] = None,
+        supervisor: Optional[bool] = None,
         **cxt,
     ) -> Article:
         article = Article.from_outline(article_outline).update_ref(article_outline)
+        self.target_collection = collection_name or self.safe_target_collection
+        if supervisor or (supervisor is None and self.supervisor):
+            for chap, sec, subsec in article.iter_subsections():
+                await self._supervisor_inner(article, article_outline, chap, sec, subsec)
 
-        if self.supervisor:
-            await gather(
-                *[
-                    self._supervisor_inner(article, article_outline, chap, sec, subsec)
-                    for chap, sec, subsec in article.iter_subsections()
-                ]
-            )
         else:
             await gather(
                 *[
@@ -92,21 +97,29 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         from questionary import confirm, text
         from rich import print as r_print
 
-        ret = await self.search_database(article, article_outline, chap, sec, subsec)
-
-        cm = CitationManager(article_chunks=await ask_retain([r.chunk for r in ret], ret)).set_cite_number_all()
+        cm = CitationManager()
+        await self.search_database(article, article_outline, chap, sec, subsec, cm)
 
         raw = await self.write_raw(article, article_outline, chap, sec, subsec, cm)
         r_print(raw)
+
         while not await confirm("Accept this version and continue?").ask_async():
-            if await confirm("Search for more refs?").ask_async():
-                new_refs = await self.search_database(article, article_outline, chap, sec, subsec)
-                cm.add_chunks(await ask_retain([r.chunk for r in new_refs], new_refs))
+            if inst := await text("Search for more refs for additional spec.").ask_async():
+                await self.search_database(
+                    article,
+                    article_outline,
+                    chap,
+                    sec,
+                    subsec,
+                    cm,
+                    supervisor=True,
+                    extra_instruction=inst,
+                )
 
-            instruction = await text("Enter the instructions to improve").ask_async()
-            raw = await self.write_raw(article, article_outline, chap, sec, subsec, cm, instruction)
-            if await confirm("Edit it?").ask_async():
-                raw = await text("Edit", default=raw).ask_async() or raw
+            if instruction := await text("Enter the instructions to improve").ask_async():
+                raw = await self.write_raw(article, article_outline, chap, sec, subsec, cm, instruction)
+            if edt := await text("Edit", default=raw).ask_async():
+                raw = edt
 
             r_print(raw)
 
@@ -120,11 +133,14 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         sec: ArticleSection,
         subsec: ArticleSubsection,
     ) -> ArticleSubsection:
-        ret = await self.search_database(article, article_outline, chap, sec, subsec)
-        cm = CitationManager(article_chunks=ret).set_cite_number_all()
+        cm = CitationManager()
+
+        await self.search_database(article, article_outline, chap, sec, subsec, cm)
 
         raw_paras = await self.write_raw(article, article_outline, chap, sec, subsec, cm)
 
+        raw_paras = "\n".join(p for p in raw_paras.splitlines() if p and not p.endswith("**") and not p.startswith("#"))
+
         return await self.extract_new_subsec(subsec, raw_paras, cm)
 
     async def extract_new_subsec(
@@ -138,6 +154,7 @@ class WriteArticleContentRAG(Action, RAG, Extract):
                 f"Above is the subsection titled `{subsec.title}`.\n"
                 f"I need you to extract the content to update my subsection obj provided below.\n{self.req}"
                 f"{subsec.display()}\n",
+                model=self.extractor_model,
             ),
             "Failed to propose new subsection.",
         )
@@ -161,12 +178,15 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         return (
             (
                 await self.aask(
-                    f"{cm.as_prompt()}\nAbove is some related reference retrieved for you."
+                    f"{cm.as_prompt()}\nAbove is some related reference from other auther retrieved for you."
                     f"{article_outline.finalized_dump()}\n\nAbove is my article outline, I m writing graduate thesis titled `{article.title}`. "
                     f"More specifically, i m witting the Chapter `{chap.title}` >> Section `{sec.title}` >> Subsection `{subsec.title}`.\n"
                     f"Please help me write the paragraphs of the subsec mentioned above, which is `{subsec.title}`.\n"
                     f"{self.req}\n"
-                    f"You SHALL use `{article.language}` as writing language.\n{extra_instruction}"
+                    f"You SHALL use `{article.language}` as writing language.\n{extra_instruction}\n"
+                    f"Do not use numbered list to display the outcome, you should regard you are writing the main text of the thesis.\n"
+                    f"You should not copy others' works from the references directly on to my thesis, we can only harness the conclusion they have drawn.\n"
+                    f"No extra explanation is allowed."
                 )
             )
             .replace(r" \( ", "$")
@@ -174,7 +194,9 @@ class WriteArticleContentRAG(Action, RAG, Extract):
             .replace(r"\(", "$")
             .replace(r"\)", "$")
             .replace("\\[\n", "$$\n")
+            .replace("\\[ ", "$$\n")
             .replace("\n\\]", "\n$$")
+            .replace(" \\]", "\n$$")
         )
 
     async def search_database(
@@ -184,27 +206,113 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         chap: ArticleChapter,
         sec: ArticleSection,
         subsec: ArticleSubsection,
+        cm: CitationManager,
         extra_instruction: str = "",
-    ) -> List[ArticleChunk]:
+        supervisor: bool = False,
+    ) -> None:
         """Search database for related references."""
+        search_req = (
+            f"{article_outline.finalized_dump()}\n\nAbove is my article outline, I m writing graduate thesis titled `{article.title}`. "
+            f"More specifically, i m witting the Chapter `{chap.title}` >> Section `{sec.title}` >> Subsection `{subsec.title}`.\n"
+            f"I need to search related references to build up the content of the subsec mentioned above, which is `{subsec.title}`.\n"
+            f"provide 10~16 queries as possible, to get best result!\n"
+            f"You should provide both English version and chinese version of the refined queries!\n{extra_instruction}\n"
+        )
+
         ref_q = ok(
             await self.arefined_query(
-                f"{article_outline.finalized_dump()}\n\nAbove is my article outline, I m writing graduate thesis titled `{article.title}`. "
-                f"More specifically, i m witting the Chapter `{chap.title}` >> Section `{sec.title}` >> Subsection `{subsec.title}`.\n"
-                f"I need to search related references to build up the content of the subsec mentioned above, which is `{subsec.title}`.\n"
-                f"provide 10~16 queries as possible, to get best result!\n"
-                f"You should provide both English version and chinese version of the refined queries!\n{extra_instruction}\n",
+                search_req,
                 model=self.query_model,
             ),
             "Failed to refine query.",
         )
 
-        if self.supervisor:
+        if supervisor:
+            ref_q = await ask_retain(ref_q)
+        ret = await self.aretrieve(
+            ref_q,
+            ArticleChunk,
+            final_limit=self.ref_limit,
+            result_per_query=self.result_per_query,
+            similarity_threshold=self.threshold,
+        )
+
+        cm.add_chunks(ok(ret))
+        ref_q = await self.arefined_query(
+            f"{cm.as_prompt()}\n\nAbove is the retrieved references in the first RAG, now we need to perform the second RAG.\n\n{search_req}",
+            model=self.query_model,
+        )
+
+        if ref_q is None:
+            logger.warning("Second refine query is None, skipping.")
+            return
+        if supervisor:
             ref_q = await ask_retain(ref_q)
 
-        return await self.aretrieve(
-            ref_q, ArticleChunk, final_limit=self.ref_limit, result_per_query=3, similarity_threshold=self.threshold
+        ret = await self.aretrieve(
+            ref_q,
+            ArticleChunk,
+            final_limit=int(self.ref_limit * self.search_increment_multiplier),
+            result_per_query=int(self.result_per_query * self.search_increment_multiplier),
+            similarity_threshold=self.threshold,
         )
+        if ret is None:
+            logger.warning("Second retrieve is None, skipping.")
+            return
+        cm.add_chunks(ret)
+
+
+class ArticleConsultRAG(Action, RAG):
+    """Write an article based on the provided outline."""
+
+    output_key: str = "consult_count"
+
+    ref_limit: int = 20
+    """The final limit of references."""
+    ref_per_q: int = 3
+    """The limit of references to retrieve per query."""
+    similarity_threshold: float = 0.62
+    """The similarity threshold of references to retrieve."""
+    ref_q_model: Optional[str] = None
+    """The model to use for refining query."""
+    req: str = TYPST_CITE_USAGE
+    """The request for the rag model."""
+
+    @precheck_package(
+        "questionary", "`questionary` is required for supervisor mode, please install it by `fabricatio[qa]`"
+    )
+    async def _execute(self, collection_name: Optional[str] = None, **cxt) -> int:
+        from questionary import confirm, text
+        from rich import print as r_print
+
+        from fabricatio.rust import convert_all_block_tex, convert_all_inline_tex
+
+        self.target_collection = collection_name or self.safe_target_collection
+
+        cm = CitationManager()
+
+        counter = 0
+        while (req := await text("User: ").ask_async()) is not None:
+            if await confirm("Empty the cm?").ask_async():
+                cm.empty()
+            ref_q = await self.arefined_query(req, model=self.ref_q_model)
+            refs = await self.aretrieve(
+                ok(ref_q, "Failed to refine query."),
+                ArticleChunk,
+                final_limit=self.ref_limit,
+                result_per_query=self.ref_per_q,
+                similarity_threshold=self.similarity_threshold,
+            )
+
+            ret = await self.aask(f"{cm.add_chunks(refs).as_prompt()}\n{self.req}\n{req}")
+            ret = convert_all_inline_tex(ret)
+            ret = convert_all_block_tex(ret)
+            ret = cm.apply(ret)
+
+            r_print(ret)
+            counter += 1
+        logger.info(f"{counter} rounds of conversation.")
+        return counter
 
 
 class TweakArticleRAG(Action, RAG, Censor):

fabricatio/actions/output.py

@@ -1,16 +1,18 @@
 """Dump the finalized output to a file."""
 
 from pathlib import Path
-from typing import Any, Iterable, List, Mapping, Optional, Type
+from typing import Any, Dict, Iterable, List, Mapping, Optional, Type
 
+from fabricatio import TEMPLATE_MANAGER
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
 from fabricatio.models.generic import FinalizedDumpAble, FromMapping, PersistentAble
 from fabricatio.models.task import Task
+from fabricatio.models.usages import LLMUsage
 from fabricatio.utils import ok
 
 
-class DumpFinalizedOutput(Action):
+class DumpFinalizedOutput(Action, LLMUsage):
     """Dump the finalized output to a file."""
 
     output_key: str = "dump_path"
@@ -38,7 +40,37 @@ class DumpFinalizedOutput(Action):
         return dump_path.as_posix()
 
 
-class PersistentAll(Action):
+class RenderedDump(Action, LLMUsage):
+    """Render the data to a file."""
+
+    output_key: str = "dump_path"
+    dump_path: Optional[str] = None
+
+    template_name: str
+    """The template name to render the data."""
+
+    async def _execute(
+        self,
+        to_dump: Dict[str, Any],
+        task_input: Optional[Task] = None,
+        dump_path: Optional[str | Path] = None,
+        **_,
+    ) -> str:
+        dump_path = Path(
+            dump_path
+            or self.dump_path
+            or ok(
+                await self.awhich_pathstr(
+                    f"{ok(task_input, 'Neither `task_input` and `dump_path` is provided.').briefing}\n\nExtract a single path of the file, to which I will dump the data."
+                ),
+                "Could not find the path of file to dump the data.",
+            )
+        )
+        logger.info(f"Saving output to {dump_path.as_posix()}")
+        return TEMPLATE_MANAGER.render_template(self.template_name, to_dump)
+
+
+class PersistentAll(Action, LLMUsage):
     """Persist all the data to a file."""
 
     output_key: str = "persistent_count"

fabricatio/config.py

@@ -328,9 +328,9 @@ class RoutingConfig(BaseModel):
     allowed_fails: Optional[int] = 3
     """The number of allowed fails before the routing is considered failed."""
     retry_after: int = 15
-    """The time in seconds to wait before retrying the routing after a fail."""
-    cooldown_time: Optional[int] = 30
-    """The time in seconds to wait before retrying the routing after a cooldown."""
+    """Minimum time to wait before retrying a failed request."""
+    cooldown_time: Optional[int] = 60
+    """Time to cooldown a deployment after failure in seconds."""
 
 
 class Settings(BaseSettings):

fabricatio/fs/curd.py

@@ -20,7 +20,7 @@ def dump_text(path: Union[str, Path], text: str) -> None:
     Returns:
         None
     """
-    Path(path).write_text(text, encoding="utf-8", errors="ignore")
+    Path(path).write_text(text, encoding="utf-8", errors="ignore", newline="\n")
 
 
 def copy_file(src: Union[str, Path], dst: Union[str, Path]) -> None:

fabricatio/models/action.py

@@ -12,12 +12,13 @@ Classes:
 import traceback
 from abc import abstractmethod
 from asyncio import Queue, create_task
-from typing import Any, Dict, Self, Tuple, Type, Union, final
+from typing import Any, Dict, Self, Sequence, Tuple, Type, Union, final
 
 from fabricatio.journal import logger
 from fabricatio.models.generic import WithBriefing
 from fabricatio.models.task import Task
-from fabricatio.models.usages import LLMUsage, ToolBoxUsage
+from fabricatio.models.usages import ToolBoxUsage
+from fabricatio.utils import override_kwargs
 from pydantic import Field, PrivateAttr
 
 OUTPUT_KEY = "task_output"
@@ -25,7 +26,7 @@ OUTPUT_KEY = "task_output"
 INPUT_KEY = "task_input"
 
 
-class Action(WithBriefing, LLMUsage):
+class Action(WithBriefing):
     """Class that represents an action to be executed in a workflow.
 
     Actions are the atomic units of work in a workflow. Each action performs
@@ -55,7 +56,7 @@ class Action(WithBriefing, LLMUsage):
         self.description = self.description or self.__class__.__doc__ or ""
 
     @abstractmethod
-    async def _execute(self, *_:Any, **cxt) -> Any:
+    async def _execute(self, *_: Any, **cxt) -> Any:
         """Implement the core logic of the action.
 
         Args:
@@ -95,11 +96,12 @@ class Action(WithBriefing, LLMUsage):
             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}"
 
-    def to_task_output(self)->Self:
+    def to_task_output(self, task_output_key: str = OUTPUT_KEY) -> Self:
         """Set the output key to OUTPUT_KEY and return the action instance."""
-        self.output_key=OUTPUT_KEY
+        self.output_key = task_output_key
         return self
 
+
 class WorkFlow(WithBriefing, ToolBoxUsage):
     """Manages sequences of actions to fulfill tasks.
 
@@ -121,9 +123,7 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
     _instances: Tuple[Action, ...] = PrivateAttr(default_factory=tuple)
     """Instantiated action objects to be executed in this workflow."""
 
-    steps: Tuple[Union[Type[Action], Action], ...] = Field(
-        frozen=True,
-    )
+    steps: Sequence[Union[Type[Action], Action]] = Field(frozen=True)
     """The sequence of actions to be executed, can be action classes or instances."""
 
     task_input_key: str = Field(default=INPUT_KEY)
@@ -177,7 +177,7 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
         current_action = None
         try:
             # Process each action in sequence
-            for i,step in enumerate(self._instances):
+            for i, step in enumerate(self._instances):
                 current_action = step.name
                 logger.info(f"Executing step [{i}] >> {current_action}")
 
@@ -227,8 +227,13 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
             - Any extra_init_context values
         """
         logger.debug(f"Initializing context for workflow: {self.name}")
-        initial_context = {self.task_input_key: task, **dict(self.extra_init_context)}
-        await self._context.put(initial_context)
+        ctx = override_kwargs(self.extra_init_context, **task.extra_init_context)
+        if self.task_input_key in ctx:
+            raise ValueError(
+                f"Task input key: `{self.task_input_key}`, which is reserved, is already set in the init context"
+            )
+
+        await self._context.put({self.task_input_key: task, **ctx})
 
     def steps_fallback_to_self(self) -> Self:
         """Configure all steps to use this workflow's configuration as fallback.
@@ -245,7 +250,7 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
         Returns:
             Self: The workflow instance for method chaining.
         """
-        self.provide_tools_to(i for i in self._instances if isinstance(i,ToolBoxUsage))
+        self.provide_tools_to(i for i in self._instances if isinstance(i, ToolBoxUsage))
         return self
 
     def update_init_context(self, /, **kwargs) -> Self:

fabricatio/models/extra/aricle_rag.py

@@ -9,7 +9,7 @@ from fabricatio.journal import logger
 from fabricatio.models.extra.rag import MilvusDataBase
 from fabricatio.models.generic import AsPrompt
 from fabricatio.models.kwargs_types import ChunkKwargs
-from fabricatio.rust import BibManager, is_chinese, split_into_chunks
+from fabricatio.rust import BibManager, blake3_hash, split_into_chunks
 from fabricatio.utils import ok
 from more_itertools.recipes import flatten, unique
 from pydantic import Field
@@ -53,7 +53,7 @@ class ArticleChunk(MilvusDataBase, AsPrompt):
 
     def _as_prompt_inner(self) -> Dict[str, str]:
         return {
-            f"[[{ok(self._cite_number, 'You need to update cite number first.')}]] reference `{self.article_title}`": self.chunk
+            f"[[{ok(self._cite_number, 'You need to update cite number first.')}]] reference `{self.article_title}` from {self.as_auther_seq()}": self.chunk
         }
 
     @property
@@ -139,15 +139,9 @@ class ArticleChunk(MilvusDataBase, AsPrompt):
         return re.sub(r"\[[\d\s,\\~–-]+]", "", string)
 
     @property
-    def auther_firstnames(self) -> List[str]:
-        """Get the first name of the authors."""
-        ret = []
-        for n in self.authors:
-            if is_chinese(n):
-                ret.append(n[0])
-            else:
-                ret.append(n.split()[-1])
-        return ret
+    def auther_lastnames(self) -> List[str]:
+        """Get the last name of the authors."""
+        return [n.split()[-1] for n in self.authors]
 
     def as_auther_seq(self) -> str:
         """Get the auther sequence."""
@@ -155,13 +149,13 @@ class ArticleChunk(MilvusDataBase, AsPrompt):
             case 0:
                 raise ValueError("No authors found")
             case 1:
-                return f"（{self.auther_firstnames[0]}，{self.year}）{self.as_typst_cite()}"
+                return f"（{self.auther_lastnames[0]}，{self.year}）{self.as_typst_cite()}"
             case 2:
-                return f"（{self.auther_firstnames[0]}{self.and_word}{self.auther_firstnames[1]}，{self.year}）{self.as_typst_cite()}"
+                return f"（{self.auther_lastnames[0]}{self.and_word}{self.auther_lastnames[1]}，{self.year}）{self.as_typst_cite()}"
             case 3:
-                return f"（{self.auther_firstnames[0]}，{self.auther_firstnames[1]}{self.and_word}{self.auther_firstnames[2]}，{self.year}）{self.as_typst_cite()}"
+                return f"（{self.auther_lastnames[0]}，{self.auther_lastnames[1]}{self.and_word}{self.auther_lastnames[2]}，{self.year}）{self.as_typst_cite()}"
             case _:
-                return f"（{self.auther_firstnames[0]}，{self.auther_firstnames[1]}{self.and_word}{self.auther_firstnames[2]}{self.etc_word}，{self.year}）{self.as_typst_cite()}"
+                return f"（{self.auther_lastnames[0]}，{self.auther_lastnames[1]}{self.and_word}{self.auther_lastnames[2]}{self.etc_word}，{self.year}）{self.as_typst_cite()}"
 
     def update_cite_number(self, cite_number: int) -> Self:
         """Update the cite number."""
@@ -182,20 +176,32 @@ class CitationManager(AsPrompt):
     abbr_sep: str = "-"
     """Separator for abbreviated citation numbers."""
 
-    def update_chunks(self, article_chunks: List[ArticleChunk], set_cite_number: bool = True) -> Self:
+    def update_chunks(
+        self, article_chunks: List[ArticleChunk], set_cite_number: bool = True, dedup: bool = True
+    ) -> Self:
         """Update article chunks."""
         self.article_chunks.clear()
         self.article_chunks.extend(article_chunks)
+        if dedup:
+            self.article_chunks = list(unique(self.article_chunks, lambda c: blake3_hash(c.chunk.encode())))
         if set_cite_number:
             self.set_cite_number_all()
         return self
 
-    def add_chunks(self, article_chunks: List[ArticleChunk], set_cite_number: bool = True)-> Self:
+    def empty(self) -> Self:
+        """Empty the article chunks."""
+        self.article_chunks.clear()
+        return self
+
+    def add_chunks(self, article_chunks: List[ArticleChunk], set_cite_number: bool = True, dedup: bool = True) -> Self:
         """Add article chunks."""
         self.article_chunks.extend(article_chunks)
+        if dedup:
+            self.article_chunks = list(unique(self.article_chunks, lambda c: blake3_hash(c.chunk.encode())))
         if set_cite_number:
             self.set_cite_number_all()
         return self
+
     def set_cite_number_all(self) -> Self:
         """Set citation numbers for all article chunks."""
         for i, a in enumerate(self.article_chunks, 1):
@@ -208,7 +214,7 @@ class CitationManager(AsPrompt):
 
     def apply(self, string: str) -> str:
         """Apply citation replacements to the input string."""
-        for origin,m in re.findall(self.pat, string):
+        for origin, m in re.findall(self.pat, string):
             logger.info(f"Matching citation: {m}")
             notations = self.convert_to_numeric_notations(m)
             logger.info(f"Citing Notations: {notations}")
@@ -216,9 +222,26 @@ class CitationManager(AsPrompt):
             logger.info(f"Citation Number Sequence: {citation_number_seq}")
             dedup = self.deduplicate_citation(citation_number_seq)
             logger.info(f"Deduplicated Citation Number Sequence: {dedup}")
-            string=string.replace(origin, self.unpack_cite_seq(dedup))
+            string = string.replace(origin, self.unpack_cite_seq(dedup))
         return string
 
+    def citation_count(self, string: str) -> int:
+        """Get the citation count in the string."""
+        count = 0
+        for _, m in re.findall(self.pat, string):
+            logger.info(f"Matching citation: {m}")
+            notations = self.convert_to_numeric_notations(m)
+            logger.info(f"Citing Notations: {notations}")
+            citation_number_seq = list(flatten(self.decode_expr(n) for n in notations))
+            logger.info(f"Citation Number Sequence: {citation_number_seq}")
+            count += len(dedup := self.deduplicate_citation(citation_number_seq))
+            logger.info(f"Deduplicated Citation Number Sequence: {dedup}")
+        return count
+
+    def citation_coverage(self, string: str) -> float:
+        """Get the citation coverage in the string."""
+        return self.citation_count(string) / len(self.article_chunks)
+
     def decode_expr(self, string: str) -> List[int]:
         """Decode citation expression into a list of integers."""
         if self.abbr_sep in string:

fabricatio/models/extra/article_base.py

@@ -46,6 +46,16 @@ class ArticleMetaData(SketchedAble, Described, WordCount, Titled, Language):
     aims: List[str]
     """List of writing aims of the research component in academic style."""
 
+    @property
+    def typst_metadata_comment(self) -> str:
+        """Generates a comment for the metadata of the article component."""
+        return comment(
+            (f"Desc:\n  {self.description}\n" if self.description else "")
+            + (f"Aims:\n  {'\n  '.join(self.aims)}\n" if self.aims else "")
+            + (f"Expected Word Count:{self.expected_word_count}" if self.expected_word_count else "")
+
+        )
+
 
 class ArticleOutlineBase(
     ArticleMetaData,
@@ -89,13 +99,7 @@ class SubSectionBase(ArticleOutlineBase):
 
     def to_typst_code(self) -> str:
         """Converts the component into a Typst code snippet for rendering."""
-        return (
-            f"=== {self.title}\n"
-            f"{comment(f'Desc:\n{self.description}\nAims:\n{"\n".join(self.aims)}')}\n"
-            + f"Expected Word Count:{self.expected_word_count}"
-            if self.expected_word_count
-            else ""
-        )
+        return f"=== {self.title}\n{self.typst_metadata_comment}\n"
 
     def introspect(self) -> str:
         """Introspects the article subsection outline."""
@@ -120,13 +124,9 @@ class SectionBase[T: SubSectionBase](ArticleOutlineBase):
         Returns:
             str: The formatted Typst code snippet.
         """
-        return (
-            f"== {self.title}\n"
-            f"{comment(f'Desc:\n{self.description}\nAims:\n{"\n".join(self.aims)}')}\n"
-            + f"Expected Word Count:{self.expected_word_count}"
-            if self.expected_word_count
-            else ""
-        ) + "\n\n".join(subsec.to_typst_code() for subsec in self.subsections)
+        return f"== {self.title}\n{self.typst_metadata_comment}\n" + "\n\n".join(
+            subsec.to_typst_code() for subsec in self.subsections
+        )
 
     def resolve_update_conflict(self, other: Self) -> str:
         """Resolve update errors in the article outline."""
@@ -169,13 +169,9 @@ class ChapterBase[T: SectionBase](ArticleOutlineBase):
 
     def to_typst_code(self) -> str:
         """Converts the chapter into a Typst formatted code snippet for rendering."""
-        return (
-            f"= {self.title}\n"
-            f"{comment(f'Desc:\n{self.description}\nAims:\n{"\n".join(self.aims)}')}\n"
-            + f"Expected Word Count:{self.expected_word_count}"
-            if self.expected_word_count
-            else ""
-        ) + "\n\n".join(sec.to_typst_code() for sec in self.sections)
+        return f"= {self.title}\n{self.typst_metadata_comment}\n" + "\n\n".join(
+            sec.to_typst_code() for sec in self.sections
+        )
 
     def resolve_update_conflict(self, other: Self) -> str:
         """Resolve update errors in the article outline."""
@@ -317,8 +313,41 @@ class ArticleBase[T: ChapterBase](FinalizedDumpAble, AsPrompt, WordCount, Descri
             === Implementation Details
             == Evaluation Protocol
         """
-        return comment(
-            f"Title:{self.title}\nDesc:\n{self.description}\n" + f"Word Count:{self.expected_word_count}"
-            if self.expected_word_count
-            else ""
-        ) + "\n\n".join(a.to_typst_code() for a in self.chapters)
+        return (
+            comment(
+                f"Title:{self.title}\n"
+                + (f"Desc:\n{self.description}\n" if self.description else "")
+                + f"Word Count:{self.expected_word_count}"
+                if self.expected_word_count
+                else ""
+            )
+            + "\n\n"
+            + "\n\n".join(a.to_typst_code() for a in self.chapters)
+        )
+
+    def avg_chap_wordcount[S](self: S) -> S:
+        """Set all chap have same word count sum up to be `self.expected_word_count`."""
+        avg = int(self.expected_word_count / len(self.chapters))
+        for c in self.chapters:
+            c.expected_word_count = avg
+        return self
+
+    def avg_sec_wordcount[S](self: S) -> S:
+        """Set all sec have same word count sum up to be `self.expected_word_count`."""
+        for c in self.chapters:
+            avg = int(c.expected_word_count / len(c.sections))
+            for s in c.sections:
+                s.expected_word_count = avg
+        return self
+
+    def avg_subsec_wordcount[S](self: S) -> S:
+        """Set all subsec have same word count sum up to be `self.expected_word_count`."""
+        for _, s in self.iter_sections():
+            avg = int(s.expected_word_count / len(s.subsections))
+            for ss in s.subsections:
+                ss.expected_word_count = avg
+        return self
+
+    def avg_wordcount_recursive(self) -> Self:
+        """Set all chap, sec, subsec have same word count sum up to be `self.expected_word_count`."""
+        return self.avg_chap_wordcount().avg_sec_wordcount().avg_sec_wordcount()

fabricatio/models/extra/article_main.py

@@ -12,10 +12,14 @@ from fabricatio.models.extra.article_base import (
     SubSectionBase,
 )
 from fabricatio.models.extra.article_outline import (
+    ArticleChapterOutline,
     ArticleOutline,
+    ArticleSectionOutline,
+    ArticleSubsectionOutline,
 )
 from fabricatio.models.generic import Described, PersistentAble, SequencePatch, SketchedAble, WithRef, WordCount
 from fabricatio.rust import convert_all_block_tex, convert_all_inline_tex, word_count
+from fabricatio.utils import fallback_kwargs
 from pydantic import Field, NonNegativeInt
 
 PARAGRAPH_SEP = "// - - -"
@@ -89,7 +93,7 @@ class ArticleSubsection(SubSectionBase):
         Returns:
             str: Typst code snippet for rendering.
         """
-        return f"=== {self.title}\n" + f"\n{PARAGRAPH_SEP}\n".join(p.content for p in self.paragraphs)
+        return super().to_typst_code() + f"\n\n{PARAGRAPH_SEP}\n\n".join(p.content for p in self.paragraphs)
 
     @classmethod
     def from_typst_code(cls, title: str, body: str) -> Self:
@@ -181,6 +185,50 @@ class Article(
     def iter_subsections(self) -> Generator[Tuple[ArticleChapter, ArticleSection, ArticleSubsection], None, None]:
         return super().iter_subsections()  # pyright: ignore [reportReturnType]
 
+    def extrac_outline(self) -> ArticleOutline:
+        """Extract outline from article."""
+        # Create an empty list to hold chapter outlines
+        chapters = []
+
+        # Iterate through each chapter in the article
+        for chapter in self.chapters:
+            # Create an empty list to hold section outlines
+            sections = []
+
+            # Iterate through each section in the chapter
+            for section in chapter.sections:
+                # Create an empty list to hold subsection outlines
+                subsections = []
+
+                # Iterate through each subsection in the section
+                for subsection in section.subsections:
+                    # Create a subsection outline and add it to the list
+                    subsections.append(
+                        ArticleSubsectionOutline(**subsection.model_dump(exclude={"paragraphs"}, by_alias=True))
+                    )
+
+                # Create a section outline and add it to the list
+                sections.append(
+                    ArticleSectionOutline(
+                        **section.model_dump(exclude={"subsections"}, by_alias=True),
+                        subsections=subsections,
+                    )
+                )
+
+            # Create a chapter outline and add it to the list
+            chapters.append(
+                ArticleChapterOutline(
+                    **chapter.model_dump(exclude={"sections"}, by_alias=True),
+                    sections=sections,
+                )
+            )
+
+        # Create and return the article outline
+        return ArticleOutline(
+            **self.model_dump(exclude={"chapters"}, by_alias=True),
+            chapters=chapters,
+        )
+
     @classmethod
     def from_outline(cls, outline: ArticleOutline) -> "Article":
         """Generates an article from the given outline.
@@ -218,15 +266,18 @@ class Article(
         return article
 
     @classmethod
-    def from_typst_code(cls, title: str, body: str) -> Self:
+    def from_typst_code(cls, title: str, body: str, **kwargs) -> Self:
         """Generates an article from the given Typst code."""
         return cls(
             chapters=[
                 ArticleChapter.from_typst_code(*pack) for pack in extract_sections(body, level=1, section_char="=")
             ],
             heading=title,
-            expected_word_count=word_count(body),
-            abstract="",
+            **fallback_kwargs(
+                kwargs,
+                expected_word_count=word_count(body),
+                abstract="",
+            ),
         )
 
     @classmethod
@@ -248,3 +299,4 @@ class Article(
 
         for a in self.iter_dfs():
             a.title = await text(f"Edit `{a.title}`.", default=a.title).ask_async() or a.title
+        return self

fabricatio/models/generic.py

@@ -122,7 +122,7 @@ class FromMapping(Base):
 
     @classmethod
     @abstractmethod
-    def from_mapping(cls, mapping: Mapping[str, Any], **kwargs: Any) -> List[Self]:
+    def from_mapping[S](cls: S, mapping: Mapping[str, Any], **kwargs: Any) -> List[S]:
         """Generate a list of objects from a mapping."""
 
 
@@ -186,7 +186,7 @@ class WithRef[T](Base):
     @overload
     def update_ref[S: WithRef](self: S, reference: None = None) -> S: ...
 
-    def update_ref[S: WithRef](self: S, reference: Union[T, "WithRef[T]", None] = None) -> S:  # noqa: PYI019
+    def update_ref[S: WithRef](self: S, reference: Union[T, "WithRef[T]", None] = None) -> S:
         """Update the reference of the object.
 
         Args:
@@ -201,7 +201,7 @@ class WithRef[T](Base):
             self._reference = reference  # pyright: ignore [reportAttributeAccessIssue]
         return self
 
-    def derive[S: WithRef](self: S, reference: Any) -> S:  # noqa: PYI019
+    def derive[S: WithRef](self: S, reference: Any) -> S:
         """Derive a new object from the current object.
 
         Args:
@@ -789,7 +789,7 @@ class ScopedConfig(Base):
     """The dimensions of the Milvus server."""
 
     @final
-    def fallback_to(self, other: "ScopedConfig") -> Self:
+    def fallback_to(self, other: Union["ScopedConfig", Any]) -> Self:
         """Merge configuration values with fallback priority.
 
         Copies non-null values from 'other' to self where current values are None.
@@ -800,6 +800,9 @@ class ScopedConfig(Base):
         Returns:
             Self: Current instance with merged values
         """
+        if not isinstance(other, ScopedConfig):
+            return self
+
         # Iterate over the attribute names and copy values from 'other' to 'self' where applicable
         # noinspection PydanticTypeChecker,PyTypeChecker
         for attr_name in ScopedConfig.model_fields:
@@ -811,7 +814,7 @@ class ScopedConfig(Base):
         return self
 
     @final
-    def hold_to(self, others: Union["ScopedConfig", Iterable["ScopedConfig"]]) -> Self:
+    def hold_to(self, others: Union[Union["ScopedConfig", Any], Iterable[Union["ScopedConfig", Any]]]) -> Self:
         """Propagate non-null values to other configurations.
 
         Copies current non-null values to target configurations where they are None.
@@ -824,7 +827,8 @@ class ScopedConfig(Base):
         """
         if not isinstance(others, Iterable):
             others = [others]
-        for other in others:
+
+        for other in (o for o in others if isinstance(o, ScopedConfig)):
             # noinspection PyTypeChecker,PydanticTypeChecker
             for attr_name in ScopedConfig.model_fields:
                 if (attr := getattr(self, attr_name)) is not None and getattr(other, attr_name) is None:

fabricatio/models/kwargs_types.py

@@ -33,7 +33,7 @@ class LLMKwargs(TypedDict, total=False):
     including generation parameters and caching options.
     """
 
-    model: str
+    model: Optional[str]
     temperature: float
     stop: str | list[str]
     top_p: float

fabricatio/models/role.py

@@ -2,18 +2,18 @@
 
 from typing import Any, Self, Set
 
-from fabricatio.capabilities.correct import Correct
-from fabricatio.capabilities.task import HandleTask, ProposeTask
+from fabricatio.capabilities.propose import Propose
 from fabricatio.core import env
 from fabricatio.journal import logger
 from fabricatio.models.action import WorkFlow
 from fabricatio.models.events import Event
 from fabricatio.models.generic import WithBriefing
 from fabricatio.models.tool import ToolBox
+from fabricatio.models.usages import ToolBoxUsage
 from pydantic import Field
 
 
-class Role(WithBriefing, ProposeTask, HandleTask, Correct):
+class Role(WithBriefing, Propose, ToolBoxUsage):
     """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
@@ -23,7 +23,8 @@ class Role(WithBriefing, ProposeTask, HandleTask, Correct):
         registry: Mapping of events to workflows that handle them
         toolboxes: Set of toolboxes available to this role and its workflows
     """
-    description:str =""
+
+    description: str = ""
     """A brief description of the role's responsibilities and capabilities."""
 
     registry: dict[Event | str, WorkFlow] = Field(default_factory=dict)

fabricatio/models/task.py

@@ -4,7 +4,7 @@ It includes methods to manage the task's lifecycle, such as starting, finishing,
 """
 
 from asyncio import Queue
-from typing import Any, List, Optional, Self
+from typing import Any, Dict, List, Optional, Self
 
 from fabricatio.config import configs
 from fabricatio.constants import TaskStatus
@@ -50,6 +50,18 @@ class Task[T](WithBriefing, ProposedAble, WithDependency):
 
     _namespace: Event = PrivateAttr(default_factory=Event)
     """The namespace of the task as an event, which is generated from the namespace list."""
+    _extra_init_context: Dict = PrivateAttr(default_factory=dict)
+    """Extra initialization context for the task, which is designed to override the one of the Workflow."""
+
+    @property
+    def extra_init_context(self) -> Dict:
+        """Extra initialization context for the task, which is designed to override the one of the Workflow."""
+        return self._extra_init_context
+
+    def update_init_context(self, /, **kwargs) -> Self:
+        """Update the extra initialization context for the task."""
+        self.extra_init_context.update(kwargs)
+        return self
 
     def model_post_init(self, __context: Any) -> None:
         """Initialize the task with a namespace event."""

fabricatio/models/usages.py

@@ -31,7 +31,7 @@ from pydantic import BaseModel, ConfigDict, Field, NonNegativeInt, PositiveInt
 
 if configs.cache.enabled and configs.cache.type:
     litellm.enable_cache(type=configs.cache.type, **configs.cache.params)
-    logger.success(f"{configs.cache.type.name} Cache enabled")
+    logger.debug(f"{configs.cache.type.name} Cache enabled")
 
 ROUTER = Router(
     routing_strategy="usage-based-routing-v2",

fabricatio/utils.py

@@ -47,21 +47,21 @@ async def ask_retain[V](candidates: List[str], value_mapping: Optional[List[V]]
         "Please choose those that should be retained.",
         choices=[Choice(p, value=p, checked=True) for p in candidates]
         if value_mapping is None
-        else [Choice(p, value=v) for p, v in zip(candidates, value_mapping, strict=True)],
+        else [Choice(p, value=v, checked=True) for p, v in zip(candidates, value_mapping, strict=True)],
     ).ask_async()
 
 
 def override_kwargs(kwargs: Mapping[str, Any], **overrides) -> Dict[str, Any]:
     """Override the values in kwargs with the provided overrides."""
     new_kwargs = dict(kwargs.items())
-    new_kwargs.update({k: v for k, v in overrides.items() if v is not None})
+    new_kwargs.update(overrides)
     return new_kwargs
 
 
-def fallback_kwargs(kwargs: Mapping[str, Any], **overrides) -> Dict[str, Any]:
-    """Fallback the values in kwargs with the provided overrides."""
+def fallback_kwargs(kwargs: Mapping[str, Any], **fallbacks) -> Dict[str, Any]:
+    """Fallback the values in kwargs with the provided fallbacks."""
     new_kwargs = dict(kwargs.items())
-    new_kwargs.update({k: v for k, v in overrides.items() if k not in new_kwargs and v is not None})
+    new_kwargs.update({k: v for k, v in fallbacks.items() if k not in new_kwargs})
     return new_kwargs
 
 

{fabricatio-0.2.11.dev2.dist-info → fabricatio-0.2.12.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.11.dev2
+Version: 0.2.12.dev1
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -20,18 +20,20 @@ Requires-Dist: pydantic-settings>=2.7.1
 Requires-Dist: pymitter>=1.0.0
 Requires-Dist: rich>=13.9.4
 Requires-Dist: ujson>=5.10.0
-Requires-Dist: fabricatio[calc,ftd,plot,qa,rag] ; extra == 'full'
+Requires-Dist: fabricatio[calc,ftd,plot,qa,rag,cli] ; extra == 'full'
 Requires-Dist: pymilvus>=2.5.4 ; extra == 'rag'
 Requires-Dist: sympy>=1.13.3 ; extra == 'calc'
 Requires-Dist: matplotlib>=3.10.1 ; extra == 'plot'
 Requires-Dist: questionary>=2.1.0 ; extra == 'qa'
 Requires-Dist: magika>=0.6.1 ; extra == 'ftd'
+Requires-Dist: typer-slim[standard]>=0.15.2 ; extra == 'cli'
 Provides-Extra: full
 Provides-Extra: rag
 Provides-Extra: calc
 Provides-Extra: plot
 Provides-Extra: qa
 Provides-Extra: ftd
+Provides-Extra: cli
 License-File: LICENSE
 Summary: A LLM multi-agent framework.
 Keywords: ai,agents,multi-agent,llm,pyo3

{fabricatio-0.2.11.dev2.dist-info → fabricatio-0.2.12.dev1.dist-info}/RECORD

@@ -1,49 +1,49 @@
-fabricatio-0.2.11.dev2.dist-info/METADATA,sha256=KLKZtUHG0VASxirXcBjV8AeFy-Ke-7zWvLZeZ9_bAbo,5035
-fabricatio-0.2.11.dev2.dist-info/WHEEL,sha256=7FgAcpQES0h1xhfN9Ugve9FTUilU6sRAr1WJ5ph2cuw,108
-fabricatio-0.2.11.dev2.dist-info/licenses/LICENSE,sha256=yDZaTLnOi03bi3Dk6f5IjhLUc5old2yOsihHWU0z-i0,1067
+fabricatio-0.2.12.dev1.dist-info/METADATA,sha256=qjBv5RTwJvd0KEFkb-OpKBorNX43NNrWf-3l5mhWOuk,5120
+fabricatio-0.2.12.dev1.dist-info/WHEEL,sha256=7FgAcpQES0h1xhfN9Ugve9FTUilU6sRAr1WJ5ph2cuw,108
+fabricatio-0.2.12.dev1.dist-info/licenses/LICENSE,sha256=yDZaTLnOi03bi3Dk6f5IjhLUc5old2yOsihHWU0z-i0,1067
 fabricatio/decorators.py,sha256=iuFCTtZ4VXwxJpM_z-CtrEpTaVZsv_eBFe5mOhe4wlo,8715
 fabricatio/constants.py,sha256=JxtaKGTf0IQhM-MNCHtr6x85Ejg8FWYcie-Z_RupCBg,557
 fabricatio/core.py,sha256=MaEKZ6DDmbdScAY-7F1gwGA6fr7ADX6Mz5rNVi2msFA,6277
-fabricatio/models/generic.py,sha256=lEMpFCo-kNL1OGWvtqE3DlI1KQyoShdI5YW-niiwNos,30267
+fabricatio/models/generic.py,sha256=a22CjQSlu-0WDdDVQiCIOddylaMFnv9lMLVuIeNKV1w,30392
 fabricatio/models/tool.py,sha256=VM3rMeDpUbeeFAKpsPfweJ2JGHf-w5f1voDnuhK99ew,12178
-fabricatio/models/role.py,sha256=iao4teYzY5QjfN1B2tEY5wbQq5afFz7jdhi6IziIong,2878
-fabricatio/models/kwargs_types.py,sha256=MI-P6_ZiCGzlyjwLNlMhHJbKb6fxXl_fBVHvPzDne1M,4608
+fabricatio/models/role.py,sha256=5SJ1Vm6H3FwOVEk5Z-4GBJWABI3OKAKwkz5t170osi8,2855
+fabricatio/models/kwargs_types.py,sha256=aI844DNQXLbSBC3P0bZQLJpuJxwwF66WTDbbYQTftaE,4618
 fabricatio/models/extra/article_proposal.py,sha256=4G2qLkMxtK54G1ANgPW0G3w4Pahxgk2lhGPU5KMxuzw,1818
 fabricatio/models/extra/advanced_judge.py,sha256=CKPP4Lseb_Ey8Y7i2V9HJfB-mZgCknFdqq7Zo41o6s4,1060
-fabricatio/models/extra/article_main.py,sha256=-8BlihRkBwIyhD5gA86w212ki7hxLElTFW7x-81WwHU,9568
+fabricatio/models/extra/article_main.py,sha256=kPa_y5j9eMOW7zfQn779On31CS2ckqZtnSFxOhkpGD8,11522
 fabricatio/models/extra/problem.py,sha256=1Sd8hsThQK6pXMXhErRhP1ft58z4PvqeB8AV8VcXiaI,7051
 fabricatio/models/extra/article_essence.py,sha256=zUfZ2_bX3h__RaVPwJlxQ-tkFyfSV8SdX8DsmFX6v_w,2649
 fabricatio/models/extra/rag.py,sha256=RWv_YJhDX6UL4t3sRtQt-LYMtxN-K-t931nmyiJXkKM,3857
 fabricatio/models/extra/article_outline.py,sha256=2vqMDhXwfRooHEe_cblkOj-4V96VsIAy68x22KBEQPQ,1387
 fabricatio/models/extra/__init__.py,sha256=0R9eZsCNu6OV-Xtf15H7FrqhfHTFBFf3fBrcd7ChsJ0,53
 fabricatio/models/extra/rule.py,sha256=b756_XmWeDoJ1qOFEGy6ZfP8O7rBjOZs4XvfZvWKXXI,2574
-fabricatio/models/extra/aricle_rag.py,sha256=2y9XBgCwi_9ZyMYEF2i3eKZO4oYEj4YgGtRdN9AS_p0,9538
-fabricatio/models/extra/article_base.py,sha256=K15Nw98DgLWZs-8CFrgJqE2r1GgpzFIuF_ftRHbB7yE,12516
+fabricatio/models/extra/aricle_rag.py,sha256=-w1fxs5PrsLTYPmNtUhWSeucQ9evnasUB75aMlzutL0,10722
+fabricatio/models/extra/article_base.py,sha256=QIcQbsp4-nE6OVpV82jLw1Ki1cXwvsQJVJns6sVhy14,13708
 fabricatio/models/extra/patches.py,sha256=_ghmnlvTZQq7UJyaH77mTZE9abjvxRJ2mgWHUbezUls,977
 fabricatio/models/adv_kwargs_types.py,sha256=659KMMuvdVq1xJxavLbUAMWxPOAz0RP9bNaZm3hyz-4,1890
-fabricatio/models/usages.py,sha256=GlzXWUBjX6AIThtDRMEydpU2eIbzlqOJuSnbCG7j3Ds,32573
+fabricatio/models/usages.py,sha256=FVRhh_AulXlJF9uUmJzKEdiLz-di0rAiaQm4snYEid0,32571
 fabricatio/models/events.py,sha256=-9Xy8kcZug1tYwxmt3GpXtCkNfZUMSFvAH5HdZoRJTI,4030
-fabricatio/models/task.py,sha256=dWbYnANDmOVh1Q1FAtk00qF4laNAJwc6xpjqQjXTcQ4,10204
-fabricatio/models/action.py,sha256=b4Ml_RSKzEQ_Tr_aHbsHlNRMiwOdK_8Ui6-Lh8psnfU,9576
+fabricatio/models/task.py,sha256=O4v5T3HuzYblGeeqNzTDOCbulhGovR6olV2ojD0FJvk,10785
+fabricatio/models/action.py,sha256=oOyxkhocfWDetfz9EEvAyDU1U3w0X1OrzdtwNHTxDr8,9854
 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
 fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fabricatio/fs/readers.py,sha256=hFHfGw1E58Da0ndBXXWcD2t-4HNdR1FimeDxuMI4-oE,1690
-fabricatio/fs/curd.py,sha256=QqwnyLdVALNnerYGXf6a0irqoPSNE9_GJV9bJ33kbl0,4610
+fabricatio/fs/curd.py,sha256=x7Je9V1ydv-BdZTjlLc3syZ6380gkOhpfrfnhXstisg,4624
 fabricatio/fs/__init__.py,sha256=abIYGDiX5bZ9vSHfro1-OtogzD_3vuR71FZMvZt8820,750
 fabricatio/rust_instances.py,sha256=i5fIt6XkE8UwUU4JarmPt50AZs8aJW6efaypSLGLl0I,303
-fabricatio/config.py,sha256=NbZu1AnHzR2VFOvzuBP5TSb9Jo3k17ODVuhL1jmT4-c,17559
-fabricatio/utils.py,sha256=wryb_mXFHLifA5GnmZGXpH-_EdlUBZiut2g_w6ueaVc,3052
+fabricatio/config.py,sha256=Zc2UG1Jf8u0XfwHR7yrApgynzdX_uC6jInMw8PDm64o,17526
+fabricatio/utils.py,sha256=DZDOsJN1FxTVqq-i1fAJZdLfDYxyVoMAJFQURuYt1rY,3004
 fabricatio/journal.py,sha256=Op0wC-JlZumnAc_aDmYM4ljnSNLoKEEMfcIRbCF69ow,455
 fabricatio/rust.pyi,sha256=EEZTQquqkHZ1G29YUPICwb9SJBzKgCB1B0ILuFNUoR0,10143
 fabricatio/__init__.py,sha256=OXoMMHJKHEB_vN97_34U4I5QpAKL9xnVQEVcBCvwBCg,986
 fabricatio/actions/fs.py,sha256=nlTmk-tYDW158nz_fzlsNfuYJwj7j4BHn_MFY5hxdqs,934
-fabricatio/actions/output.py,sha256=XudogHKTp-9qqB7fvqRRjtcKee3I-vZ0WepMeEE7qsI,6805
-fabricatio/actions/article_rag.py,sha256=tbvLM4Jaa-uBdA9_uz8Fernx9iVsqhYTIsFhHn7wFjA,13897
+fabricatio/actions/output.py,sha256=KR9SKDxLSp6rRWf0sriSGwITwe2HE506QGUP3yj-N4E,7891
+fabricatio/actions/article_rag.py,sha256=uGnHfw7fNzxHPXNB7ukXe9gfZaBrHtJRA54BVTnZVIc,18506
 fabricatio/actions/rag.py,sha256=-bA7KkZEFfWEanAPHzYwRHG7zRlTZcNDI7HL3n-lDuE,3496
 fabricatio/actions/__init__.py,sha256=ZMa1LeM5BNeqp-J-D32W-f5bD53-kdXGyt0zuueJofM,47
-fabricatio/actions/article.py,sha256=blqa4DYaFFw1n6qazeFrRD-vCEdZssGxBHJFFqWcM3I,9980
+fabricatio/actions/article.py,sha256=syUjEyKppdT72Xd1LSXKR3Djo1aybRPeFRHRzifNhm0,10632
 fabricatio/actions/rules.py,sha256=07ILsiwR250AUcKLPHTUPpWD_mPhPCfWKSkEAKcPv3A,3557
 fabricatio/workflows/articles.py,sha256=ZDV5nqUKRo1GOuuKWeSV7ZI32FYZU7WiTrD4YDuCeEo,945
 fabricatio/workflows/rag.py,sha256=uOZXprD479fUhLA6sYvEM8RWcVcUZXXtP0xRbTMPdHE,509
@@ -60,6 +60,6 @@ fabricatio/capabilities/review.py,sha256=EPL8IlxSKO0XStBkXdW7FJMbPztDQMv9w7tHgu6
 fabricatio/capabilities/propose.py,sha256=vOJvmmnMBHUQB6N1AmZNFw42jf7Bl2mBRNlBK15TpNI,1942
 fabricatio/capabilities/task.py,sha256=_BAQonNy5JH3JxhLmPGfn0nDvn_ENKXyOdql8EVXRLE,4362
 fabricatio/capabilities/extract.py,sha256=b4_Tuc9O6Pe71y4Tj-JHMb4simdhduVR-rcfD9yW8RA,2425
-fabricatio/rust.cpython-312-x86_64-linux-gnu.so,sha256=RMc1j9N5smoAD9ffKxSFOinOa3O2p7UlIf4y4n9F7lM,4435800
-fabricatio-0.2.11.dev2.data/scripts/tdown,sha256=bb3sOe5zM95YbGfmmxLTz4ZK3o-SFFAJ6Mdu6clF5Q8,4585440
-fabricatio-0.2.11.dev2.dist-info/RECORD,,
+fabricatio/rust.cpython-312-x86_64-linux-gnu.so,sha256=ABhIKEaDhWIR9Bx9rY2CqpwvJNBsxdXb1DDYQhbnhvI,4438896
+fabricatio-0.2.12.dev1.data/scripts/tdown,sha256=EEtn-cmxQQ9M1XIunkzQFqqGRRfo6WQXlk3mv7oFARw,4582192
+fabricatio-0.2.12.dev1.dist-info/RECORD,,