fabricatio 0.2.7.dev0__cp312-cp312-manylinux_2_34_x86_64.whl → 0.2.7.dev2__cp312-cp312-manylinux_2_34_x86_64.whl

fabricatio/_rust.pyi

@@ -11,7 +11,7 @@ class TemplateManager:
     """
 
     def __init__(
-            self, template_dirs: List[Path], suffix: Optional[str] = None, active_loading: Optional[bool] = None
+        self, template_dirs: List[Path], suffix: Optional[str] = None, active_loading: Optional[bool] = None
     ) -> None:
         """Initialize the template manager.
 
@@ -55,6 +55,16 @@ class TemplateManager:
             RuntimeError: If template rendering fails
         """
 
+    def render_template_raw(self, template: str, data: Dict[str, Any]) -> str:
+        """Render a template with context data.
+
+        Args:
+            template: The template string
+            data: Context dictionary to provide variables to the template
+
+        Returns:
+            Rendered template content as string
+        """
 
 def blake3_hash(content: bytes) -> str:
     """Calculate the BLAKE3 cryptographic hash of data.
@@ -66,7 +76,6 @@ def blake3_hash(content: bytes) -> str:
         Hex-encoded BLAKE3 hash string
     """
 
-
 class BibManager:
     """BibTeX bibliography manager for parsing and querying citation data."""
 

fabricatio/actions/article.py

@@ -1,16 +1,14 @@
 """Actions for transmitting tasks to targets."""
 
-from os import PathLike
 from pathlib import Path
 from typing import Any, Callable, List, Optional
 
 from fabricatio.fs import safe_text_read
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
-from fabricatio.models.extra import ArticleEssence, ArticleOutline, ArticleProposal
+from fabricatio.models.extra import Article, ArticleEssence, ArticleOutline, ArticleProposal
 from fabricatio.models.task import Task
-from questionary import confirm, text
-from rich import print as rprint
+from fabricatio.models.utils import ok
 
 
 class ExtractArticleEssence(Action):
@@ -51,18 +49,33 @@ class GenerateArticleProposal(Action):
 
     async def _execute(
         self,
-        task_input: Task,
+        task_input: Optional[Task] = None,
+        article_briefing: Optional[str] = None,
+        article_briefing_path: Optional[str] = None,
         **_,
     ) -> Optional[ArticleProposal]:
-        input_path = await self.awhich_pathstr(
-            f"{task_input.briefing}\nExtract the path of file, which contains the article briefing that I need to read."
-        )
-
-        return await self.propose(
-            ArticleProposal,
-            safe_text_read(input_path),
-            system_message=f"# your personal briefing: \n{self.briefing}",
-        )
+        if article_briefing is None and article_briefing_path is None and task_input is None:
+            logger.error("Task not approved, since all inputs are None.")
+            return None
+
+        return (
+            await self.propose(
+                ArticleProposal,
+                briefing := (
+                    article_briefing
+                    or safe_text_read(
+                        ok(
+                            article_briefing_path
+                            or await self.awhich_pathstr(
+                                f"{task_input.briefing}\nExtract the path of file which contains the article briefing."
+                            ),
+                            "Could not find the path of file to read.",
+                        )
+                    )
+                ),
+                **self.prepend_sys_msg(),
+            )
+        ).update_ref(briefing)
 
 
 class GenerateOutline(Action):
@@ -76,35 +89,40 @@ class GenerateOutline(Action):
         article_proposal: ArticleProposal,
         **_,
     ) -> Optional[ArticleOutline]:
-        return await self.propose(
+        out = await self.propose(
             ArticleOutline,
-            article_proposal.display(),
-            system_message=f"# your personal briefing: \n{self.briefing}",
+            article_proposal.as_prompt(),
+            **self.prepend_sys_msg(),
         )
 
+        manual = await self.draft_rating_manual(
+            topic=(
+                topic
+                := "Fix the internal referring error, make sure there is no more `ArticleRef` pointing to a non-existing article component."
+            ),
+        )
+        while err := out.resolve_ref_error():
+            logger.warning(f"Found error in the outline: \n{err}")
+            out = await self.correct_obj(
+                out,
+                reference=f"# Referring Error\n{err}",
+                topic=topic,
+                rating_manual=manual,
+                supervisor_check=False,
+            )
+        return out.update_ref(article_proposal)
+
 
 class CorrectProposal(Action):
     """Correct the proposal of the article."""
 
     output_key: str = "corrected_proposal"
 
-    async def _execute(self, task_input: Task, article_proposal: ArticleProposal, **_) -> Any:
-        input_path = await self.awhich_pathstr(
-            f"{task_input.briefing}\nExtract the path of file, which contains the article briefing that I need to read."
+    async def _execute(self, article_proposal: ArticleProposal, **_) -> Any:
+        return (await self.censor_obj(article_proposal, reference=article_proposal.referenced)).update_ref(
+            article_proposal
         )
 
-        ret = None
-        while await confirm("Do you want to correct the Proposal?").ask_async():
-            rprint(article_proposal.display())
-            while not (topic := await text("What is the topic of the proposal reviewing?").ask_async()):
-                ...
-            ret = await self.correct_obj(
-                article_proposal,
-                safe_text_read(input_path),
-                topic=topic,
-            )
-        return ret or article_proposal
-
 
 class CorrectOutline(Action):
     """Correct the outline of the article."""
@@ -115,17 +133,77 @@ class CorrectOutline(Action):
     async def _execute(
         self,
         article_outline: ArticleOutline,
-        article_proposal: ArticleProposal,
-
         **_,
     ) -> ArticleOutline:
-        ret = None
-        while await confirm("Do you want to correct the outline?").ask_async():
-            rprint(article_outline.finalized_dump())
-            while not (topic := await text("What is the topic of the outline reviewing?").ask_async()):
-                ...
-            ret = await self.correct_obj(article_outline, article_proposal.display(), topic=topic)
-        return ret or article_outline
+        return (await self.censor_obj(article_outline, reference=article_outline.referenced.as_prompt())).update_ref(
+            article_outline
+        )
 
 
+class GenerateArticle(Action):
+    """Generate the article based on the outline."""
 
+    output_key: str = "article"
+    """The key of the output data."""
+
+    async def _execute(
+        self,
+        article_outline: ArticleOutline,
+        **_,
+    ) -> Optional[Article]:
+        article: Article = Article.from_outline(article_outline).update_ref(article_outline)
+
+        writing_manual = await self.draft_rating_manual(
+            topic=(
+                topic_1
+                := "improve the content of the subsection to fit the outline. SHALL never add or remove any section or subsection, you can only add or delete paragraphs within the subsection."
+            ),
+        )
+        err_resolve_manual = await self.draft_rating_manual(
+            topic=(topic_2 := "this article component has violated the constrain, please correct it.")
+        )
+        for c, deps in article.iter_dfs_with_deps(chapter=False):
+            logger.info(f"Updating the article component: \n{c.display()}")
+
+            out = ok(
+                await self.correct_obj(
+                    c,
+                    reference=(
+                        ref := f"{article_outline.referenced.as_prompt()}\n" + "\n".join(d.display() for d in deps)
+                    ),
+                    topic=topic_1,
+                    rating_manual=writing_manual,
+                    supervisor_check=False,
+                ),
+                "Could not correct the article component.",
+            )
+            while err := c.resolve_update_error(out):
+                logger.warning(f"Found error in the article component: \n{err}")
+                out = ok(
+                    await self.correct_obj(
+                        out,
+                        reference=f"{ref}\n\n# Violated Error\n{err}",
+                        topic=topic_2,
+                        rating_manual=err_resolve_manual,
+                        supervisor_check=False,
+                    ),
+                    "Could not correct the article component.",
+                )
+
+            c.update_from(out)
+        return article
+
+
+class CorrectArticle(Action):
+    """Correct the article based on the outline."""
+
+    output_key: str = "corrected_article"
+    """The key of the output data."""
+
+    async def _execute(
+        self,
+        article: Article,
+        article_outline: ArticleOutline,
+        **_,
+    ) -> Article:
+        return await self.censor_obj(article, reference=article_outline.referenced.as_prompt())

fabricatio/actions/output.py

@@ -1,8 +1,12 @@
 """Dump the finalized output to a file."""
 
+from pathlib import Path
+from typing import Optional
+
 from fabricatio.models.action import Action
 from fabricatio.models.generic import FinalizedDumpAble
 from fabricatio.models.task import Task
+from fabricatio.models.utils import ok
 
 
 class DumpFinalizedOutput(Action):
@@ -10,10 +14,21 @@ class DumpFinalizedOutput(Action):
 
     output_key: str = "dump_path"
 
-    async def _execute(self, task_input: Task, to_dump: FinalizedDumpAble, **_) -> str:
-        dump_path = await self.awhich_pathstr(
-            f"{task_input.briefing}\n\nExtract a single path of the file, to which I will dump 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 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.",
+            )
         )
-
-        to_dump.finalized_dump_to(dump_path)
-        return dump_path
+        ok(to_dump, "Could not dump the data since the path is not specified.").finalized_dump_to(dump_path)
+        return dump_path.as_posix()

fabricatio/capabilities/correct.py

@@ -10,9 +10,11 @@ from typing import Optional, Unpack, cast
 from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.capabilities.review import Review, ReviewResult
 from fabricatio.config import configs
-from fabricatio.models.generic import Display, ProposedAble, WithBriefing
-from fabricatio.models.kwargs_types import CorrectKwargs, ReviewKwargs
+from fabricatio.models.generic import CensoredAble, Display, ProposedAble, WithBriefing
+from fabricatio.models.kwargs_types import CensoredCorrectKwargs, CorrectKwargs, ReviewKwargs
 from fabricatio.models.task import Task
+from questionary import confirm, text
+from rich import print as rprint
 
 
 class Correct(Review):
@@ -55,7 +57,7 @@ class Correct(Review):
         if supervisor_check:
             await review_res.supervisor_check()
         if "default" in kwargs:
-            cast('ReviewKwargs[None]', kwargs)["default"] = None
+            cast("ReviewKwargs[None]", kwargs)["default"] = None
         return await self.propose(
             obj.__class__,
             TEMPLATE_MANAGER.render_template(
@@ -89,7 +91,7 @@ class Correct(Review):
             await review_res.supervisor_check()
 
         if "default" in kwargs:
-            cast('ReviewKwargs[None]', kwargs)["default"] = None
+            cast("ReviewKwargs[None]", kwargs)["default"] = None
         return await self.ageneric_string(
             TEMPLATE_MANAGER.render_template(
                 configs.templates.correct_template, {"content": input_text, "review": review_res.display()}
@@ -113,3 +115,31 @@ class Correct(Review):
             Optional[Task[T]]: The corrected task, or None if correction fails.
         """
         return await self.correct_obj(task, **kwargs)
+
+    async def censor_obj[M: CensoredAble](
+        self, obj: M, **kwargs: Unpack[CensoredCorrectKwargs[ReviewResult[str]]]
+    ) -> M:
+        """Censor and correct an object based on defined criteria and templates.
+
+        Args:
+            obj (M): The object to be reviewed and corrected.
+            **kwargs (Unpack[CensoredCorrectKwargs]): Additional keyword
+
+        Returns:
+            M: The censored and corrected object.
+        """
+        last_modified_obj = obj
+        modified_obj = None
+        rprint(obj.finalized_dump())
+        while await confirm("Begin to correct obj above with human censorship?").ask_async():
+            while (topic := await text("What is the topic of the obj reviewing?").ask_async()) is not None and topic:
+                ...
+            if (modified_obj := await self.correct_obj(
+                last_modified_obj,
+                topic=topic,
+                **kwargs,
+            )) is None:
+                break
+            last_modified_obj = modified_obj
+            rprint(last_modified_obj.finalized_dump())
+        return modified_obj or last_modified_obj

fabricatio/capabilities/rag.py

@@ -19,6 +19,7 @@ from fabricatio.models.kwargs_types import (
     EmbeddingKwargs,
     FetchKwargs,
     LLMKwargs,
+    RetrievalKwargs,
 )
 from fabricatio.models.usages import EmbeddingUsage
 from fabricatio.models.utils import MilvusData, ok
@@ -213,6 +214,25 @@ class RAG(EmbeddingUsage):
         self.add_document(await self.pack(text), collection_name or self.safe_target_collection, flush=True)
         return self
 
+    @overload
+    async def afetch_document[V: (int, str, float, bytes)](
+        self,
+        vecs: List[List[float]],
+        desired_fields: List[str],
+        collection_name: Optional[str] = None,
+        similarity_threshold: float = 0.37,
+        result_per_query: int = 10,
+    ) -> List[Dict[str, V]]: ...
+
+    @overload
+    async def afetch_document[V: (int, str, float, bytes)](
+        self,
+        vecs: List[List[float]],
+        desired_fields: str,
+        collection_name: Optional[str] = None,
+        similarity_threshold: float = 0.37,
+        result_per_query: int = 10,
+    ) -> List[V]: ...
     async def afetch_document[V: (int, str, float, bytes)](
         self,
         vecs: List[List[float]],
@@ -275,7 +295,7 @@ class RAG(EmbeddingUsage):
         if isinstance(query, str):
             query = [query]
         return cast(
-            'List[str]',
+            "List[str]",
             await self.afetch_document(
                 vecs=(await self.vectorize(query)),
                 desired_fields="text",
@@ -283,6 +303,24 @@ class RAG(EmbeddingUsage):
             ),
         )[:final_limit]
 
+    async def aretrieve_compact(
+        self,
+        query: List[str] | str,
+        **kwargs: Unpack[RetrievalKwargs],
+    ) -> str:
+        """Retrieve data from the collection and format it for display.
+
+        Args:
+            query (List[str] | str): The query to be used for retrieval.
+            **kwargs (Unpack[RetrievalKwargs]): Additional keyword arguments for retrieval.
+
+        Returns:
+            str: A formatted string containing the retrieved data.
+        """
+        return TEMPLATE_MANAGER.render_template(
+            configs.templates.retrieved_display_template, {"docs": (await self.aretrieve(query, **kwargs))}
+        )
+
     async def aask_retrieved(
         self,
         question: str,
@@ -313,16 +351,14 @@ class RAG(EmbeddingUsage):
         Returns:
             str: A string response generated after asking with the context of retrieved documents.
         """
-        docs = await self.aretrieve(
+        rendered = await self.aretrieve_compact(
             query or question,
-            final_limit,
+            final_limit=final_limit,
             collection_name=collection_name,
             result_per_query=result_per_query,
             similarity_threshold=similarity_threshold,
         )
 
-        rendered = TEMPLATE_MANAGER.render_template(configs.templates.retrieved_display_template, {"docs": docs[::-1]})
-
         logger.debug(f"Retrieved Documents: \n{rendered}")
         return await self.aask(
             question,

fabricatio/capabilities/rating.py

@@ -10,6 +10,7 @@ from fabricatio.journal import logger
 from fabricatio.models.generic import WithBriefing
 from fabricatio.models.kwargs_types import ValidateKwargs
 from fabricatio.models.usages import LLMUsage
+from fabricatio.models.utils import override_kwargs
 from fabricatio.parser import JsonCapture
 from more_itertools import flatten, windowed
 from pydantic import NonNegativeInt, PositiveInt
@@ -126,13 +127,13 @@ class GiveRating(WithBriefing, LLMUsage):
         return await self.rate_fine_grind(to_rate, manual, score_range, **kwargs)
 
     async def draft_rating_manual(
-        self, topic: str, criteria: Set[str], **kwargs: Unpack[ValidateKwargs[Dict[str, str]]]
+        self, topic: str, criteria: Optional[Set[str]] = None, **kwargs: Unpack[ValidateKwargs[Dict[str, str]]]
     ) -> Optional[Dict[str, str]]:
         """Drafts a rating manual based on a topic and dimensions.
 
         Args:
             topic (str): The topic for the rating manual.
-            criteria (Set[str]): A set of dimensions for the rating manual.
+            criteria (Optional[Set[str]], optional): A set of criteria for the rating manual. If not specified, then this method will draft the criteria automatically.
             **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
@@ -148,6 +149,14 @@ class GiveRating(WithBriefing, LLMUsage):
                 return json_data
             return None
 
+        criteria = criteria or await self.draft_rating_criteria(
+            topic, **self.prepend_sys_msg(override_kwargs(dict(kwargs), default=None))
+        )
+
+        if criteria is None:
+            logger.error(f"Failed to draft rating criteria for topic {topic}")
+            return None
+
         return await self.aask_validate(
             question=(
                 TEMPLATE_MANAGER.render_template(
@@ -159,7 +168,7 @@ class GiveRating(WithBriefing, LLMUsage):
                 )
             ),
             validator=_validator,
-            **self.prepend(kwargs),
+            **self.prepend_sys_msg(kwargs),
         )
 
     async def draft_rating_criteria(
@@ -191,7 +200,7 @@ class GiveRating(WithBriefing, LLMUsage):
             validator=lambda resp: set(out)
             if (out := JsonCapture.validate_with(resp, list, str, criteria_count)) is not None
             else out,
-            **self.prepend(kwargs),
+            **self.prepend_sys_msg(kwargs),
         )
 
     async def draft_rating_criteria_from_examples(
@@ -244,7 +253,7 @@ class GiveRating(WithBriefing, LLMUsage):
                 validator=lambda resp: JsonCapture.validate_with(
                     resp, target_type=list, elements_type=str, length=reasons_count
                 ),
-                **self.prepend(kwargs),
+                **self.prepend_sys_msg(kwargs),
             )
         )
         # extract certain mount of criteria from reasons according to their importance and frequency
@@ -301,7 +310,7 @@ class GiveRating(WithBriefing, LLMUsage):
                 for pair in windows
             ],
             validator=lambda resp: JsonCapture.validate_with(resp, target_type=float),
-            **self.prepend(kwargs),
+            **self.prepend_sys_msg(kwargs),
         )
         weights = [1]
         for rw in relative_weights:

fabricatio/capabilities/review.py

@@ -1,6 +1,6 @@
 """A module that provides functionality to rate tasks based on a rating manual and score range."""
 
-from typing import List, Optional, Self, Set, Unpack, cast
+from typing import Dict, List, Optional, Self, Set, Unpack, cast
 
 from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.capabilities.propose import Propose
@@ -200,13 +200,14 @@ class Review(GiveRating, Propose):
             ReviewResult[Task[T]]: A review result containing identified problems and proposed solutions,
                 with a reference to the original task.
         """
-        return cast('ReviewResult[Task[T]]', await self.review_obj(task, **kwargs))
+        return cast("ReviewResult[Task[T]]", await self.review_obj(task, **kwargs))
 
     async def review_string(
         self,
         input_text: str,
         topic: str,
         criteria: Optional[Set[str]] = None,
+        rating_manual: Optional[Dict[str, str]] = None,
         **kwargs: Unpack[ValidateKwargs[ReviewResult[str]]],
     ) -> ReviewResult[str]:
         """Review a string based on specified topic and criteria.
@@ -219,6 +220,7 @@ class Review(GiveRating, Propose):
             topic (str): The subject topic for the review criteria.
             criteria (Optional[Set[str]], optional): A set of criteria for the review.
                 If not provided, criteria will be drafted automatically. Defaults to None.
+            rating_manual (Optional[Dict[str,str]], optional): A dictionary of rating criteria and their corresponding scores.
             **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
@@ -227,12 +229,13 @@ class Review(GiveRating, Propose):
         """
         default = None
         if "default" in kwargs:
+            # this `default` is the default for the `propose` method
             default = kwargs.pop("default")
 
         criteria = criteria or (await self.draft_rating_criteria(topic, **kwargs))
         if not criteria:
             raise ValueError("No criteria provided for review.")
-        manual = await self.draft_rating_manual(topic, criteria, **kwargs)
+        manual = rating_manual or await self.draft_rating_manual(topic, criteria, **kwargs)
 
         if default is not None:
             kwargs["default"] = default

fabricatio/capabilities/task.py

@@ -37,7 +37,7 @@ class ProposeTask(WithBriefing, Propose):
             logger.error(err := f"{self.name}: Prompt must be provided.")
             raise ValueError(err)
 
-        return await self.propose(Task, prompt, **self.prepend(cast('Dict[str, Any]', kwargs)))
+        return await self.propose(Task, prompt, **self.prepend_sys_msg(cast("Dict[str, Any]", kwargs)))
 
 
 class HandleTask(WithBriefing, ToolBoxUsage):
@@ -81,7 +81,7 @@ class HandleTask(WithBriefing, ToolBoxUsage):
         return await self.aask_validate(
             question=q,
             validator=_validator,
-            **self.prepend(cast('Dict[str, Any]', kwargs)),
+            **self.prepend_sys_msg(cast("Dict[str, Any]", kwargs)),
         )
 
     async def handle_fine_grind(

fabricatio/config.py

@@ -235,6 +235,9 @@ class TemplateConfig(BaseModel):
     co_validation_template: str = Field(default="co_validation")
     """The name of the co-validation template which will be used to co-validate a string."""
 
+    as_prompt_template: str = Field(default="as_prompt")
+    """The name of the as prompt template which will be used to convert a string to a prompt."""
+
 
 class MagikaConfig(BaseModel):
     """Magika configuration class."""

fabricatio/decorators.py

@@ -177,3 +177,35 @@ def use_temp_module[**P, R](modules: ModuleType | List[ModuleType]) -> Callable[
         return _wrapper
 
     return _decorator
+
+
+def logging_exec_time[**P, R](func: Callable[P, R]) -> Callable[P, R]:
+    """Decorator to log the execution time of a function.
+
+    Args:
+        func (Callable): The function to be executed
+
+    Returns:
+        Callable: A decorator that wraps the function to log the execution time.
+    """
+    from time import time
+
+    if iscoroutinefunction(func):
+
+        @wraps(func)
+        async def _async_wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            start_time = time()
+            result = await func(*args, **kwargs)
+            logger.debug(f"Execution time of `{func.__name__}`: {time() - start_time:.2f} s")
+            return result
+
+        return _async_wrapper
+
+    @wraps(func)
+    def _wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        start_time = time()
+        result = func(*args, **kwargs)
+        logger.debug(f"Execution time of {func.__name__}: {(time() - start_time) * 1000:.2f} ms")
+        return result
+
+    return _wrapper

fabricatio/models/action.py

@@ -48,7 +48,7 @@ class Action(HandleTask, ProposeTask, Correct):
         self.description = self.description or self.__class__.__doc__ or ""
 
     @abstractmethod
-    async def _execute(self,*_, **cxt) -> Any:  # noqa: ANN002
+    async def _execute(self, *_, **cxt) -> Any:  # noqa: ANN002
         """Execute the action logic with the provided context arguments.
 
         This method must be implemented by subclasses to define the actual behavior.
@@ -147,6 +147,8 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
         Args:
             task: The task to be processed.
         """
+        logger.info(f"Start execute workflow: {self.name}")
+
         await task.start()
         await self._init_context(task)
 
@@ -155,12 +157,11 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
             # Process each action in sequence
             for step in self._instances:
                 current_action = step.name
-                logger.debug(f"Executing step: {current_action}")
+                logger.info(f"Executing step: {current_action}")
 
                 # Get current context and execute action
                 context = await self._context.get()
                 act_task = create_task(step.act(context))
-
                 # Handle task cancellation
                 if task.is_cancelled():
                     act_task.cancel(f"Cancelled by task: {task.name}")
@@ -168,9 +169,10 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
 
                 # Update context with modified values
                 modified_ctx = await act_task
+                logger.success(f"Step execution finished: {current_action}")
                 await self._context.put(modified_ctx)
 
-            logger.info(f"Finished executing workflow: {self.name}")
+            logger.success(f"Workflow execution finished: {self.name}")
 
             # Get final context and extract result
             final_ctx = await self._context.get()
@@ -184,9 +186,9 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
 
             await task.finish(result)
 
-        except RuntimeError as e:
-            logger.error(f"Error during task: {current_action} execution: {e}")
-            logger.error(traceback.format_exc())
+        except Exception as e:  # noqa: BLE001
+            logger.critical(f"Error during task: {current_action} execution: {e}")
+            logger.critical(traceback.format_exc())
             await task.fail()
 
     async def _init_context[T](self, task: Task[T]) -> None: