fabricatio 0.2.0.dev17__tar.gz → 0.2.0.dev19__tar.gz

{fabricatio-0.2.0.dev17 → fabricatio-0.2.0.dev19}/Cargo.lock

@@ -67,6 +67,18 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
+[[package]]
+name = "arrayref"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
+
+[[package]]
+name = "arrayvec"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+
 [[package]]
 name = "atomic-waker"
 version = "1.1.2"
@@ -106,6 +118,20 @@ version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8f68f53c83ab957f72c32642f3868eec03eb974d1fb82e453128456482613d36"
 
+[[package]]
+name = "blake3"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1230237285e3e10cde447185e8975408ae24deaa67205ce684805c25bc0c7937"
+dependencies = [
+ "arrayref",
+ "arrayvec",
+ "cc",
+ "cfg-if",
+ "constant_time_eq",
+ "memmap2",
+]
+
 [[package]]
 name = "block-buffer"
 version = "0.10.4"
@@ -188,6 +214,12 @@ version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990"
 
+[[package]]
+name = "constant_time_eq"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6"
+
 [[package]]
 name = "core-foundation"
 version = "0.9.4"
@@ -369,8 +401,11 @@ dependencies = [
 name = "fabricatio"
 version = "0.0.0"
 dependencies = [
+ "blake3",
  "handlebars",
  "pyo3",
+ "pythonize",
+ "serde_json",
  "walkdir",
 ]
 
@@ -910,6 +945,15 @@ version = "2.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
+[[package]]
+name = "memmap2"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd3f7eed9d3848f8b98834af67102b720745c4ec028fcd0aa0239277e7de374f"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "memoffset"
 version = "0.9.1"
@@ -1189,6 +1233,16 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "pythonize"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91a6ee7a084f913f98d70cdc3ebec07e852b735ae3059a1500db2661265da9ff"
+dependencies = [
+ "pyo3",
+ "serde",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.38"

{fabricatio-0.2.0.dev17 → fabricatio-0.2.0.dev19}/Cargo.toml

@@ -6,8 +6,11 @@ edition = "2024"
 crate-type = ["cdylib"]
 
 [dependencies]
+blake3 = "1.6.0"
 handlebars = "6.3.1"
 pyo3 = { version = "0.23.4", features = ["extension-module"] }
+pythonize = "0.23.0"
+serde_json = "1.0.138"
 walkdir = "2.5.0"
 
 [workspace]

{fabricatio-0.2.0.dev17 → fabricatio-0.2.0.dev19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.0.dev17
+Version: 0.2.0.dev19
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12

{fabricatio-0.2.0.dev17 → fabricatio-0.2.0.dev19}/examples/propose_task/propose.py

@@ -25,7 +25,7 @@ async def main() -> None:
     role = Role(
         name="talker", description="talker role", registry={task.pending_label: WorkFlow(name="talk", steps=(Talk,))}
     )
-    logger.info(Task.json_example())
+    logger.info(f"Task example:\n{Task.json_example()}")
     logger.info(f"proposed task: {await role.propose('write a rust clap cli that can download a html page')}")
 
 

{fabricatio-0.2.0.dev17 → fabricatio-0.2.0.dev19}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.0-dev.17"
+version = "0.2.0-dev.19"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }

{fabricatio-0.2.0.dev17 → fabricatio-0.2.0.dev19}/python/fabricatio/__init__.py

@@ -11,6 +11,7 @@ from fabricatio.models.task import Task
 from fabricatio.models.tool import ToolBox
 from fabricatio.models.utils import Message, Messages
 from fabricatio.parser import Capture, CodeBlockCapture, JsonCapture, PythonCapture
+from fabricatio.toolboxes import arithmetic_toolbox, basic_toolboxes, fs_toolbox, task_toolbox
 
 __all__ = [
     "Action",
@@ -25,8 +26,12 @@ __all__ = [
     "Task",
     "ToolBox",
     "WorkFlow",
+    "arithmetic_toolbox",
+    "basic_toolboxes",
     "env",
+    "fs_toolbox",
     "logger",
     "magika",
+    "task_toolbox",
     "template_manager",
 ]

{fabricatio-0.2.0.dev17 → fabricatio-0.2.0.dev19}/python/fabricatio/_rust.pyi

@@ -1,53 +1,53 @@
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Dict, List, Optional
 
 class TemplateManager:
-    def __init__(self, template_dirs: List[Path], suffix: Optional[str] = None) -> None:
+    """TemplateManager class for managing handlebars templates."""
+    def __init__(
+        self, template_dirs: List[Path], suffix: Optional[str] = None, active_loading: Optional[bool] = None
+    ) -> None:
         """Initialize the template manager.
 
         Args:
             template_dirs (List[Path]): A list of paths to directories containing templates.
-            suffix (str, optional): The suffix of template files. None means 'hbs' suffix .
+            suffix (str, optional): The suffix of template files. None means 'hbs' suffix.
+            active_loading (bool, optional): Whether to enable active loading of templates.
         """
 
     @property
     def template_count(self) -> int:
         """Get the number of templates discovered."""
 
-    @property
-    def templates(self) -> List[str]:
-        """Get a list of template names."""
-
-    def get_template(self, name: str) -> str:
-        """Get a template by name.
-
-        Args:
-            name (str): The name of the template to retrieve.
-
-        Returns:
-            str: The template content.
-        """
-
-    def get_template_source(self, name: str) -> str:
+    def get_template_source(self, name: str) -> Optional[str]:
         """Get the source path of a template by name.
 
         Args:
             name (str): The name of the template to retrieve.
 
         Returns:
-            str: The source path of the template.
+            Optional[str]: The source path of the template.
         """
 
     def discover_templates(self) -> None:
         """Discover templates in the specified directories."""
 
-    def render_template(self, name: str, data: Dict[str, Any]) -> str:
+    def render_template(self, name: str, data: Dict[str, str]) -> str:
         """Render a template with the given name and data.
 
         Args:
             name (str): The name of the template to render.
-            data (Dict[str, Any]): The data to pass to the template.
+            data (Dict[str, str]): The data to pass to the template.
 
         Returns:
             str: The rendered template.
         """
+
+def blake3_hash(content: bytes) -> str:
+    """Calculate the BLAKE3 hash of the given data.
+
+    Args:
+        content (bytes): The data to hash.
+
+    Returns:
+        str: The BLAKE3 hash of the data.
+    """

fabricatio-0.2.0.dev19/python/fabricatio/_rust_instances.py

@@ -0,0 +1,8 @@
+from fabricatio._rust import TemplateManager
+from fabricatio.config import configs
+
+template_manager = TemplateManager(
+    template_dirs=configs.templates.template_dir,
+    suffix=configs.templates.template_suffix,
+    active_loading=configs.templates.active_loading,
+)

{fabricatio-0.2.0.dev17 → fabricatio-0.2.0.dev19}/python/fabricatio/actions/communication.py

@@ -12,4 +12,4 @@ class Talk(Action):
 
     async def _execute(self, task_input: Task[str], **_) -> str:
         """Execute the action."""
-        return await self.aask(task_input.briefing, system_message=task_input.generate_prompt())
+        return await self.aask(task_input.briefing, system_message=task_input.dependencies_prompt())

{fabricatio-0.2.0.dev17 → fabricatio-0.2.0.dev19}/python/fabricatio/config.py

@@ -63,7 +63,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", "User:"))
+    stop_sign: str | List[str] = Field(default=("\n\n\n", "User:"))
     """The stop sign of the LLM model. No default stop sign specified."""
 
     top_p: NonNegativeFloat = Field(default=0.35)
@@ -124,10 +124,27 @@ class TemplateConfig(BaseModel):
         default_factory=lambda: [DirectoryPath(r".\templates"), DirectoryPath(rf"{ROAMING_DIR}\templates")]
     )
     """The directory containing the templates."""
+    active_loading: bool = Field(default=False)
+    """Whether to enable active loading of templates."""
 
     template_suffix: str = Field(default="hbs", frozen=True)
     """The suffix of the templates."""
 
+    propose_task_template: str = Field(default="propose_task")
+    """The name of the propose task template which will be used to propose a task."""
+
+    draft_tool_usage_code_template: str = Field(default="draft_tool_usage_code")
+    """The name of the draft tool usage code template which will be used to draft tool usage code."""
+
+    make_choice_template: str = Field(default="make_choice")
+    """The name of the make choice template which will be used to make a choice."""
+
+    make_judgment_template: str = Field(default="make_judgment")
+    """The name of the make judgment template which will be used to make a judgment."""
+
+    dependencies_template: str = Field(default="dependencies")
+    """The name of the dependencies template which will be used to manage dependencies."""
+
 
 class MagikaConfig(BaseModel):
     """Magika configuration class."""

{fabricatio-0.2.0.dev17 → fabricatio-0.2.0.dev19}/python/fabricatio/fs/curd.py

@@ -5,10 +5,11 @@ import subprocess
 from pathlib import Path
 from typing import Union
 
-from fabricatio.decorators import depend_on_external_cmd
+from fabricatio.decorators import confirm_to_execute, depend_on_external_cmd
 from fabricatio.journal import logger
 
 
+@confirm_to_execute
 def copy_file(src: Union[str, Path], dst: Union[str, Path]) -> None:
     """Copy a file from source to destination.
 
@@ -28,6 +29,7 @@ def copy_file(src: Union[str, Path], dst: Union[str, Path]) -> None:
         raise
 
 
+@confirm_to_execute
 def move_file(src: Union[str, Path], dst: Union[str, Path]) -> None:
     """Move a file from source to destination.
 
@@ -47,6 +49,7 @@ def move_file(src: Union[str, Path], dst: Union[str, Path]) -> None:
         raise
 
 
+@confirm_to_execute
 def delete_file(file_path: Union[str, Path]) -> None:
     """Delete a file.
 
@@ -65,6 +68,7 @@ def delete_file(file_path: Union[str, Path]) -> None:
         raise
 
 
+@confirm_to_execute
 def create_directory(dir_path: Union[str, Path], parents: bool = True, exist_ok: bool = True) -> None:
     """Create a directory.
 
@@ -81,6 +85,7 @@ def create_directory(dir_path: Union[str, Path], parents: bool = True, exist_ok:
         raise
 
 
+@confirm_to_execute
 @depend_on_external_cmd(
     "erd",
     "Please install `erd` using `cargo install erdtree` or `scoop install erdtree`.",
@@ -92,6 +97,7 @@ def tree(dir_path: Union[str, Path]) -> str:
     return subprocess.check_output(("erd", dir_path.as_posix()), encoding="utf-8")  # noqa: S603
 
 
+@confirm_to_execute
 def delete_directory(dir_path: Union[str, Path]) -> None:
     """Delete a directory and its contents.
 

fabricatio-0.2.0.dev19/python/fabricatio/fs/readers.py

@@ -0,0 +1,24 @@
+"""Filesystem readers for Fabricatio."""
+
+from pathlib import Path
+
+from magika import Magika
+
+from fabricatio.config import configs
+
+magika = Magika(model_dir=configs.magika.model_dir)
+
+
+def safe_text_read(path: Path) -> str:
+    """Safely read the text from a file.
+
+    Args:
+        path (Path): The path to the file.
+
+    Returns:
+        str: The text from the file.
+    """
+    try:
+        return path.read_text(encoding="utf-8")
+    except (UnicodeDecodeError, IsADirectoryError, FileNotFoundError):
+        return ""

{fabricatio-0.2.0.dev17 → fabricatio-0.2.0.dev19}/python/fabricatio/models/action.py

@@ -3,17 +3,17 @@
 import traceback
 from abc import abstractmethod
 from asyncio import Queue
-from typing import Any, Dict, Self, Tuple, Type, Unpack
+from typing import Any, Dict, Self, Tuple, Type, Union, Unpack
 
 from fabricatio.journal import logger
-from fabricatio.models.advanced import ProposeTask
+from fabricatio.models.advanced import HandleTask, ProposeTask
 from fabricatio.models.generic import WithBriefing
 from fabricatio.models.task import Task
 from fabricatio.models.usages import ToolBoxUsage
 from pydantic import Field, PrivateAttr
 
 
-class Action(ProposeTask, ToolBoxUsage):
+class Action(HandleTask, ProposeTask):
     """Class that represents an action to be executed in a workflow."""
 
     personality: str = Field(default="")
@@ -52,7 +52,7 @@ class Action(ProposeTask, ToolBoxUsage):
         return f"# The action you are going to perform: \n{super().briefing}"
 
 
-class WorkFlow[A: Type[Action] | Action](WithBriefing, ToolBoxUsage):
+class WorkFlow[A: Union[Type[Action], Action]](WithBriefing, ToolBoxUsage):
     """Class that represents a workflow to be executed in a task."""
 
     _context: Queue[Dict[str, Any]] = PrivateAttr(default_factory=lambda: Queue(maxsize=1))
@@ -102,13 +102,12 @@ class WorkFlow[A: Type[Action] | Action](WithBriefing, ToolBoxUsage):
             task: The task to be served.
         """
         await task.start()
-        await self._init_context()
+        await self._init_context(task)
         current_action = None
         try:
             for step in self._instances:
                 logger.debug(f"Executing step: {step.name}")
-                cxt = await self._context.get()
-                modified_ctx = await step.act(cxt)
+                modified_ctx = await step.act(await self._context.get())
                 await self._context.put(modified_ctx)
                 current_action = step.name
             logger.info(f"Finished executing workflow: {self.name}")
@@ -118,10 +117,10 @@ class WorkFlow[A: Type[Action] | Action](WithBriefing, ToolBoxUsage):
             logger.error(traceback.format_exc())  # Add this line to log the traceback
             await task.fail()  # Mark the task as failed
 
-    async def _init_context(self) -> None:
+    async def _init_context[T](self, task: Task[T]) -> None:
         """Initialize the context dictionary for workflow execution."""
         logger.debug(f"Initializing context for workflow: {self.name}")
-        await self._context.put({self.task_input_key: None, **dict(self.extra_init_context)})
+        await self._context.put({self.task_input_key: task, **dict(self.extra_init_context)})
 
     def steps_fallback_to_self(self) -> Self:
         """Set the fallback for each step to the workflow itself."""

fabricatio-0.2.0.dev19/python/fabricatio/models/advanced.py

@@ -0,0 +1,119 @@
+"""A module for advanced models and functionalities."""
+
+from types import CodeType
+from typing import List, Optional, Tuple, Unpack
+
+import orjson
+from fabricatio._rust_instances import template_manager
+from fabricatio.config import configs
+from fabricatio.models.generic import WithBriefing
+from fabricatio.models.kwargs_types import LLMKwargs
+from fabricatio.models.task import Task
+from fabricatio.models.tool import Tool, ToolExecutor
+from fabricatio.models.usages import LLMUsage, ToolBoxUsage
+from fabricatio.parser import JsonCapture, PythonCapture
+from loguru import logger
+from pydantic import PositiveInt, ValidationError
+
+
+class ProposeTask(WithBriefing, LLMUsage):
+    """A class that proposes a task based on a prompt."""
+
+    async def propose[T](
+        self,
+        prompt: str,
+        max_validations: PositiveInt = 2,
+        **kwargs: Unpack[LLMKwargs],
+    ) -> Task[T]:
+        """Asynchronously proposes a task based on a given prompt and parameters.
+
+        Parameters:
+            prompt: The prompt text for proposing a task, which is a string that must be provided.
+            max_validations: The maximum number of validations allowed, default is 2.
+            **kwargs: The keyword arguments for the LLM (Large Language Model) usage.
+
+        Returns:
+            A Task object based on the proposal result.
+        """
+        if not prompt:
+            err = f"{self.name}: Prompt must be provided."
+            logger.error(err)
+            raise ValueError(err)
+
+        def _validate_json(response: str) -> None | Task:
+            try:
+                cap = JsonCapture.capture(response)
+                logger.debug(f"Response: \n{response}")
+                logger.info(f"Captured JSON: \n{cap}")
+                return Task.model_validate_json(cap)
+            except ValidationError as e:
+                logger.error(f"Failed to parse task from JSON: {e}")
+                return None
+
+        template_data = {"prompt": prompt, "json_example": Task.json_example()}
+        return await self.aask_validate(
+            question=template_manager.render_template(configs.templates.propose_task_template, template_data),
+            validator=_validate_json,
+            system_message=f"# your personal briefing: \n{self.briefing}",
+            max_validations=max_validations,
+            **kwargs,
+        )
+
+
+class HandleTask(WithBriefing, ToolBoxUsage):
+    """A class that handles a task based on a task object."""
+
+    async def draft_tool_usage_code(
+        self,
+        task: Task,
+        tools: List[Tool],
+        **kwargs: Unpack[LLMKwargs],
+    ) -> 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}")
+
+        if not tools:
+            err = f"{self.name}: Tools must be provided to draft the tool usage code."
+            logger.error(err)
+            raise ValueError(err)
+
+        def _validator(response: str) -> Tuple[CodeType, List[str]] | None:
+            if (source := PythonCapture.convert_with(response, lambda resp: compile(resp, "<string>", "exec"))) and (
+                to_extract := JsonCapture.convert_with(response, orjson.loads)
+            ):
+                return source, to_extract
+            return None
+
+        return await self.aask_validate(
+            question=template_manager.render_template(
+                configs.templates.draft_tool_usage_code_template,
+                {
+                    "tool_module_name": configs.toolbox.tool_module_name,
+                    "task": task.briefing,
+                    "tools": [tool.briefing for tool in tools],
+                },
+            ),
+            validator=_validator,
+            system_message=f"# your personal briefing: \n{self.briefing}",
+            **kwargs,
+        )
+
+    async def handle_fin_grind(
+        self,
+        task: Task,
+        **kwargs: Unpack[LLMKwargs],
+    ) -> Optional[Tuple]:
+        """Asynchronously handles a task based on a given task object and parameters."""
+        logger.info(f"Handling task: {task.briefing}")
+
+        tools = await self.gather_tools(task)
+        logger.info(f"{self.name} have gathered {len(tools)} tools gathered")
+
+        if tools:
+            executor = ToolExecutor(execute_sequence=tools)
+            code, to_extract = await self.draft_tool_usage_code(task, tools, **kwargs)
+            cxt = await executor.execute(code)
+            if to_extract:
+                return tuple(cxt.get(k) for k in to_extract)
+
+        return None

{fabricatio-0.2.0.dev17 → fabricatio-0.2.0.dev19}/python/fabricatio/models/events.py

@@ -1,11 +1,11 @@
 """The module containing the Event class."""
 
-from typing import List, Self
+from typing import List, Self, Union
 
 from fabricatio.config import configs
 from pydantic import BaseModel, ConfigDict, Field
 
-type EventLike = str | List[str] | Self
+type EventLike = Union[str, List[str], "Event"]
 
 
 class Event(BaseModel):

{fabricatio-0.2.0.dev17 → fabricatio-0.2.0.dev19}/python/fabricatio/models/generic.py

@@ -4,7 +4,10 @@ from pathlib import Path
 from typing import List, Self
 
 import orjson
-from fabricatio.fs.readers import magika
+from fabricatio._rust import blake3_hash
+from fabricatio._rust_instances import template_manager
+from fabricatio.config import configs
+from fabricatio.fs.readers import magika, safe_text_read
 from pydantic import (
     BaseModel,
     ConfigDict,
@@ -96,15 +99,25 @@ class WithDependency(Base):
             self.dependencies.remove(Path(d).as_posix())
         return self
 
-    def generate_prompt(self) -> str:
+    @property
+    def dependencies_prompt(self) -> str:
         """Generate a prompt for the task based on the file dependencies.
 
         Returns:
             str: The generated prompt for the task.
         """
-        contents = [Path(d).read_text("utf-8") for d in self.dependencies]
-        recognized = [magika.identify_path(c) for c in contents]
-        out = ""
-        for r, p, c in zip(recognized, self.dependencies, contents, strict=False):
-            out += f"---\n\n> {p}\n```{r.dl.ct_label}\n{c}\n```\n\n"
-        return out
+        return template_manager.render_template(
+            configs.templates.dependencies_template,
+            {
+                (pth := Path(p)).as_posix(): {
+                    "exists": pth.exists(),
+                    "description": (identity := magika.identify_path(pth)).output.description,
+                    "size": f"{pth.stat().st_size / (1024 * 1024) if pth.exists() and pth.is_file() else 0:.3f} MB",
+                    "content": (text := safe_text_read(pth)),
+                    "lines": len(text.splitlines()),
+                    "language": identity.output.ct_label,
+                    "checksum": blake3_hash(pth.read_bytes()) if pth.exists() and pth.is_file() else "unknown",
+                }
+                for p in self.dependencies
+            },
+        )

fabricatio-0.2.0.dev19/python/fabricatio/models/kwargs_types.py

@@ -0,0 +1,26 @@
+"""This module contains the types for the keyword arguments of the methods in the models module."""
+
+from typing import List, NotRequired, TypedDict
+
+from pydantic import NonNegativeFloat, NonNegativeInt, PositiveInt
+
+
+class LLMKwargs(TypedDict):
+    """A type representing the keyword arguments for the LLM (Large Language Model) usage."""
+
+    model: NotRequired[str]
+    temperature: NotRequired[NonNegativeFloat]
+    stop: NotRequired[str | List[str]]
+    top_p: NotRequired[NonNegativeFloat]
+    max_tokens: NotRequired[PositiveInt]
+    stream: NotRequired[bool]
+    timeout: NotRequired[PositiveInt]
+    max_retries: NotRequired[PositiveInt]
+
+
+class ChooseKwargs(LLMKwargs):
+    """A type representing the keyword arguments for the choose method."""
+
+    max_validations: NotRequired[PositiveInt]
+    system_message: NotRequired[str]
+    k: NotRequired[NonNegativeInt]

{fabricatio-0.2.0.dev17 → fabricatio-0.2.0.dev19}/python/fabricatio/models/role.py

@@ -1,6 +1,6 @@
 """Module that contains the Role class."""
 
-from typing import Any, Set
+from typing import Any, Self, Set
 
 from fabricatio.core import env
 from fabricatio.journal import logger
@@ -22,8 +22,22 @@ class Role(ProposeTask, ToolBoxUsage):
     toolboxes: Set[ToolBox] = Field(default=basic_toolboxes)
 
     def model_post_init(self, __context: Any) -> None:
+        """Register the workflows in the role to the event bus."""
+        self.resolve_configuration().register_workflows()
+
+    def register_workflows(self) -> Self:
         """Register the workflows in the role to the event bus."""
         for event, workflow in self.registry.items():
+            logger.debug(
+                f"Registering workflow: `{workflow.name}` for event: `{Event.instantiate_from(event).collapse()}`"
+            )
+            env.on(event, workflow.serve)
+        return self
+
+    def resolve_configuration(self) -> Self:
+        """Resolve the configuration of the role."""
+        for workflow in self.registry.values():
+            logger.debug(f"Resolving config for workflow: `{workflow.name}`")
             (
                 workflow.fallback_to(self)
                 .steps_fallback_to_self()
@@ -32,7 +46,4 @@ class Role(ProposeTask, ToolBoxUsage):
                 .steps_supply_tools_from_self()
             )
 
-            logger.debug(
-                f"Registering workflow: {workflow.name} for event: {event.collapse() if isinstance(event, Event) else event}"
-            )
-            env.on(event, workflow.serve)
+        return self