fabricatio 0.2.5.dev4__tar.gz → 0.2.6.dev0__tar.gz

{fabricatio-0.2.5.dev4 → fabricatio-0.2.6.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.5.dev4
+Version: 0.2.6.dev0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -11,6 +11,7 @@ Classifier: Typing :: Typed
 Requires-Dist: appdirs>=1.4.4
 Requires-Dist: asyncio>=3.4.3
 Requires-Dist: asyncstdlib>=3.13.0
+Requires-Dist: json-repair>=0.39.1
 Requires-Dist: litellm>=1.60.0
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: magika>=0.5.1

{fabricatio-0.2.5.dev4 → fabricatio-0.2.6.dev0}/examples/extract_and_review/extract_and_review.py

@@ -25,8 +25,13 @@ async def main() -> None:
         "Extract the essence of the article from the files in './bpdf_out'",
     )
 
-    ess = await task.override_dependencies(gather_files("bpdf_out", "md")).delegate("article")
-    logger.success(f"Essence Count:{len(ess)}")
+    unchecked_ess = await task.override_dependencies(gather_files("bpdf_out", "md")).delegate("article")
+
+    if unchecked_ess is None:
+        logger.error("No essence found")
+        return
+    ess = list(filter(lambda x: x is not None, unchecked_ess))
+    logger.success(f"Essence Count:{len(ess)}, invalid count: {len(unchecked_ess) - len(ess)}")
 
     Path("output").mkdir(exist_ok=True)
     for i, e in enumerate(ess):

{fabricatio-0.2.5.dev4 → fabricatio-0.2.6.dev0}/examples/minor/hello_fabricatio.py

@@ -13,7 +13,7 @@ class Hello(Action):
 
     output_key: str = "task_output"
 
-    async def _execute(self, task_input: Task[str], **_) -> Any:
+    async def _execute(self, **_) -> Any:
         ret = "Hello fabricatio!"
         logger.info("executing talk action")
         return ret

{fabricatio-0.2.5.dev4 → fabricatio-0.2.6.dev0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.5-dev4"
+version = "0.2.6-dev0"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -30,6 +30,7 @@ dependencies = [
     "appdirs>=1.4.4",
     "asyncio>=3.4.3",
     "asyncstdlib>=3.13.0",
+    "json-repair>=0.39.1",
     "litellm>=1.60.0",
     "loguru>=0.7.3",
     "magika>=0.5.1",
@@ -71,6 +72,7 @@ dev = [
     "pytest-mock>=3.14.0",
     "pytest-rerunfailures>=15.0",
     "pytest-xdist>=3.6.1",
+    "viztracer>=1.0.2",
 ]
 
 [project.optional-dependencies]

{fabricatio-0.2.5.dev4 → fabricatio-0.2.6.dev0}/python/fabricatio/actions/article.py

@@ -2,7 +2,7 @@
 
 from os import PathLike
 from pathlib import Path
-from typing import Callable, List
+from typing import Callable, List, Optional
 
 from fabricatio.fs import safe_text_read
 from fabricatio.journal import logger
@@ -27,7 +27,7 @@ class ExtractArticleEssence(Action):
         task_input: Task,
         reader: Callable[[P], str] = lambda p: Path(p).read_text(encoding="utf-8"),
         **_,
-    ) -> List[ArticleEssence]:
+    ) -> Optional[List[ArticleEssence]]:
         if not task_input.dependencies:
             logger.info(err := "Task not approved, since no dependencies are provided.")
             raise RuntimeError(err)
@@ -51,7 +51,7 @@ class GenerateArticleProposal(Action):
         self,
         task_input: Task,
         **_,
-    ) -> ArticleProposal:
+    ) -> 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."
         )
@@ -73,7 +73,7 @@ class GenerateOutline(Action):
         self,
         article_proposal: ArticleProposal,
         **_,
-    ) -> ArticleOutline:
+    ) -> Optional[ArticleOutline]:
         return await self.propose(
             ArticleOutline,
             article_proposal.display(),

{fabricatio-0.2.5.dev4 → fabricatio-0.2.6.dev0}/python/fabricatio/actions/output.py

@@ -1,7 +1,5 @@
 """Dump the finalized output to a file."""
 
-from typing import Unpack
-
 from fabricatio.models.action import Action
 from fabricatio.models.generic import FinalizedDumpAble
 from fabricatio.models.task import Task
@@ -12,7 +10,7 @@ class DumpFinalizedOutput(Action):
 
     output_key: str = "dump_path"
 
-    async def _execute(self, task_input: Task, to_dump: FinalizedDumpAble, **cxt: Unpack) -> str:
+    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."
         )

{fabricatio-0.2.5.dev4 → fabricatio-0.2.6.dev0}/python/fabricatio/actions/rag.py

@@ -1,6 +1,6 @@
 """Inject data into the database."""
 
-from typing import List, Optional, Unpack
+from typing import List, Optional
 
 from fabricatio.capabilities.rag import RAG
 from fabricatio.models.action import Action
@@ -13,8 +13,8 @@ class InjectToDB(Action, RAG):
     output_key: str = "collection_name"
 
     async def _execute[T: PrepareVectorization](
-        self, to_inject: T | List[T], collection_name: Optional[str] = "my_collection", **cxt: Unpack
-    ) -> str:
+        self, to_inject: T | List[T], collection_name: Optional[str] = "my_collection", **_
+    ) -> Optional[str]:
         if not isinstance(to_inject, list):
             to_inject = [to_inject]
 

{fabricatio-0.2.5.dev4 → fabricatio-0.2.6.dev0}/python/fabricatio/capabilities/propose.py

@@ -1,37 +1,37 @@
 """A module for the task capabilities of the Fabricatio library."""
 
-from typing import List, Type, Unpack, overload
+from typing import List, Optional, Type, Unpack, overload
 
 from fabricatio.models.generic import ProposedAble
-from fabricatio.models.kwargs_types import GenerateKwargs
+from fabricatio.models.kwargs_types import ValidateKwargs
 from fabricatio.models.usages import LLMUsage
 
 
-class Propose[M: ProposedAble](LLMUsage):
+class Propose(LLMUsage):
     """A class that proposes an Obj based on a prompt."""
 
     @overload
-    async def propose(
+    async def propose[M: ProposedAble](
         self,
         cls: Type[M],
         prompt: List[str],
-        **kwargs: Unpack[GenerateKwargs[M]],
-    ) -> List[M]: ...
+        **kwargs: Unpack[ValidateKwargs[M]],
+    ) -> Optional[List[M]]: ...
 
     @overload
-    async def propose(
+    async def propose[M: ProposedAble](
         self,
         cls: Type[M],
         prompt: str,
-        **kwargs: Unpack[GenerateKwargs[M]],
-    ) -> M: ...
+        **kwargs: Unpack[ValidateKwargs[M]],
+    ) -> Optional[M]: ...
 
-    async def propose(
+    async def propose[M: ProposedAble](
         self,
         cls: Type[M],
         prompt: List[str] | str,
-        **kwargs: Unpack[GenerateKwargs[M]],
-    ) -> List[M] | M:
+        **kwargs: Unpack[ValidateKwargs[M]],
+    ) -> Optional[List[M] | M]:
         """Asynchronously proposes a task based on a given prompt and parameters.
 
         Parameters:
@@ -42,14 +42,8 @@ class Propose[M: ProposedAble](LLMUsage):
         Returns:
             A Task object based on the proposal result.
         """
-        if isinstance(prompt, str):
-            return await self.aask_validate(
-                question=cls.create_json_prompt(prompt),
-                validator=cls.instantiate_from_string,
-                **kwargs,
-            )
-        return await self.aask_validate_batch(
-            questions=[cls.create_json_prompt(p) for p in prompt],
+        return await self.aask_validate(
+            question=cls.create_json_prompt(prompt),
             validator=cls.instantiate_from_string,
             **kwargs,
         )

{fabricatio-0.2.5.dev4 → fabricatio-0.2.6.dev0}/python/fabricatio/capabilities/rag.py

@@ -8,7 +8,7 @@ from functools import lru_cache
 from operator import itemgetter
 from os import PathLike
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Self, Union, Unpack, overload
+from typing import Any, Callable, Dict, List, Optional, Self, Union, Unpack, cast, overload
 
 from fabricatio._rust_instances import template_manager
 from fabricatio.config import configs
@@ -111,9 +111,9 @@ class RAG(EmbeddingUsage):
             create (bool): Whether to create the collection if it does not exist.
             **kwargs (Unpack[CollectionSimpleConfigKwargs]): Additional keyword arguments for collection configuration.
         """
-        if create and collection_name and not self._client.has_collection(collection_name):
+        if create and collection_name and self.client.has_collection(collection_name):
             kwargs["dimension"] = kwargs.get("dimension") or self.milvus_dimensions or configs.rag.milvus_dimensions
-            self._client.create_collection(collection_name, auto_id=True, **kwargs)
+            self.client.create_collection(collection_name, auto_id=True, **kwargs)
             logger.info(f"Creating collection {collection_name}")
 
         self.target_collection = collection_name
@@ -152,15 +152,17 @@ class RAG(EmbeddingUsage):
             Self: The current instance, allowing for method chaining.
         """
         if isinstance(data, MilvusData):
-            data = data.prepare_insertion()
-        if isinstance(data, list):
-            data = [d.prepare_insertion() if isinstance(d, MilvusData) else d for d in data]
+            prepared_data = data.prepare_insertion()
+        elif isinstance(data, list):
+            prepared_data = [d.prepare_insertion() if isinstance(d, MilvusData) else d for d in data]
+        else:
+            raise TypeError(f"Expected MilvusData or list of MilvusData, got {type(data)}")
         c_name = collection_name or self.safe_target_collection
-        self._client.insert(c_name, data)
+        self.client.insert(c_name, prepared_data)
 
         if flush:
             logger.debug(f"Flushing collection {c_name}")
-            self._client.flush(c_name)
+            self.client.flush(c_name)
         return self
 
     async def consume_file(
@@ -196,14 +198,14 @@ class RAG(EmbeddingUsage):
         self.add_document(await self.pack(text), collection_name or self.safe_target_collection, flush=True)
         return self
 
-    async def afetch_document(
+    async def afetch_document[V: (int, str, float, bytes)](
         self,
         vecs: List[List[float]],
         desired_fields: List[str] | str,
         collection_name: Optional[str] = None,
         similarity_threshold: float = 0.37,
         result_per_query: int = 10,
-    ) -> List[Dict[str, Any]] | List[Any]:
+    ) -> List[Dict[str, Any]] | List[V]:
         """Fetch data from the collection.
 
         Args:
@@ -217,7 +219,7 @@ class RAG(EmbeddingUsage):
             List[Dict[str, Any]] | List[Any]: The retrieved data.
         """
         # Step 1: Search for vectors
-        search_results = self._client.search(
+        search_results = self.client.search(
             collection_name or self.safe_target_collection,
             vecs,
             search_params={"radius": similarity_threshold},
@@ -237,7 +239,7 @@ class RAG(EmbeddingUsage):
 
         if isinstance(desired_fields, list):
             return resp
-        return [r.get(desired_fields) for r in resp]
+        return [r.get(desired_fields) for r in resp]  # extract the single field as list
 
     async def aretrieve(
         self,
@@ -257,12 +259,13 @@ class RAG(EmbeddingUsage):
         """
         if isinstance(query, str):
             query = [query]
-        return (
+        return cast(
+            List[str],
             await self.afetch_document(
                 vecs=(await self.vectorize(query)),
                 desired_fields="text",
                 **kwargs,
-            )
+            ),
         )[:final_limit]
 
     async def aask_retrieved(

{fabricatio-0.2.5.dev4 → fabricatio-0.2.6.dev0}/python/fabricatio/capabilities/rating.py

@@ -1,15 +1,14 @@
 """A module that provides functionality to rate tasks based on a rating manual and score range."""
 
-from asyncio import gather
 from itertools import permutations
 from random import sample
-from typing import Dict, List, Set, Tuple, Union, Unpack, overload
+from typing import Dict, List, Optional, Set, Tuple, Union, Unpack, overload
 
 from fabricatio._rust_instances import template_manager
 from fabricatio.config import configs
 from fabricatio.journal import logger
 from fabricatio.models.generic import WithBriefing
-from fabricatio.models.kwargs_types import GenerateKwargs, ValidateKwargs
+from fabricatio.models.kwargs_types import ValidateKwargs
 from fabricatio.models.usages import LLMUsage
 from fabricatio.parser import JsonCapture
 from more_itertools import flatten, windowed
@@ -25,11 +24,11 @@ class GiveRating(WithBriefing, LLMUsage):
 
     async def rate_fine_grind(
         self,
-        to_rate: str,
+        to_rate: str | List[str],
         rating_manual: Dict[str, str],
         score_range: Tuple[float, float],
-        **kwargs: Unpack[ValidateKwargs],
-    ) -> Dict[str, float]:
+        **kwargs: Unpack[ValidateKwargs[Dict[str, float]]],
+    ) -> Optional[Dict[str, float] | List[Dict[str, float]]]:
         """Rate a given string based on a rating manual and score range.
 
         Args:
@@ -63,9 +62,21 @@ class GiveRating(WithBriefing, LLMUsage):
                         "rating_manual": rating_manual,
                     },
                 )
-            ),
+            )
+            if isinstance(to_rate, str)
+            else [
+                template_manager.render_template(
+                    configs.templates.rate_fine_grind_template,
+                    {
+                        "to_rate": item,
+                        "min_score": score_range[0],
+                        "max_score": score_range[1],
+                        "rating_manual": rating_manual,
+                    },
+                )
+                for item in to_rate
+            ],
             validator=_validator,
-            system_message=f"# your personal briefing: \n{self.briefing}",
             **kwargs,
         )
 
@@ -96,7 +107,7 @@ class GiveRating(WithBriefing, LLMUsage):
         criteria: Set[str],
         score_range: Tuple[float, float] = (0.0, 1.0),
         **kwargs: Unpack[ValidateKwargs],
-    ) -> Union[Dict[str, float], List[Dict[str, float]]]:
+    ) -> Optional[Dict[str, float] | List[Dict[str, float]]]:
         """Rate a given string or a sequence of strings based on a topic, criteria, and score range.
 
         Args:
@@ -110,16 +121,13 @@ class GiveRating(WithBriefing, LLMUsage):
             Union[Dict[str, float], List[Dict[str, float]]]: A dictionary with the ratings for each criterion if a single string is provided,
             or a list of dictionaries with the ratings for each criterion if a sequence of strings is provided.
         """
-        manual = await self.draft_rating_manual(topic, criteria, **kwargs)
-        if isinstance(to_rate, str):
-            return await self.rate_fine_grind(to_rate, manual, score_range, **kwargs)
-        if isinstance(to_rate, list):
-            return await gather(*[self.rate_fine_grind(item, manual, score_range, **kwargs) for item in to_rate])
-        raise ValueError("to_rate must be a string or a list of strings")
+        manual = await self.draft_rating_manual(topic, criteria, **kwargs) or dict(zip(criteria, criteria, strict=True))
+
+        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: Set[str], **kwargs: Unpack[ValidateKwargs[Dict[str, str]]]
+    ) -> Optional[Dict[str, str]]:
         """Drafts a rating manual based on a topic and dimensions.
 
         Args:
@@ -151,16 +159,15 @@ class GiveRating(WithBriefing, LLMUsage):
                 )
             ),
             validator=_validator,
-            system_message=f"# your personal briefing: \n{self.briefing}",
-            **kwargs,
+            **self.prepend(kwargs),
         )
 
     async def draft_rating_criteria(
         self,
         topic: str,
         criteria_count: NonNegativeInt = 0,
-        **kwargs: Unpack[ValidateKwargs],
-    ) -> Set[str]:
+        **kwargs: Unpack[ValidateKwargs[Set[str]]],
+    ) -> Optional[Set[str]]:
         """Drafts rating dimensions based on a topic.
 
         Args:
@@ -182,10 +189,9 @@ class GiveRating(WithBriefing, LLMUsage):
                 )
             ),
             validator=lambda resp: set(out)
-            if (out := JsonCapture.validate_with(resp, list, str, criteria_count))
+            if (out := JsonCapture.validate_with(resp, list, str, criteria_count)) is not None
             else out,
-            system_message=f"# your personal briefing: \n{self.briefing}",
-            **kwargs,
+            **self.prepend(kwargs),
         )
 
     async def draft_rating_criteria_from_examples(
@@ -196,7 +202,7 @@ class GiveRating(WithBriefing, LLMUsage):
         reasons_count: PositiveInt = 2,
         criteria_count: PositiveInt = 5,
         **kwargs: Unpack[ValidateKwargs],
-    ) -> Set[str]:
+    ) -> Optional[Set[str]]:
         """Asynchronously drafts a set of rating criteria based on provided examples.
 
         This function generates rating criteria by analyzing examples and extracting reasons for comparison,
@@ -220,11 +226,10 @@ class GiveRating(WithBriefing, LLMUsage):
         if m:
             examples = sample(examples, m)
 
-        kwargs = GenerateKwargs(system_message=f"# your personal briefing: \n{self.briefing}", **kwargs)
         # extract reasons from the comparison of ordered pairs of extracted from examples
         reasons = flatten(
-            await self.aask_validate_batch(
-                questions=[
+            await self.aask_validate(
+                question=[
                     template_manager.render_template(
                         configs.templates.extract_reasons_from_examples_template,
                         {
@@ -239,7 +244,7 @@ class GiveRating(WithBriefing, LLMUsage):
                 validator=lambda resp: JsonCapture.validate_with(
                     resp, target_type=list, elements_type=str, length=reasons_count
                 ),
-                **kwargs,
+                **self.prepend(kwargs),
             )
         )
         # extract certain mount of criteria from reasons according to their importance and frequency
@@ -264,7 +269,7 @@ class GiveRating(WithBriefing, LLMUsage):
         self,
         topic: str,
         criteria: Set[str],
-        **kwargs: Unpack[ValidateKwargs],
+        **kwargs: Unpack[ValidateKwargs[float]],
     ) -> Dict[str, float]:
         """Drafts rating weights for a given topic and criteria using the Klee method.
 
@@ -279,12 +284,12 @@ class GiveRating(WithBriefing, LLMUsage):
         if len(criteria) < 2:  # noqa: PLR2004
             raise ValueError("At least two criteria are required to draft rating weights")
 
-        criteria = list(criteria)  # freeze the order
-        windows = windowed(criteria, 2)
+        criteria_seq = list(criteria)  # freeze the order
+        windows = windowed(criteria_seq, 2)
 
         # get the importance multiplier indicating how important is second criterion compared to the first one
-        relative_weights = await self.aask_validate_batch(
-            questions=[
+        relative_weights = await self.aask_validate(
+            question=[
                 template_manager.render_template(
                     configs.templates.draft_rating_weights_klee_template,
                     {
@@ -296,13 +301,13 @@ class GiveRating(WithBriefing, LLMUsage):
                 for pair in windows
             ],
             validator=lambda resp: JsonCapture.validate_with(resp, target_type=float),
-            **GenerateKwargs(system_message=f"# your personal briefing: \n{self.briefing}", **kwargs),
+            **self.prepend(kwargs),
         )
         weights = [1]
         for rw in relative_weights:
             weights.append(weights[-1] * rw)
         total = sum(weights)
-        return dict(zip(criteria, [w / total for w in weights], strict=True))
+        return dict(zip(criteria_seq, [w / total for w in weights], strict=True))
 
     async def composite_score(
         self,

{fabricatio-0.2.5.dev4 → fabricatio-0.2.6.dev0}/python/fabricatio/capabilities/review.py

@@ -1,15 +1,14 @@
 """A module that provides functionality to rate tasks based on a rating manual and score range."""
 
-from typing import List, Optional, Self, Set, Unpack
+from typing import List, Optional, Self, Set, Unpack, cast
 
 from fabricatio import template_manager
 from fabricatio.capabilities.propose import Propose
 from fabricatio.capabilities.rating import GiveRating
 from fabricatio.config import configs
 from fabricatio.models.generic import Base, Display, ProposedAble, WithBriefing
-from fabricatio.models.kwargs_types import GenerateKwargs, ReviewKwargs
+from fabricatio.models.kwargs_types import ReviewKwargs, ValidateKwargs
 from fabricatio.models.task import Task
-from pydantic import PrivateAttr
 from questionary import Choice, checkbox
 from rich import print
 
@@ -76,7 +75,7 @@ class ReviewResult[T](ProposedAble, Display):
     problem_solutions: List[ProblemSolutions]
     """Collection of problems identified during review along with their potential solutions."""
 
-    _ref: T = PrivateAttr(None)
+    _ref: T
     """Reference to the original object that was reviewed."""
 
     def update_topic(self, topic: str) -> Self:
@@ -100,8 +99,8 @@ class ReviewResult[T](ProposedAble, Display):
         Returns:
             ReviewResult[K]: The current instance with updated reference type.
         """
-        self._ref = ref
-        return self
+        self._ref = ref  # pyright: ignore [reportAttributeAccessIssue]
+        return cast(ReviewResult[K], self)
 
     def deref(self) -> T:
         """Retrieve the referenced object that was reviewed.
@@ -178,14 +177,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 await self.review_obj(task, **kwargs)
+        return cast(ReviewResult[Task[T]], await self.review_obj(task, **kwargs))
 
     async def review_string(
         self,
         text: str,
         topic: str,
         criteria: Optional[Set[str]] = None,
-        **kwargs: Unpack[GenerateKwargs[ReviewResult[str]]],
+        **kwargs: Unpack[ValidateKwargs[ReviewResult[str]]],
     ) -> ReviewResult[str]:
         """Review a string based on specified topic and criteria.
 
@@ -197,7 +196,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.
-            **kwargs (Unpack[GenerateKwargs]): Additional keyword arguments for the LLM usage.
+            **kwargs (Unpack[ValidateKwargs]): Additional keyword arguments for the LLM usage.
 
         Returns:
             ReviewResult[str]: A review result containing identified problems and proposed solutions,

{fabricatio-0.2.5.dev4 → fabricatio-0.2.6.dev0}/python/fabricatio/capabilities/task.py

@@ -1,19 +1,19 @@
 """A module for the task capabilities of the Fabricatio library."""
 
 from types import CodeType
-from typing import Any, Dict, List, Optional, Tuple, Unpack
+from typing import Any, Dict, List, Optional, Tuple, Unpack, cast
 
 import orjson
 from fabricatio._rust_instances import template_manager
 from fabricatio.capabilities.propose import Propose
 from fabricatio.config import configs
+from fabricatio.journal import logger
 from fabricatio.models.generic import WithBriefing
 from fabricatio.models.kwargs_types import ChooseKwargs, ValidateKwargs
 from fabricatio.models.task import Task
 from fabricatio.models.tool import Tool, ToolExecutor
 from fabricatio.models.usages import ToolBoxUsage
 from fabricatio.parser import JsonCapture, PythonCapture
-from loguru import logger
 
 
 class ProposeTask(WithBriefing, Propose):
@@ -22,7 +22,7 @@ class ProposeTask(WithBriefing, Propose):
     async def propose_task[T](
         self,
         prompt: str,
-        **kwargs: Unpack[ValidateKwargs],
+        **kwargs: Unpack[ValidateKwargs[Task[T]]],
     ) -> Task[T]:
         """Asynchronously proposes a task based on a given prompt and parameters.
 
@@ -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, system_message=f"# your personal briefing: \n{self.briefing}", **kwargs)
+        return await self.propose(Task, prompt, **self.prepend(cast(Dict[str, Any], kwargs)))
 
 
 class HandleTask(WithBriefing, ToolBoxUsage):
@@ -49,7 +49,7 @@ class HandleTask(WithBriefing, ToolBoxUsage):
         tools: List[Tool],
         data: Dict[str, Any],
         **kwargs: Unpack[ValidateKwargs],
-    ) -> Tuple[CodeType, List[str]]:
+    ) -> Optional[Tuple[CodeType, List[str]]]:
         """Asynchronously drafts the tool usage code for a task based on a given task object and tools."""
         logger.info(f"Drafting tool usage code for task: {task.briefing}")
 
@@ -81,8 +81,7 @@ class HandleTask(WithBriefing, ToolBoxUsage):
         return await self.aask_validate(
             question=q,
             validator=_validator,
-            system_message=f"# your personal briefing: \n{self.briefing}",
-            **kwargs,
+            **self.prepend(cast(Dict[str, Any], kwargs)),
         )
 
     async def handle_fin_grind(
@@ -99,10 +98,10 @@ class HandleTask(WithBriefing, ToolBoxUsage):
         tools = await self.gather_tools_fine_grind(task, box_choose_kwargs, tool_choose_kwargs)
         logger.info(f"{self.name} have gathered {[t.name for t in tools]}")
 
-        if tools:
+        if tools and (pack := await self.draft_tool_usage_code(task, tools, data, **kwargs)):
             executor = ToolExecutor(candidates=tools, data=data)
-            code, to_extract = await self.draft_tool_usage_code(task, tools, data, **kwargs)
 
+            code, to_extract = pack
             cxt = executor.execute(code)
             if to_extract:
                 return tuple(cxt.get(k) for k in to_extract)