fabricatio 0.2.11.dev3__tar.gz → 0.2.12.dev2__tar.gz

{fabricatio-0.2.11.dev3 → fabricatio-0.2.12.dev2}/.gitignore

@@ -166,3 +166,5 @@ cython_debug/
 extra/scripts/*
 output/
 .vscode/
+templates/customed
+*.typ

{fabricatio-0.2.11.dev3 → fabricatio-0.2.12.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.11.dev3
+Version: 0.2.12.dev2
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12

fabricatio-0.2.12.dev2/examples/write_article/.gitignore

@@ -0,0 +1,4 @@
+article_briefing.txt
+article_outline_raw.txt
+out.typ
+persistent*

{fabricatio-0.2.11.dev3 → fabricatio-0.2.12.dev2}/examples/write_article/write_article.py

@@ -6,25 +6,26 @@ from pathlib import Path
 import typer
 from fabricatio import Event, Role, WorkFlow, logger
 from fabricatio.actions.article import ExtractOutlineFromRaw, GenerateArticleProposal, GenerateInitialOutline
-from fabricatio.actions.article_rag import WriteArticleContentRAG
-from fabricatio.actions.output import (
-    DumpFinalizedOutput,
-    PersistentAll,
-)
+from fabricatio.actions.article_rag import ArticleConsultRAG, WriteArticleContentRAG
+from fabricatio.actions.output import DumpFinalizedOutput, PersistentAll, RenderedDump
+from fabricatio.models.extra.article_outline import ArticleOutline
 from fabricatio.models.task import Task
 from fabricatio.utils import ok
 from typer import Typer
 
+# from pydantic import HttpUrl
+
 Role(
     name="Undergraduate Researcher",
     description="Write an outline for an article in typst format.",
-    llm_model="openai/qwen-max",
-    llm_temperature=0.63,
-    llm_stream=True,
-    llm_top_p=0.85,
+    llm_model="openai/deepseek-v3-250324",
+    llm_temperature=0.45,
+    # llm_api_endpoint=HttpUrl("https://dashscope.aliyuncs.com/compatible-mode/v1"),
+    llm_top_p=0.95,
     llm_max_tokens=8191,
     llm_rpm=600,
     llm_tpm=900000,
+    llm_timeout=600,
     registry={
         Event.quick_instantiate(ns := "article"): WorkFlow(
             name="Generate Article",
@@ -33,38 +34,48 @@ Role(
                 GenerateArticleProposal,
                 GenerateInitialOutline(output_key="article_outline"),
                 PersistentAll,
-                WriteArticleContentRAG(
-                    output_key="to_dump",
-                    llm_top_p=0.9,
-                    ref_limit=35,
-                    llm_model="openai/qwq-plus",
-                    target_collection="article_chunks",
-                    extractor_model="openai/qwen-plus",
-                    query_model="openai/qwen-max",
+                (
+                    a := WriteArticleContentRAG(
+                        output_key="to_dump",
+                        ref_limit=18,
+                        threshold=0.58,
+                        result_per_query=2,
+                        extractor_model={"model": "openai/qwen-max"},
+                        query_model={"model": "openai/qwen-turbo", "temperature": 0.3, "top_p": 0.85},
+                    )
                 ),
-                DumpFinalizedOutput(output_key="task_output"),
                 PersistentAll,
+                DumpFinalizedOutput(dump_path="median.typ"),
+                RenderedDump(template_name="article").to_task_output(),
             ),
         ),
-        Event.quick_instantiate(ns2 := ""): WorkFlow(
+        Event.quick_instantiate(ns2 := "complete"): WorkFlow(
             name="Generate Article",
             description="Generate an article with given raw article outline. dump the outline to the given path. in typst format.",
             steps=(
-                ExtractOutlineFromRaw,
+                ExtractOutlineFromRaw(output_key="article_outline"),
                 PersistentAll,
-                WriteArticleContentRAG(
-                    output_key="to_dump",
-                    llm_top_p=0.9,
-                    ref_limit=35,
-                    llm_model="openai/qwq-plus",
-                    target_collection="article_chunks",
-                    extractor_model="openai/qwen-plus",
-                    query_model="openai/qwen-max",
-                ),
-                DumpFinalizedOutput(output_key="task_output"),
+                a,
+                PersistentAll,
+                DumpFinalizedOutput(dump_path="median.typ"),
+                RenderedDump(template_name="article").to_task_output(),
+            ),
+        ),
+        Event.quick_instantiate(ns3 := "finish"): WorkFlow(
+            name="Finish Article",
+            description="Finish an article with given article outline. dump the outline to the given path. in typst format.",
+            steps=(
+                a,
                 PersistentAll,
+                DumpFinalizedOutput(dump_path="median.typ"),
+                RenderedDump(template_name="article").to_task_output(),
             ),
         ),
+        Event.quick_instantiate(ns4 := "consult"): WorkFlow(
+            name="Consult Article",
+            description="Consult an article with given article outline. dump the outline to the given path. in typst format.",
+            steps=(ArticleConsultRAG(ref_q_model={"model":"openai/qwen-turbo"}).to_task_output(),),
+        ),
     },
 )
 
@@ -72,6 +83,52 @@ Role(
 app = Typer()
 
 
+@app.command()
+def consult(
+    collection_name: str = typer.Option("article_chunks", "-c", "--collection-name", help="Name of the collection."),
+) -> None:
+    """Consult an article based on a given article outline."""
+    _ = asyncio.run(
+        Task(name="Answer Question")
+        .update_init_context(
+            collection_name=collection_name,
+        )
+        .delegate(ns4)
+    )
+
+    logger.info("Finished")
+
+
+@app.command()
+def finish(
+    article_outline_path: Path = typer.Argument(  # noqa: B008
+        help="Path to the article outline raw file."
+    ),
+    dump_path: Path = typer.Option(Path("out.typ"), "-d", "--dump-path", help="Path to dump the final output."),  # noqa: B008
+    persist_dir: Path = typer.Option(  # noqa: B008
+        Path("persistent"), "-p", "--persist-dir", help="Directory to persist the output."
+    ),
+    collection_name: str = typer.Option("article_chunks", "-c", "--collection-name", help="Name of the collection."),
+    supervisor: bool = typer.Option(False, "-s", "--supervisor", help="Whether to use the supervisor mode."),
+) -> None:
+    """Finish an article based on a given article outline."""
+    path = ok(
+        asyncio.run(
+            Task(name="write an article")
+            .update_init_context(
+                article_outline=ArticleOutline.from_persistent(article_outline_path),
+                dump_path=dump_path,
+                persist_dir=persist_dir,
+                collection_name=collection_name,
+                supervisor=supervisor,
+            )
+            .delegate(ns3)
+        ),
+        "Failed to generate an article ",
+    )
+    logger.success(f"The outline is saved in:\n{path}")
+
+
 @app.command()
 def completion(
     article_outline_raw_path: Path = typer.Option(  # noqa: B008
@@ -95,7 +152,7 @@ def completion(
                 collection_name=collection_name,
                 supervisor=supervisor,
             )
-            .delegate(ns)
+            .delegate(ns2)
         ),
         "Failed to generate an article ",
     )

{fabricatio-0.2.11.dev3 → fabricatio-0.2.12.dev2}/examples/write_outline/write_outline.py

@@ -3,6 +3,8 @@
 import asyncio
 
 from fabricatio import Event, Role, logger
+from fabricatio.models.task import Task
+from fabricatio.utils import ok
 from fabricatio.workflows.articles import WriteOutlineCorrectedWorkFlow
 
 
@@ -14,10 +16,11 @@ async def main() -> None:
         registry={Event.quick_instantiate(ns := "article"): WriteOutlineCorrectedWorkFlow},
     )
 
-    proposed_task = await role.propose_task(
+    proposed_task = await role.propose(
+        Task,
         "You need to read the `./article_briefing.txt` file and write an outline for the article in typst format. The outline should be saved in the `./out.typ` file.",
     )
-    path = await proposed_task.delegate(ns)
+    path = await ok(proposed_task).delegate(ns)
     logger.success(f"The outline is saved in:\n{path}")
 
 

{fabricatio-0.2.11.dev3 → fabricatio-0.2.12.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.11-dev3"
+version = "0.2.12-dev2"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -137,7 +137,8 @@ ignore = [
     "PYI063",
     "PYI021",
     "ASYNC109",
-    "RUF001"
+    "RUF001",
+    "PYI019"
 ]
 [tool.ruff.lint.pydocstyle]
 convention = "google"

{fabricatio-0.2.11.dev3 → fabricatio-0.2.12.dev2}/python/fabricatio/actions/article_rag.py

@@ -4,7 +4,10 @@ from asyncio import gather
 from pathlib import Path
 from typing import List, Optional
 
+from pydantic import Field, PositiveInt
+
 from fabricatio import BibManager
+from fabricatio.capabilities.advanced_rag import AdvancedRAG
 from fabricatio.capabilities.censor import Censor
 from fabricatio.capabilities.extract import Extract
 from fabricatio.capabilities.rag import RAG
@@ -16,59 +19,63 @@ from fabricatio.models.extra.article_essence import ArticleEssence
 from fabricatio.models.extra.article_main import Article, ArticleChapter, ArticleSection, ArticleSubsection
 from fabricatio.models.extra.article_outline import ArticleOutline
 from fabricatio.models.extra.rule import RuleSet
+from fabricatio.models.kwargs_types import ChooseKwargs, LLMKwargs
 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"
+    "Wrap inline expression with '\\(' and '\\)',like '\\(>5m\\)' '\\(89%\\)', and wrap block equation with '\\[' and '\\]'.\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 two 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"
+    "```\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
+    extractor_model: LLMKwargs
     """The model to use for extracting the content from the retrieved references."""
-    query_model: str
+    query_model: LLMKwargs
     """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,
-        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):
-            await gather(
-                *[
-                    self._supervisor_inner(article, article_outline, chap, sec, subsec)
-                    for chap, sec, subsec in article.iter_subsections()
-                ]
-            )
+            for chap, sec, subsec in article.iter_subsections():
+                await self._supervisor_inner(article, article_outline, chap, sec, subsec)
+
         else:
             await gather(
                 *[
@@ -92,22 +99,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, supervisor=True)
-                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)
 
@@ -121,11 +135,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(
@@ -139,11 +156,12 @@ 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",
+                **self.extractor_model,
             ),
             "Failed to propose new subsection.",
         )
         for p in new_subsec.paragraphs:
-            p.content = cm.apply(p.content).replace("$$", "\n$$\n")
+            p.content = cm.apply(p.content)
         subsec.update_from(new_subsec)
         logger.debug(f"{subsec.title}:rpl\n{subsec.display()}")
         return subsec
@@ -159,23 +177,16 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         extra_instruction: str = "",
     ) -> str:
         """Write the raw paragraphs of the subsec."""
-        return (
-            (
-                await self.aask(
-                    f"{cm.as_prompt()}\nAbove is some related reference 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}"
-                )
-            )
-            .replace(r" \( ", "$")
-            .replace(r" \) ", "$")
-            .replace(r"\(", "$")
-            .replace(r"\)", "$")
-            .replace("\\[\n", "$$\n")
-            .replace("\n\\]", "\n$$")
+        return await self.aask(
+            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}\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."
         )
 
     async def search_database(
@@ -185,28 +196,117 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         chap: ArticleChapter,
         sec: ArticleSection,
         subsec: ArticleSubsection,
+        cm: CitationManager,
         extra_instruction: str = "",
         supervisor: bool = False,
-    ) -> List[ArticleChunk]:
+    ) -> 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",
-                model=self.query_model,
+                search_req,
+                **self.query_model,
             ),
             "Failed to refine query.",
         )
 
+        if supervisor:
+            ref_q = await ask_retain(ref_q)
+        ret = await self.aretrieve(
+            ref_q,
+            ArticleChunk,
+            max_accepted=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}",
+            **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,
+            max_accepted=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, AdvancedRAG):
+    """Write an article based on the provided outline."""
+
+    output_key: str = "consult_count"
+    search_increment_multiplier: float = 1.6
+    """The multiplier to increase the limit of references to retrieve per query."""
+    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: ChooseKwargs = Field(default_factory=ChooseKwargs)
+    """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, fix_misplaced_labels
+
+        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()
+            await self.clued_search(
+                req,
+                cm,
+                refinery_kwargs=self.ref_q_model,
+                expand_multiplier=self.search_increment_multiplier,
+                base_accepted=self.ref_limit,
+                result_per_query=self.ref_per_q,
+                similarity_threshold=self.similarity_threshold,
+            )
+
+            ret = await self.aask(f"{cm.as_prompt()}\n{self.req}\n{req}")
+
+            ret = fix_misplaced_labels(ret)
+            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):
@@ -290,7 +390,7 @@ class TweakArticleRAG(Action, RAG, Censor):
         await self.censor_obj_inplace(
             subsec,
             ruleset=ruleset,
-            reference=f"{'\n\n'.join(d.display() for d in await self.aretrieve(refind_q, document_model=ArticleEssence, final_limit=self.ref_limit))}\n\n"
+            reference=f"{'\n\n'.join(d.display() for d in await self.aretrieve(refind_q, document_model=ArticleEssence, max_accepted=self.ref_limit))}\n\n"
             f"You can use Reference above to rewrite the `{subsec.__class__.__name__}`.\n"
             f"You should Always use `{subsec.language}` as written language, "
             f"which is the original language of the `{subsec.title}`. "

{fabricatio-0.2.11.dev3 → fabricatio-0.2.12.dev2}/python/fabricatio/actions/output.py

@@ -3,14 +3,17 @@
 from pathlib import Path
 from typing import Any, Iterable, List, Mapping, Optional, Type
 
+from fabricatio import TEMPLATE_MANAGER
+from fabricatio.fs import dump_text
 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 +41,45 @@ 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: FinalizedDumpAble,
+        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()}")
+        dump_text(
+            dump_path,
+            TEMPLATE_MANAGER.render_template(
+                self.template_name, {to_dump.__class__.__name__: to_dump.finalized_dump()}
+            ),
+        )
+
+        return dump_path.as_posix()
+
+
+class PersistentAll(Action, LLMUsage):
     """Persist all the data to a file."""
 
     output_key: str = "persistent_count"