fabricatio 0.2.5.dev3__cp312-cp312-win_amd64.whl → 0.2.5.dev5__cp312-cp312-win_amd64.whl

fabricatio/actions/rag.py

@@ -14,7 +14,7 @@ class InjectToDB(Action, RAG):
 
     async def _execute[T: PrepareVectorization](
         self, to_inject: T | List[T], collection_name: Optional[str] = "my_collection", **cxt: Unpack
-    ) -> str:
+    ) -> Optional[str]:
         if not isinstance(to_inject, list):
             to_inject = [to_inject]
 

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/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/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/capabilities/task.py

@@ -1,7 +1,7 @@
 """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
@@ -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)

fabricatio/config.py

@@ -1,5 +1,6 @@
 """Configuration module for the Fabricatio application."""
 
+from pathlib import Path
 from typing import List, Literal, Optional
 
 from appdirs import user_config_dir
@@ -67,7 +68,7 @@ class LLMConfig(BaseModel):
     temperature: NonNegativeFloat = Field(default=1.0)
     """The temperature of the LLM model. Controls randomness in generation. Set to 1.0 as per request."""
 
-    stop_sign: str | List[str] = Field(default=("\n\n\n", "User:"))
+    stop_sign: str | List[str] = Field(default_factory=lambda :["\n\n\n", "User:"])
     """The stop sign of the LLM model. No default stop sign specified."""
 
     top_p: NonNegativeFloat = Field(default=0.35)
@@ -143,7 +144,7 @@ class DebugConfig(BaseModel):
     log_level: Literal["DEBUG", "INFO", "SUCCESS", "WARNING", "ERROR", "CRITICAL"] = Field(default="INFO")
     """The log level of the application."""
 
-    log_file: FilePath = Field(default=rf"{ROAMING_DIR}\fabricatio.log")
+    log_file: FilePath = Field(default=Path(rf"{ROAMING_DIR}\fabricatio.log"))
     """The log file of the application."""
 
     rotation: int = Field(default=1)
@@ -161,7 +162,7 @@ class TemplateConfig(BaseModel):
 
     model_config = ConfigDict(use_attribute_docstrings=True)
     template_dir: List[DirectoryPath] = Field(
-        default_factory=lambda: [DirectoryPath(r".\templates"), DirectoryPath(rf"{ROAMING_DIR}\templates")]
+        default_factory=lambda: [Path(r".\templates"), Path(rf"{ROAMING_DIR}\templates")]
     )
     """The directory containing the templates."""
     active_loading: bool = Field(default=False)
@@ -234,12 +235,15 @@ class GeneralConfig(BaseModel):
     """Global configuration class."""
 
     model_config = ConfigDict(use_attribute_docstrings=True)
-    workspace: DirectoryPath = Field(default=DirectoryPath(r"."))
+    workspace: DirectoryPath = Field(default=Path())
     """The workspace directory for the application."""
 
     confirm_on_ops: bool = Field(default=True)
     """Whether to confirm on operations."""
 
+    use_json_repair: bool = Field(default=True)
+    """Whether to use JSON repair."""
+
 
 class ToolBoxConfig(BaseModel):
     """Toolbox configuration class."""

fabricatio/fs/readers.py

@@ -3,8 +3,8 @@
 from pathlib import Path
 from typing import Dict
 
+import orjson
 from magika import Magika
-from orjson import orjson
 
 from fabricatio.config import configs
 from fabricatio.journal import logger

fabricatio/journal.py

@@ -18,6 +18,7 @@ logger.add(
 )
 logger.add(sys.stderr, level=configs.debug.log_level)
 
+__all__ = ["logger"]
 if __name__ == "__main__":
     logger.debug("This is a trace message.")
     logger.info("This is an information message.")

fabricatio/models/action.py

@@ -75,7 +75,7 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
     _context: Queue[Dict[str, Any]] = PrivateAttr(default_factory=lambda: Queue(maxsize=1))
     """ The context dictionary to be used for workflow execution."""
 
-    _instances: Tuple[Action, ...] = PrivateAttr(...)
+    _instances: Tuple[Action, ...] = PrivateAttr(default_factory=tuple)
     """ The instances of the workflow steps."""
 
     steps: Tuple[Union[Type[Action], Action], ...] = Field(...)

fabricatio/models/events.py

@@ -18,7 +18,7 @@ class Event(BaseModel):
     """ The segments of the namespaces."""
 
     @classmethod
-    def instantiate_from(cls, event: EventLike) -> Self:
+    def instantiate_from(cls, event: EventLike) -> "Event":
         """Create an Event instance from a string or list of strings or an Event instance.
 
         Args:
@@ -35,7 +35,7 @@ class Event(BaseModel):
         return cls(segments=event)
 
     @classmethod
-    def quick_instantiate(cls, event: EventLike) -> Self:
+    def quick_instantiate(cls, event: EventLike) -> "Event":
         """Create an Event instance from a string or list of strings or an Event instance and push a wildcard and pending segment.
 
         Args:
@@ -59,7 +59,7 @@ class Event(BaseModel):
 
     def clone(self) -> Self:
         """Clone the event."""
-        return Event(segments=list(self.segments))
+        return self.__class__(segments=list(self.segments))
 
     def push(self, segment: str) -> Self:
         """Push a segment to the event."""
@@ -113,6 +113,8 @@ class Event(BaseModel):
         """Return the hash of the event, using the collapsed string."""
         return hash(self.collapse())
 
-    def __eq__(self, other: str | List[str] | Self) -> bool:
+    def __eq__(self, other: object) -> bool:
         """Check if the event is equal to another event or a string."""
+        if not isinstance(other, (str , list , Event)):
+            return False
         return self.collapse() == Event.instantiate_from(other).collapse()

fabricatio/models/extra.py

@@ -9,23 +9,23 @@ from pydantic import Field
 class Equation(Base):
     """Structured representation of mathematical equations (including their physical or conceptual meanings)."""
 
-    description: str = Field(...)
+    description: str
     """A concise explanation of the equation's meaning, purpose, and relevance in the context of the research."""
 
-    latex_code: str = Field(...)
+    latex_code: str
     """The LaTeX code used to represent the equation in a publication-ready format."""
 
 
 class Figure(Base):
     """Structured representation of figures (including their academic significance and explanatory captions)."""
 
-    description: str = Field(...)
+    description: str
     """A detailed explanation of the figure's content and its role in conveying key insights."""
 
-    figure_caption: str = Field(...)
+    figure_caption: str
     """The caption accompanying the figure, summarizing its main points and academic value."""
 
-    figure_path: str = Field(...)
+    figure_path: str
     """The file path to the figure"""
 
 
@@ -34,7 +34,7 @@ class Highlightings(Base):
 
     # Academic Achievements Showcase
     highlighted_equations: List[Equation] = Field(default_factory=list)
-    """Core mathematical equations that represent breakthroughs in the field, accompanied by explanations of their physical or conceptual significance."""
+    """Core mathematical equations that represent breakthroughs in the field, accompanied by explanations of their physical or conceptual significance,Should always be in LaTeX format wrapped in $ or $$ signs."""
 
     highlighted_algorithms: List[str] = Field(default_factory=list)
     """Pseudocode for key algorithms, annotated to highlight innovative components."""
@@ -53,39 +53,42 @@ class ArticleEssence(ProposedAble, Display, PrepareVectorization):
     title: str = Field(...)
     """The full title of the paper, including any subtitles if applicable."""
 
-    authors: List[str] = Field(default_factory=list)
+    authors: List[str]
     """A list of the paper's authors, typically in the order of contribution."""
 
-    keywords: List[str] = Field(default_factory=list)
+    keywords: List[str]
     """A list of keywords that summarize the paper's focus and facilitate indexing."""
 
-    publication_year: int = Field(None)
+    publication_year: int
     """The year in which the paper was published."""
 
     # Core Content Elements
-    domain: List[str] = Field(default_factory=list)
+    highlightings: Highlightings = Field(default_factory=Highlightings)
+    """A collection of highlighted elements in the paper, including equations, algorithms, figures, and tables."""
+
+    domain: List[str]
     """The research domains or fields addressed by the paper (e.g., ['Natural Language Processing', 'Computer Vision'])."""
 
     abstract: str = Field(...)
     """A structured abstract that outlines the research problem, methodology, and conclusions in three distinct sections."""
 
-    core_contributions: List[str] = Field(default_factory=list)
+    core_contributions: List[str]
     """Key academic contributions that distinguish the paper from prior work in the field."""
 
-    technical_novelty: List[str] = Field(default_factory=list)
+    technical_novelty: List[str]
     """Specific technical innovations introduced by the research, listed as individual points."""
 
     # Academic Discussion Dimensions
-    research_problem: str = Field("")
+    research_problems: List[str]
     """A clearly defined research question or problem addressed by the study."""
 
-    limitations: List[str] = Field(default_factory=list)
+    limitations: List[str]
     """An analysis of the methodological or experimental limitations of the research."""
 
-    future_work: List[str] = Field(default_factory=list)
+    future_work: List[str]
     """Suggestions for potential directions or topics for follow-up studies."""
 
-    impact_analysis: str = Field("")
+    impact_analysis: List[str]
     """An assessment of the paper's potential influence on the development of the field."""
 
     def _prepare_vectorization_inner(self) -> str:

fabricatio/models/generic.py

@@ -2,7 +2,7 @@
 
 from abc import abstractmethod
 from pathlib import Path
-from typing import Callable, Iterable, List, Optional, Self, Union, final
+from typing import Any, Callable, Dict, Iterable, List, Optional, Self, Union, final
 
 import orjson
 from fabricatio._rust import blake3_hash
@@ -67,6 +67,18 @@ class WithBriefing(Named, Described):
         """
         return f"{self.name}: {self.description}" if self.description else self.name
 
+    def prepend[D: Dict[str, Any]](self, kwargs: D) -> D:
+        """Prepend the briefing to the system message in the kwargs.
+
+        Args:
+            kwargs (Dict[str, Any]): The keyword arguments to modify.
+
+        Returns:
+            Dict[str, Any]: The modified keyword arguments.
+        """
+        kwargs["system_message"] = f"# your personal briefing: \n{self.briefing}\n" + kwargs.get("system_message", "")
+        return kwargs
+
 
 class WithFormatedJsonSchema(Base):
     """Class that provides a formatted JSON schema of the model."""
@@ -361,3 +373,4 @@ class ScopedConfig(Base):
             for attr_name in ScopedConfig.model_fields:
                 if (attr := getattr(self, attr_name)) is not None and getattr(other, attr_name) is None:
                     setattr(other, attr_name, attr)
+        return self