fabricatio 0.2.11.dev3__cp312-cp312-manylinux_2_34_x86_64.whl → 0.2.12__cp312-cp312-manylinux_2_34_x86_64.whl

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,13 @@ 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)
+            p.description = cm.apply(p.description)
         subsec.update_from(new_subsec)
         logger.debug(f"{subsec.title}:rpl\n{subsec.display()}")
         return subsec
@@ -159,23 +178,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 +197,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 +391,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/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"

fabricatio/capabilities/advanced_rag.py

@@ -0,0 +1,56 @@
+"""Advanced RAG (Retrieval Augmented Generation) model."""
+
+from typing import Optional, Unpack
+
+from fabricatio.capabilities.rag import RAG
+from fabricatio.journal import logger
+from fabricatio.models.adv_kwargs_types import FetchKwargs
+from fabricatio.models.extra.aricle_rag import ArticleChunk, CitationManager
+from fabricatio.models.kwargs_types import ChooseKwargs
+
+
+class AdvancedRAG(RAG):
+    """A class representing the Advanced RAG (Retrieval Augmented Generation) model."""
+
+    async def clued_search(
+        self,
+        requirement: str,
+        cm: CitationManager,
+        max_capacity: int = 40,
+        max_round: int = 3,
+        expand_multiplier: float = 1.4,
+        base_accepted: int = 12,
+        refinery_kwargs: Optional[ChooseKwargs] = None,
+        **kwargs: Unpack[FetchKwargs],
+    ) -> CitationManager:
+        """Asynchronously performs a clued search based on a given requirement and citation manager."""
+        if max_round<=0:
+            raise ValueError("max_round should be greater than 0")
+        if max_round == 1:
+            logger.warning(
+                "max_round should be greater than 1, otherwise it behaves nothing different from the `self.aretrieve`"
+            )
+
+        refinery_kwargs = refinery_kwargs or {}
+
+        for i in range(max_round + 1, 1):
+            logger.info(f"Round [{i + 1}/{max_round}] search started.")
+            ref_q = await self.arefined_query(
+                f"{cm.as_prompt()}\n\nAbove is the retrieved references in the {i - 1}th RAG, now we need to perform the {i}th RAG."
+                f"\n\n{requirement}",
+                **refinery_kwargs,
+            )
+            if ref_q is None:
+                logger.error(f"At round [{i + 1}/{max_round}] search, failed to refine the query, exit.")
+                return cm
+            refs = await self.aretrieve(ref_q, ArticleChunk, base_accepted, **kwargs)
+
+            if (max_capacity := max_capacity - len(refs)) < 0:
+                cm.add_chunks(refs[0:max_capacity])
+                logger.debug(f"At round [{i + 1}/{max_round}] search, the capacity is not enough, exit.")
+                return cm
+
+            cm.add_chunks(refs)
+            base_accepted = int(base_accepted * expand_multiplier)
+        logger.debug(f"Exceeded max_round: {max_round}, exit.")
+        return cm

fabricatio/capabilities/rag.py

@@ -189,7 +189,7 @@ class RAG(EmbeddingUsage):
         self,
         query: List[str] | str,
         document_model: Type[D],
-        final_limit: int = 20,
+        max_accepted: int = 20,
         **kwargs: Unpack[FetchKwargs],
     ) -> List[D]:
         """Retrieve data from the collection.
@@ -197,7 +197,7 @@ class RAG(EmbeddingUsage):
         Args:
             query (List[str] | str): The query to be used for retrieval.
             document_model (Type[D]): The model class used to convert retrieved data into document objects.
-            final_limit (int): The final limit on the number of results to return.
+            max_accepted (int): The final limit on the number of results to return.
             **kwargs (Unpack[FetchKwargs]): Additional keyword arguments for retrieval.
 
         Returns:
@@ -211,9 +211,9 @@ class RAG(EmbeddingUsage):
                 document_model=document_model,
                 **kwargs,
             )
-        )[:final_limit]
+        )[:max_accepted]
 
-    async def arefined_query(self, question: List[str] | str, **kwargs: Unpack[ChooseKwargs]) -> Optional[List[str]]:
+    async def arefined_query(self, question: List[str] | str, **kwargs: Unpack[ChooseKwargs[Optional[List[str]]]]) -> Optional[List[str]]:
         """Refines the given question using a template.
 
         Args:

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,12 @@ 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
 
@@ -26,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
@@ -96,9 +96,9 @@ 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
 
 
@@ -123,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)