fabricatio 0.2.0.dev15__tar.gz → 0.2.0.dev17__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.0.dev15
+Version: 0.2.0.dev17
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -22,6 +22,11 @@ Requires-Dist: pymitter>=1.0.0
 Requires-Dist: questionary>=2.1.0
 Requires-Dist: regex>=2024.11.6
 Requires-Dist: rich>=13.9.4
+Requires-Dist: faiss-cpu>=1.10.0 ; extra == 'rag'
+Requires-Dist: pymilvus>=2.5.4 ; extra == 'rag'
+Requires-Dist: fabricatio[rag] ; extra == 'full'
+Provides-Extra: rag
+Provides-Extra: full
 License-File: LICENSE
 Summary: A LLM multi-agent framework.
 Keywords: ai,agents,multi-agent,llm,pyo3

{fabricatio-0.2.0.dev15 → fabricatio-0.2.0.dev17}/examples/llm_usages/llm_usage.py

@@ -1,3 +1,5 @@
+"""Example of using the library."""
+
 import asyncio
 from typing import Any, Callable
 

{fabricatio-0.2.0.dev15 → fabricatio-0.2.0.dev17}/examples/minor/hello_fabricatio.py

@@ -1,3 +1,5 @@
+"""Example of a simple hello world program using fabricatio."""
+
 import asyncio
 from typing import Any
 

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

@@ -1,3 +1,5 @@
+"""Example of proposing a task to a role."""
+
 import asyncio
 from typing import Any
 

{fabricatio-0.2.0.dev15 → fabricatio-0.2.0.dev17}/examples/simple_chat/chat.py

@@ -1,3 +1,5 @@
+"""Simple chat example."""
+
 import asyncio
 from typing import Any
 

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

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.0-dev.15"
+version = "0.2.0-dev.17"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -47,6 +47,8 @@ dependencies = [
 Homepage = "https://github.com/Whth/fabricatio"
 Repository = "https://github.com/Whth/fabricatio"
 Issues = "https://github.com/Whth/fabricatio/issues"
+
+
 [build-system]
 requires = ["maturin>=1.0,<2.0"]
 build-backend = "maturin"
@@ -59,6 +61,9 @@ data = "extra"
 dev = [
     "maturin>=1.8.2",
     "maturin-import-hook>=0.2.0",
+    "ruff>=0.9.4",
+    "uv>=0.5.29",
+    "viztracer>=1.0.2",
     "pytest>=8.3.4",
     "pytest-asyncio>=0.25.3",
     "pytest-cov>=6.0.0",
@@ -67,10 +72,9 @@ dev = [
     "pytest-mock>=3.14.0",
     "pytest-rerunfailures>=15.0",
     "pytest-xdist>=3.6.1",
-    "ruff>=0.9.4",
-    "uv>=0.5.29",
-    "viztracer>=1.0.2",
 ]
+
+[project.optional-dependencies]
 rag = [
     "faiss-cpu>=1.10.0",
     "pymilvus>=2.5.4",
@@ -80,7 +84,6 @@ full = [
     "fabricatio[rag]",
 ]
 
-
 [tool.ruff]
 include = ["pyproject.toml", "python/fabricatio/*.py","python/fabricatio/*.pyi", "examples/*.py"]
 line-length = 120
@@ -117,10 +120,8 @@ select = [
     "RUF", # Ruff-specific rules
 ]
 ignore = [
-    "S101",
     "ANN401",
     "ANN003",
-    "D100",
     "PYI063",
     "PYI021",
     "ASYNC109"
@@ -138,7 +139,7 @@ testpaths = [
 ]
 
 [tool.uv.sources]
-code2prompt = { git = "https://github.com/mufeedvh/code2prompt" }
+code2prompt = { git = "https://github.com/mufeedvh/code2prompt", rev = "d157ee84827458bd6816142e213886487d28bd3d" }
 
 [[tool.uv.index]]
 url = "https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple"

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

@@ -1,3 +1,5 @@
+"""Actions that involve communication with the user."""
+
 from fabricatio.models.action import Action
 from fabricatio.models.task import Task
 

{fabricatio-0.2.0.dev15 → fabricatio-0.2.0.dev17}/python/fabricatio/actions/transmission.py

@@ -1,3 +1,5 @@
+"""Actions for transmitting tasks to targets."""
+
 from typing import List
 
 from fabricatio.journal import logger

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

@@ -148,6 +148,15 @@ class GeneralConfig(BaseModel):
     """Whether to confirm on file system operations."""
 
 
+class ToolBoxConfig(BaseModel):
+    """Toolbox configuration class."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+
+    tool_module_name: str = Field(default="Toolbox")
+    """The name of the module containing the toolbox."""
+
+
 class Settings(BaseSettings):
     """Application settings class.
 
@@ -185,6 +194,10 @@ class Settings(BaseSettings):
     """Magika Configuration"""
 
     general: GeneralConfig = Field(default_factory=GeneralConfig)
+    """General Configuration"""
+
+    toolbox: ToolBoxConfig = Field(default_factory=ToolBoxConfig)
+    """Toolbox Configuration"""
 
     @classmethod
     def settings_customise_sources(

{fabricatio-0.2.0.dev15 → fabricatio-0.2.0.dev17}/python/fabricatio/decorators.py

@@ -1,3 +1,5 @@
+"""Decorators for Fabricatio."""
+
 from functools import wraps
 from inspect import signature
 from shutil import which

{fabricatio-0.2.0.dev15 → fabricatio-0.2.0.dev17}/python/fabricatio/models/advanced.py

@@ -44,7 +44,10 @@ class ProposeTask(LLMUsage, WithBriefing):
         Returns:
             A Task object based on the proposal result.
         """
-        assert prompt, "Prompt must be provided."
+        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:

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

@@ -47,8 +47,10 @@ class Event(BaseModel):
 
     def push(self, segment: str) -> Self:
         """Push a segment to the event."""
-        assert segment, "The segment must not be empty."
-        assert configs.pymitter.delimiter not in segment, "The segment must not contain the delimiter."
+        if not segment:
+            raise ValueError("The segment must not be empty.")
+        if configs.pymitter.delimiter in segment:
+            raise ValueError("The segment must not contain the delimiter.")
 
         self.segments.append(segment)
         return self

{fabricatio-0.2.0.dev15 → fabricatio-0.2.0.dev17}/python/fabricatio/models/tool.py

@@ -1,9 +1,13 @@
 """A module for defining tools and toolboxes."""
 
+from importlib.machinery import ModuleSpec
+from importlib.util import module_from_spec
 from inspect import iscoroutinefunction, signature
-from types import CodeType
+from sys import modules
+from types import CodeType, ModuleType
 from typing import Any, Callable, Dict, List, Optional, Self, overload
 
+from fabricatio.config import configs
 from fabricatio.journal import logger
 from fabricatio.models.generic import WithBriefing
 from pydantic import BaseModel, ConfigDict, Field
@@ -24,7 +28,9 @@ class Tool[**P, R](WithBriefing):
     def model_post_init(self, __context: Any) -> None:
         """Initialize the tool with a name and a source function."""
         self.name = self.name or self.source.__name__
-        assert self.name, "The tool must have a name."
+
+        if not self.name:
+            raise RuntimeError("The tool must have a source function.")
         self.description = self.description or self.source.__doc__ or ""
         self.description = self.description.strip()
 
@@ -102,13 +108,13 @@ class ToolBox(WithBriefing):
             Tool: The tool instance with the specified name.
 
         Raises:
-            AssertionError: If no tool with the specified name is found.
+            ValueError: If no tool with the specified name is found.
         """
         tool = next((tool for tool in self.tools if tool.name == name), None)
         if tool is None:
             err = f"No tool with the name {name} found in the toolbox."
             logger.error(err)
-            raise AssertionError(err)
+            raise ValueError(err)
 
         return tool
 
@@ -124,14 +130,18 @@ class ToolExecutor(BaseModel):
     execute_sequence: List[Tool] = Field(default_factory=list, frozen=True)
     """The sequence of tools to execute."""
 
-    def inject_tools[C: Dict[str, Any]](self, cxt: Optional[C] = None) -> C:
-        """Inject the tools into the context."""
-        cxt = cxt or {}
-        return {**cxt, **{tool.name: tool for tool in self.execute_sequence}}
+    def inject_tools[M: ModuleType](self, module: Optional[M] = None) -> M:
+        """Inject the tools into the provided module."""
+        module = module or module_from_spec(spec=ModuleSpec(name=configs.toolbox.tool_module_name, loader=None))
+        for tool in self.execute_sequence:
+            setattr(module, tool.name, tool.invoke)
+        return module
 
     def execute[C: Dict[str, Any]](self, source: CodeType, cxt: Optional[C] = None) -> C:
         """Execute the sequence of tools with the provided context."""
-        exec(source, (cxt := self.inject_tools(cxt)))  # noqa: S102
+        modules[configs.toolbox.tool_module_name] = self.inject_tools()
+        exec(source, cxt)  # noqa: S102
+        modules.pop(configs.toolbox.tool_module_name)
         return cxt
 
     @overload

{fabricatio-0.2.0.dev15 → fabricatio-0.2.0.dev17}/python/fabricatio/models/usages.py

@@ -1,20 +1,34 @@
 """This module contains classes that manage the usage of language models and tools in tasks."""
 
-from typing import Callable, Dict, Iterable, List, Optional, Self, Set, Union
+from typing import Callable, Dict, Iterable, List, NotRequired, Optional, Self, Set, TypedDict, Union, Unpack
 
 import litellm
 import orjson
 from fabricatio._rust_instances import template_manager
 from fabricatio.config import configs
+from fabricatio.journal import logger
 from fabricatio.models.generic import Base, WithBriefing
 from fabricatio.models.task import Task
-from fabricatio.models.tool import ToolBox
+from fabricatio.models.tool import Tool, ToolBox
 from fabricatio.models.utils import Messages
 from fabricatio.parser import JsonCapture
 from litellm.types.utils import Choices, ModelResponse, StreamingChoices
 from pydantic import Field, HttpUrl, NonNegativeFloat, NonNegativeInt, PositiveInt, SecretStr
 
 
+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 LLMUsage(Base):
     """Class that manages LLM (Large Language Model) usage parameters and methods."""
 
@@ -54,29 +68,15 @@ class LLMUsage(Base):
     async def aquery(
         self,
         messages: List[Dict[str, str]],
-        model: str | None = None,
-        temperature: NonNegativeFloat | None = None,
-        stop: str | List[str] | None = None,
-        top_p: NonNegativeFloat | None = None,
-        max_tokens: PositiveInt | None = None,
         n: PositiveInt | None = None,
-        stream: bool | None = None,
-        timeout: PositiveInt | None = None,
-        max_retries: PositiveInt | None = None,
+        **kwargs: Unpack[LLMKwargs],
     ) -> ModelResponse:
         """Asynchronously queries the language model to generate a response based on the provided messages and parameters.
 
         Args:
             messages (List[Dict[str, str]]): A list of messages, where each message is a dictionary containing the role and content of the message.
-            model (str | None): The name of the model to use. If not provided, the default model will be used.
-            temperature (NonNegativeFloat | None): Controls the randomness of the output. Lower values make the output more deterministic.
-            stop (str | None): A sequence at which to stop the generation of the response.
-            top_p (NonNegativeFloat | None): Controls the diversity of the output through nucleus sampling.
-            max_tokens (PositiveInt | None): The maximum number of tokens to generate in the response.
-            n (PositiveInt | None): The number of responses to generate.
-            stream (bool | None): Whether to receive the response in a streaming fashion.
-            timeout (PositiveInt | None): The timeout duration for the request.
-            max_retries (PositiveInt | None): The maximum number of retries in case of failure.
+            n (PositiveInt | None): The number of responses to generate. Defaults to the instance's `llm_generation_count` or the global configuration.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
 
         Returns:
             ModelResponse: An object containing the generated response and other metadata from the model.
@@ -84,15 +84,15 @@ class LLMUsage(Base):
         # Call the underlying asynchronous completion function with the provided and default parameters
         return await litellm.acompletion(
             messages=messages,
-            model=model or self.llm_model or configs.llm.model,
-            temperature=temperature or self.llm_temperature or configs.llm.temperature,
-            stop=stop or self.llm_stop_sign or configs.llm.stop_sign,
-            top_p=top_p or self.llm_top_p or configs.llm.top_p,
-            max_tokens=max_tokens or self.llm_max_tokens or configs.llm.max_tokens,
             n=n or self.llm_generation_count or configs.llm.generation_count,
-            stream=stream or self.llm_stream or configs.llm.stream,
-            timeout=timeout or self.llm_timeout or configs.llm.timeout,
-            max_retries=max_retries or self.llm_max_retries or configs.llm.max_retries,
+            model=kwargs.get("model") or self.llm_model or configs.llm.model,
+            temperature=kwargs.get("temperature") or self.llm_temperature or configs.llm.temperature,
+            stop=kwargs.get("stop") or self.llm_stop_sign or configs.llm.stop_sign,
+            top_p=kwargs.get("top_p") or self.llm_top_p or configs.llm.top_p,
+            max_tokens=kwargs.get("max_tokens") or self.llm_max_tokens or configs.llm.max_tokens,
+            stream=kwargs.get("stream") or self.llm_stream or configs.llm.stream,
+            timeout=kwargs.get("timeout") or self.llm_timeout or configs.llm.timeout,
+            max_retries=kwargs.get("max_retries") or self.llm_max_retries or configs.llm.max_retries,
             api_key=self.llm_api_key.get_secret_value() if self.llm_api_key else configs.llm.api_key.get_secret_value(),
             base_url=self.llm_api_endpoint.unicode_string()
             if self.llm_api_endpoint
@@ -103,30 +103,16 @@ class LLMUsage(Base):
         self,
         question: str,
         system_message: str = "",
-        model: str | None = None,
-        temperature: NonNegativeFloat | None = None,
-        stop: str | List[str] | None = None,
-        top_p: NonNegativeFloat | None = None,
-        max_tokens: PositiveInt | None = None,
         n: PositiveInt | None = None,
-        stream: bool | None = None,
-        timeout: PositiveInt | None = None,
-        max_retries: PositiveInt | None = None,
+        **kwargs: Unpack[LLMKwargs],
     ) -> List[Choices | StreamingChoices]:
         """Asynchronously invokes the language model with a question and optional system message.
 
         Args:
             question (str): The question to ask the model.
-            system_message (str): The system message to provide context to the model.
-            model (str | None): The name of the model to use. If not provided, the default model will be used.
-            temperature (NonNegativeFloat | None): Controls the randomness of the output. Lower values make the output more deterministic.
-            stop (str | None): A sequence at which to stop the generation of the response.
-            top_p (NonNegativeFloat | None): Controls the diversity of the output through nucleus sampling.
-            max_tokens (PositiveInt | None): The maximum number of tokens to generate in the response.
-            n (PositiveInt | None): The number of responses to generate.
-            stream (bool | None): Whether to receive the response in a streaming fashion.
-            timeout (PositiveInt | None): The timeout duration for the request.
-            max_retries (PositiveInt | None): The maximum number of retries in case of failure.
+            system_message (str): The system message to provide context to the model. Defaults to an empty string.
+            n (PositiveInt | None): The number of responses to generate. Defaults to the instance's `llm_generation_count` or the global configuration.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
 
         Returns:
             List[Choices | StreamingChoices]: A list of choices or streaming choices from the model response.
@@ -134,15 +120,8 @@ class LLMUsage(Base):
         return (
             await self.aquery(
                 messages=Messages().add_system_message(system_message).add_user_message(question),
-                model=model,
-                temperature=temperature,
-                stop=stop,
-                top_p=top_p,
-                max_tokens=max_tokens,
                 n=n,
-                stream=stream,
-                timeout=timeout,
-                max_retries=max_retries,
+                **kwargs,
             )
         ).choices
 
@@ -150,28 +129,14 @@ class LLMUsage(Base):
         self,
         question: str,
         system_message: str = "",
-        model: str | None = None,
-        temperature: NonNegativeFloat | None = None,
-        stop: str | List[str] | None = None,
-        top_p: NonNegativeFloat | None = None,
-        max_tokens: PositiveInt | None = None,
-        stream: bool | None = None,
-        timeout: PositiveInt | None = None,
-        max_retries: PositiveInt | None = None,
+        **kwargs: Unpack[LLMKwargs],
     ) -> str:
         """Asynchronously asks the language model a question and returns the response content.
 
         Args:
             question (str): The question to ask the model.
-            system_message (str): The system message to provide context to the model.
-            model (str | None): The name of the model to use. If not provided, the default model will be used.
-            temperature (NonNegativeFloat | None): Controls the randomness of the output. Lower values make the output more deterministic.
-            stop (str | None): A sequence at which to stop the generation of the response.
-            top_p (NonNegativeFloat | None): Controls the diversity of the output through nucleus sampling.
-            max_tokens (PositiveInt | None): The maximum number of tokens to generate in the response.
-            stream (bool | None): Whether to receive the response in a streaming fashion.
-            timeout (PositiveInt | None): The timeout duration for the request.
-            max_retries (PositiveInt | None): The maximum number of retries in case of failure.
+            system_message (str): The system message to provide context to the model. Defaults to an empty string.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
 
         Returns:
             str: The content of the model's response message.
@@ -182,14 +147,7 @@ class LLMUsage(Base):
                     n=1,
                     question=question,
                     system_message=system_message,
-                    model=model,
-                    temperature=temperature,
-                    stop=stop,
-                    top_p=top_p,
-                    max_tokens=max_tokens,
-                    stream=stream,
-                    timeout=timeout,
-                    max_retries=max_retries,
+                    **kwargs,
                 )
             )
             .pop()
@@ -202,30 +160,16 @@ class LLMUsage(Base):
         validator: Callable[[str], T | None],
         max_validations: PositiveInt = 2,
         system_message: str = "",
-        model: str | None = None,
-        temperature: NonNegativeFloat | None = None,
-        stop: str | List[str] | None = None,
-        top_p: NonNegativeFloat | None = None,
-        max_tokens: PositiveInt | None = None,
-        stream: bool | None = None,
-        timeout: PositiveInt | None = None,
-        max_retries: PositiveInt | None = None,
+        **kwargs: Unpack[LLMKwargs],
     ) -> T:
-        """Asynchronously ask a question and validate the response using a given validator.
+        """Asynchronously asks a question and validates the response using a given validator.
 
         Args:
             question (str): The question to ask.
             validator (Callable[[str], T | None]): A function to validate the response.
-            max_validations (PositiveInt): Maximum number of validation attempts.
-            system_message (str): System message to include in the request.
-            model (str | None): The model to use for the request.
-            temperature (NonNegativeFloat | None): Temperature setting for the request.
-            stop (str | None): Stop sequence for the request.
-            top_p (NonNegativeFloat | None): Top-p sampling parameter.
-            max_tokens (PositiveInt | None): Maximum number of tokens in the response.
-            stream (bool | None): Whether to stream the response.
-            timeout (PositiveInt | None): Timeout for the request.
-            max_retries (PositiveInt | None): Maximum number of retries for the request.
+            max_validations (PositiveInt): Maximum number of validation attempts. Defaults to 2.
+            system_message (str): System message to include in the request. Defaults to an empty string.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
 
         Returns:
             T: The validated response.
@@ -238,14 +182,7 @@ class LLMUsage(Base):
                 response := await self.aask(
                     question=question,
                     system_message=system_message,
-                    model=model,
-                    temperature=temperature,
-                    stop=stop,
-                    top_p=top_p,
-                    max_tokens=max_tokens,
-                    stream=stream,
-                    timeout=timeout,
-                    max_retries=max_retries,
+                    **kwargs,
                 )
             ) and (validated := validator(response)):
                 return validated
@@ -258,31 +195,17 @@ class LLMUsage(Base):
         k: NonNegativeInt = 0,
         max_validations: PositiveInt = 2,
         system_message: str = "",
-        model: str | None = None,
-        temperature: NonNegativeFloat | None = None,
-        stop: str | List[str] | None = None,
-        top_p: NonNegativeFloat | None = None,
-        max_tokens: PositiveInt | None = None,
-        stream: bool | None = None,
-        timeout: PositiveInt | None = None,
-        max_retries: PositiveInt | None = None,
+        **kwargs: Unpack[LLMKwargs],
     ) -> List[T]:
         """Asynchronously executes a multi-choice decision-making process, generating a prompt based on the instruction and options, and validates the returned selection results.
 
         Args:
-            instruction: The user-provided instruction/question description.
-            choices: A list of candidate options, requiring elements to have `name` and `briefing` fields.
-            k: The number of choices to select, 0 means infinite.
-            max_validations: Maximum number of validation failures, default is 2.
-            system_message: Custom system-level prompt, defaults to an empty string.
-            model: The name of the LLM model to use.
-            temperature: Sampling temperature to control randomness in generation.
-            stop: Stop condition string or list for generation.
-            top_p: Core sampling probability threshold.
-            max_tokens: Maximum token limit for the generated result.
-            stream: Whether to enable streaming response mode.
-            timeout: Request timeout in seconds.
-            max_retries: Maximum number of retries.
+            instruction (str): The user-provided instruction/question description.
+            choices (List[T]): A list of candidate options, requiring elements to have `name` and `briefing` fields.
+            k (NonNegativeInt): The number of choices to select, 0 means infinite. Defaults to 0.
+            max_validations (PositiveInt): Maximum number of validation failures, default is 2.
+            system_message (str): Custom system-level prompt, defaults to an empty string.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
 
         Returns:
             List[T]: The final validated selection result list, with element types matching the input `choices`.
@@ -315,14 +238,7 @@ class LLMUsage(Base):
             validator=_validate,
             max_validations=max_validations,
             system_message=system_message,
-            model=model,
-            temperature=temperature,
-            stop=stop,
-            top_p=top_p,
-            max_tokens=max_tokens,
-            stream=stream,
-            timeout=timeout,
-            max_retries=max_retries,
+            **kwargs,
         )
 
     async def ajudge(
@@ -332,31 +248,17 @@ class LLMUsage(Base):
         deny_case: str = "",
         max_validations: PositiveInt = 2,
         system_message: str = "",
-        model: str | None = None,
-        temperature: NonNegativeFloat | None = None,
-        stop: str | List[str] | None = None,
-        top_p: NonNegativeFloat | None = None,
-        max_tokens: PositiveInt | None = None,
-        stream: bool | None = None,
-        timeout: PositiveInt | None = None,
-        max_retries: PositiveInt | None = None,
+        **kwargs: Unpack[LLMKwargs],
     ) -> bool:
         """Asynchronously judges a prompt using AI validation.
 
         Args:
             prompt (str): The input prompt to be judged.
-            affirm_case (str, optional): The affirmative case for the AI model. Defaults to "".
-            deny_case (str, optional): The negative case for the AI model. Defaults to "".
-            max_validations (PositiveInt, optional): Maximum number of validation attempts. Defaults to 2.
-            system_message (str, optional): System message for the AI model. Defaults to "".
-            model (str | None, optional): AI model to use. Defaults to None.
-            temperature (NonNegativeFloat | None, optional): Sampling temperature. Defaults to None.
-            stop (str | List[str] | None, optional): Stop sequences. Defaults to None.
-            top_p (NonNegativeFloat | None, optional): Nucleus sampling parameter. Defaults to None.
-            max_tokens (PositiveInt | None, optional): Maximum number of tokens to generate. Defaults to None.
-            stream (bool | None, optional): Whether to stream the response. Defaults to None.
-            timeout (PositiveInt | None, optional): Timeout in seconds. Defaults to None.
-            max_retries (PositiveInt | None, optional): Maximum number of retries. Defaults to None.
+            affirm_case (str): The affirmative case for the AI model. Defaults to an empty string.
+            deny_case (str): The negative case for the AI model. Defaults to an empty string.
+            max_validations (PositiveInt): Maximum number of validation attempts. Defaults to 2.
+            system_message (str): System message for the AI model. Defaults to an empty string.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
 
         Returns:
             bool: The judgment result (True or False) based on the AI's response.
@@ -379,14 +281,7 @@ class LLMUsage(Base):
             validator=_validate,
             max_validations=max_validations,
             system_message=system_message,
-            model=model,
-            temperature=temperature,
-            stop=stop,
-            top_p=top_p,
-            max_tokens=max_tokens,
-            stream=stream,
-            timeout=timeout,
-            max_retries=max_retries,
+            **kwargs,
         )
 
     def fallback_to(self, other: "LLMUsage") -> Self:
@@ -424,30 +319,123 @@ class LLMUsage(Base):
                     setattr(other, attr_name, attr)
 
 
+class ChooseKwargs(LLMKwargs):
+    """A type representing the keyword arguments for the choose method."""
+
+    max_validations: NotRequired[PositiveInt]
+    system_message: NotRequired[str]
+    k: NotRequired[NonNegativeInt]
+
+
 class ToolBoxUsage(LLMUsage):
     """A class representing the usage of tools in a task."""
 
     toolboxes: Set[ToolBox] = Field(default_factory=set)
     """A set of toolboxes used by the instance."""
 
-    async def choose_toolboxes(self, task: Task):
-        # TODO: Implement this method
-        pass
-
-    async def choose_tool(self, task, toolbox: ToolBox | str):
-        # TODO Implement this method
-        pass
-
     @property
     def available_toolbox_names(self) -> List[str]:
         """Return a list of available toolbox names."""
         return [toolbox.name for toolbox in self.toolboxes]
 
-    def supply_tools_from(self, others: Union["ToolBoxUsage", Iterable["ToolBoxUsage"]]) -> Self:
+    async def choose_toolboxes(
+        self,
+        task: Task,
+        system_message: str = "",
+        k: NonNegativeInt = 0,
+        max_validations: PositiveInt = 2,
+        **kwargs: Unpack[LLMKwargs],
+    ) -> List[ToolBox]:
+        """Asynchronously executes a multi-choice decision-making process to choose toolboxes.
+
+        Args:
+            task (Task): The task for which to choose toolboxes.
+            system_message (str): Custom system-level prompt, defaults to an empty string.
+            k (NonNegativeInt): The number of toolboxes to select, 0 means infinite. Defaults to 0.
+            max_validations (PositiveInt): Maximum number of validation failures, default is 2.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
+
+        Returns:
+            List[ToolBox]: The selected toolboxes.
+        """
+        if not self.toolboxes:
+            logger.warning("No toolboxes available.")
+            return []
+        return await self.achoose(
+            instruction=task.briefing,
+            choices=list(self.toolboxes),
+            k=k,
+            max_validations=max_validations,
+            system_message=system_message,
+            **kwargs,
+        )
+
+    async def choose_tools(
+        self,
+        task: Task,
+        toolbox: ToolBox,
+        system_message: str = "",
+        k: NonNegativeInt = 0,
+        max_validations: PositiveInt = 2,
+        **kwargs: Unpack[LLMKwargs],
+    ) -> List[Tool]:
+        """Asynchronously executes a multi-choice decision-making process to choose tools.
+
+        Args:
+            task (Task): The task for which to choose tools.
+            toolbox (ToolBox): The toolbox from which to choose tools.
+            system_message (str): Custom system-level prompt, defaults to an empty string.
+            k (NonNegativeInt): The number of tools to select, 0 means infinite. Defaults to 0.
+            max_validations (PositiveInt): Maximum number of validation failures, default is 2.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments for the LLM usage, such as `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
+
+        Returns:
+            List[Tool]: The selected tools.
+        """
+        if not toolbox.tools:
+            logger.warning(f"No tools available in toolbox {toolbox.name}.")
+            return []
+        return await self.achoose(
+            instruction=task.briefing,
+            choices=toolbox.tools,
+            k=k,
+            max_validations=max_validations,
+            system_message=system_message,
+            **kwargs,
+        )
+
+    async def gather_tools(
+        self,
+        task: Task,
+        box_choose_kwargs: Optional[ChooseKwargs] = None,
+        tool_choose_kwargs: Optional[ChooseKwargs] = None,
+    ) -> List[Tool]:
+        """Asynchronously gathers tools based on the provided task and toolbox and tool selection criteria.
+
+        Args:
+            task (Task): The task for which to gather tools.
+            box_choose_kwargs (Optional[ChooseKwargs]): Keyword arguments for choosing toolboxes, such as `system_message`, `k`, `max_validations`, `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
+            tool_choose_kwargs (Optional[ChooseKwargs]): Keyword arguments for choosing tools, such as `system_message`, `k`, `max_validations`, `model`, `temperature`, `stop`, `top_p`, `max_tokens`, `stream`, `timeout`, and `max_retries`.
+
+        Returns:
+            List[Tool]: A list of tools gathered based on the provided task and toolbox and tool selection criteria.
+        """
+        box_choose_kwargs = box_choose_kwargs or {}
+        tool_choose_kwargs = tool_choose_kwargs or {}
+
+        # Choose the toolboxes
+        chosen_toolboxes = await self.choose_toolboxes(task, **box_choose_kwargs)
+        # Choose the tools
+        chosen_tools = []
+        for toolbox in chosen_toolboxes:
+            chosen_tools.extend(await self.choose_tools(task, toolbox, **tool_choose_kwargs))
+        return chosen_tools
+
+    def supply_tools_from[S: "ToolBoxUsage"](self, others: Union[S, Iterable[S]]) -> Self:
         """Supplies tools from other ToolUsage instances to this instance.
 
         Args:
-            others ("ToolUsage" | Iterable["ToolUsage"]): A single ToolUsage instance or an iterable of ToolUsage instances
+            others (ToolBoxUsage | Iterable[ToolBoxUsage]): A single ToolUsage instance or an iterable of ToolUsage instances
                 from which to take tools.
 
         Returns:
@@ -459,11 +447,11 @@ class ToolBoxUsage(LLMUsage):
             self.toolboxes.update(other.toolboxes)
         return self
 
-    def provide_tools_to(self, others: Union["ToolBoxUsage", Iterable["ToolBoxUsage"]]) -> Self:
+    def provide_tools_to[S: "ToolBoxUsage"](self, others: Union[S, Iterable[S]]) -> Self:
         """Provides tools from this instance to other ToolUsage instances.
 
         Args:
-            others ("ToolUsage" | Iterable["ToolUsage"]): A single ToolUsage instance or an iterable of ToolUsage instances
+            others (ToolBoxUsage | Iterable[ToolBoxUsage]): A single ToolUsage instance or an iterable of ToolUsage instances
                 to which to provide tools.
 
         Returns:

{fabricatio-0.2.0.dev15 → fabricatio-0.2.0.dev17}/python/fabricatio/toolboxes/fs.py

@@ -1,3 +1,5 @@
+"""File system tool box."""
+
 from fabricatio.fs.curd import copy_file, create_directory, delete_directory, delete_file, move_file, tree
 from fabricatio.models.tool import ToolBox
 

{fabricatio-0.2.0.dev15 → fabricatio-0.2.0.dev17}/python/fabricatio/toolboxes/task.py

@@ -1,3 +1,5 @@
+"""This module contains the toolbox for tasks management."""
+
 from fabricatio.models.task import Task
 from fabricatio.models.tool import ToolBox
 

{fabricatio-0.2.0.dev15 → fabricatio-0.2.0.dev17}/uv.lock

@@ -179,7 +179,7 @@ wheels = [
 [[package]]
 name = "code2prompt"
 version = "2.0.0"
-source = { git = "https://github.com/mufeedvh/code2prompt#28bf1dc0f9b847a890045a2b0bb95a84aa54520b" }
+source = { git = "https://github.com/mufeedvh/code2prompt?rev=d157ee84827458bd6816142e213886487d28bd3d#d157ee84827458bd6816142e213886487d28bd3d" }
 
 [[package]]
 name = "colorama"
@@ -260,7 +260,7 @@ wheels = [
 
 [[package]]
 name = "fabricatio"
-version = "0.2.0.dev15"
+version = "0.2.0.dev17"
 source = { editable = "." }
 dependencies = [
     { name = "appdirs" },
@@ -279,6 +279,16 @@ dependencies = [
     { name = "rich" },
 ]
 
+[package.optional-dependencies]
+full = [
+    { name = "faiss-cpu" },
+    { name = "pymilvus" },
+]
+rag = [
+    { name = "faiss-cpu" },
+    { name = "pymilvus" },
+]
+
 [package.dev-dependencies]
 dev = [
     { name = "maturin" },
@@ -295,19 +305,14 @@ dev = [
     { name = "uv" },
     { name = "viztracer" },
 ]
-full = [
-    { name = "fabricatio" },
-]
-rag = [
-    { name = "faiss-cpu" },
-    { name = "pymilvus" },
-]
 
 [package.metadata]
 requires-dist = [
     { name = "appdirs", specifier = ">=1.4.4" },
     { name = "asyncio", specifier = ">=3.4.3" },
-    { name = "code2prompt", git = "https://github.com/mufeedvh/code2prompt" },
+    { name = "code2prompt", git = "https://github.com/mufeedvh/code2prompt?rev=d157ee84827458bd6816142e213886487d28bd3d" },
+    { name = "fabricatio", extras = ["rag"], marker = "extra == 'full'" },
+    { name = "faiss-cpu", marker = "extra == 'rag'", specifier = ">=1.10.0" },
     { name = "gitpython", specifier = ">=3.1.44" },
     { name = "litellm", specifier = ">=1.60.0" },
     { name = "loguru", specifier = ">=0.7.3" },
@@ -315,11 +320,13 @@ requires-dist = [
     { name = "orjson", specifier = ">=3.10.15" },
     { name = "pydantic", specifier = ">=2.10.6" },
     { name = "pydantic-settings", specifier = ">=2.7.1" },
+    { name = "pymilvus", marker = "extra == 'rag'", specifier = ">=2.5.4" },
     { name = "pymitter", specifier = ">=1.0.0" },
     { name = "questionary", specifier = ">=2.1.0" },
     { name = "regex", specifier = ">=2024.11.6" },
     { name = "rich", specifier = ">=13.9.4" },
 ]
+provides-extras = ["rag", "full"]
 
 [package.metadata.requires-dev]
 dev = [
@@ -337,11 +344,6 @@ dev = [
     { name = "uv", specifier = ">=0.5.29" },
     { name = "viztracer", specifier = ">=1.0.2" },
 ]
-full = [{ name = "fabricatio", extras = ["rag"] }]
-rag = [
-    { name = "faiss-cpu", specifier = ">=1.10.0" },
-    { name = "pymilvus", specifier = ">=2.5.4" },
-]
 
 [[package]]
 name = "faiss-cpu"