fabricatio 0.2.2__cp312-cp312-win_amd64.whl → 0.2.3__cp312-cp312-win_amd64.whl

fabricatio/__init__.py

@@ -1,5 +1,7 @@
 """Fabricatio is a Python library for building llm app using event-based agent structure."""
 
+from importlib.util import find_spec
+
 from fabricatio._rust_instances import template_manager
 from fabricatio.core import env
 from fabricatio.fs import magika
@@ -35,3 +37,9 @@ __all__ = [
     "task_toolbox",
     "template_manager",
 ]
+
+
+if find_spec("pymilvus"):
+    from fabricatio.capabilities.rag import RAG
+
+    __all__ += ["RAG"]

fabricatio/capabilities/rag.py

@@ -0,0 +1,310 @@
+"""A module for the RAG (Retrieval Augmented Generation) model."""
+
+try:
+    from pymilvus import MilvusClient
+except ImportError as e:
+    raise RuntimeError("pymilvus is not installed. Have you installed `fabricatio[rag]` instead of `fabricatio`") from e
+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 fabricatio._rust_instances import template_manager
+from fabricatio.config import configs
+from fabricatio.journal import logger
+from fabricatio.models.kwargs_types import CollectionSimpleConfigKwargs, EmbeddingKwargs, FetchKwargs, LLMKwargs
+from fabricatio.models.usages import EmbeddingUsage
+from fabricatio.models.utils import MilvusData
+from more_itertools.recipes import flatten
+from pydantic import Field, PrivateAttr
+
+
+@lru_cache(maxsize=None)
+def create_client(uri: str, token: str = "", timeout: Optional[float] = None) -> MilvusClient:
+    """Create a Milvus client."""
+    return MilvusClient(
+        uri=uri,
+        token=token,
+        timeout=timeout,
+    )
+
+
+class RAG(EmbeddingUsage):
+    """A class representing the RAG (Retrieval Augmented Generation) model."""
+
+    target_collection: Optional[str] = Field(default=None)
+    """The name of the collection being viewed."""
+
+    _client: Optional[MilvusClient] = PrivateAttr(None)
+    """The Milvus client used for the RAG model."""
+
+    @property
+    def client(self) -> MilvusClient:
+        """Return the Milvus client."""
+        if self._client is None:
+            raise RuntimeError("Client is not initialized. Have you called `self.init_client()`?")
+        return self._client
+
+    def init_client(
+        self,
+        milvus_uri: Optional[str] = None,
+        milvus_token: Optional[str] = None,
+        milvus_timeout: Optional[float] = None,
+    ) -> Self:
+        """Initialize the Milvus client."""
+        self._client = create_client(
+            uri=milvus_uri or (self.milvus_uri or configs.rag.milvus_uri).unicode_string(),
+            token=milvus_token
+            or (token.get_secret_value() if (token := (self.milvus_token or configs.rag.milvus_token)) else ""),
+            timeout=milvus_timeout or self.milvus_timeout,
+        )
+        return self
+
+    @overload
+    async def pack(
+        self, input_text: List[str], subject: Optional[str] = None, **kwargs: Unpack[EmbeddingKwargs]
+    ) -> List[MilvusData]: ...
+    @overload
+    async def pack(
+        self, input_text: str, subject: Optional[str] = None, **kwargs: Unpack[EmbeddingKwargs]
+    ) -> MilvusData: ...
+
+    async def pack(
+        self, input_text: List[str] | str, subject: Optional[str] = None, **kwargs: Unpack[EmbeddingKwargs]
+    ) -> List[MilvusData] | MilvusData:
+        """Asynchronously generates MilvusData objects for the given input text.
+
+        Args:
+            input_text (List[str] | str): A string or list of strings to generate embeddings for.
+            subject (Optional[str]): The subject of the input text. Defaults to None.
+            **kwargs (Unpack[EmbeddingKwargs]): Additional keyword arguments for embedding.
+
+        Returns:
+            List[MilvusData] | MilvusData: The generated MilvusData objects.
+        """
+        if isinstance(input_text, str):
+            return MilvusData(vector=await self.vectorize(input_text, **kwargs), text=input_text, subject=subject)
+        vecs = await self.vectorize(input_text, **kwargs)
+        return [
+            MilvusData(
+                vector=vec,
+                text=text,
+                subject=subject,
+            )
+            for text, vec in zip(input_text, vecs, strict=True)
+        ]
+
+    def view(
+        self, collection_name: Optional[str], create: bool = False, **kwargs: Unpack[CollectionSimpleConfigKwargs]
+    ) -> Self:
+        """View the specified collection.
+
+        Args:
+            collection_name (str): The name of the collection.
+            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):
+            kwargs["dimension"] = kwargs.get("dimension") or self.milvus_dimensions or configs.rag.milvus_dimensions
+            self._client.create_collection(collection_name, auto_id=True, **kwargs)
+            logger.info(f"Creating collection {collection_name}")
+
+        self.target_collection = collection_name
+        return self
+
+    def quit_viewing(self) -> Self:
+        """Quit the current view.
+
+        Returns:
+            Self: The current instance, allowing for method chaining.
+        """
+        return self.view(None)
+
+    @property
+    def safe_target_collection(self) -> str:
+        """Get the name of the collection being viewed, raise an error if not viewing any collection.
+
+        Returns:
+            str: The name of the collection being viewed.
+        """
+        if self.target_collection is None:
+            raise RuntimeError("No collection is being viewed. Have you called `self.view()`?")
+        return self.target_collection
+
+    def add_document[D: Union[Dict[str, Any], MilvusData]](
+        self, data: D | List[D], collection_name: Optional[str] = None, flush: bool = False
+    ) -> Self:
+        """Adds a document to the specified collection.
+
+        Args:
+            data (Union[Dict[str, Any], MilvusData] | List[Union[Dict[str, Any], MilvusData]]): The data to be added to the collection.
+            collection_name (Optional[str]): The name of the collection. If not provided, the currently viewed collection is used.
+            flush (bool): Whether to flush the collection after insertion.
+
+        Returns:
+            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]
+        c_name = collection_name or self.safe_target_collection
+        self._client.insert(c_name, data)
+
+        if flush:
+            logger.debug(f"Flushing collection {c_name}")
+            self._client.flush(c_name)
+        return self
+
+    async def consume_file(
+        self,
+        source: List[PathLike] | PathLike,
+        reader: Callable[[PathLike], str] = lambda path: Path(path).read_text(encoding="utf-8"),
+        collection_name: Optional[str] = None,
+    ) -> Self:
+        """Consume a file and add its content to the collection.
+
+        Args:
+            source (PathLike): The path to the file to be consumed.
+            reader (Callable[[PathLike], MilvusData]): The reader function to read the file.
+            collection_name (Optional[str]): The name of the collection. If not provided, the currently viewed collection is used.
+
+        Returns:
+            Self: The current instance, allowing for method chaining.
+        """
+        if not isinstance(source, list):
+            source = [source]
+        return await self.consume_string([reader(s) for s in source], collection_name)
+
+    async def consume_string(self, text: List[str] | str, collection_name: Optional[str] = None) -> Self:
+        """Consume a string and add it to the collection.
+
+        Args:
+            text (List[str] | str): The text to be added to the collection.
+            collection_name (Optional[str]): The name of the collection. If not provided, the currently viewed collection is used.
+
+        Returns:
+            Self: The current instance, allowing for method chaining.
+        """
+        self.add_document(await self.pack(text), collection_name or self.safe_target_collection, flush=True)
+        return self
+
+    async def afetch_document(
+        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]:
+        """Fetch data from the collection.
+
+        Args:
+            vecs (List[List[float]]): The vectors to search for.
+            desired_fields (List[str] | str): The fields to retrieve.
+            collection_name (Optional[str]): The name of the collection. If not provided, the currently viewed collection is used.
+            similarity_threshold (float): The threshold for similarity, only results above this threshold will be returned.
+            result_per_query (int): The number of results to return per query.
+
+        Returns:
+            List[Dict[str, Any]] | List[Any]: The retrieved data.
+        """
+        # Step 1: Search for vectors
+        search_results = self._client.search(
+            collection_name or self.safe_target_collection,
+            vecs,
+            search_params={"radius": similarity_threshold},
+            output_fields=desired_fields if isinstance(desired_fields, list) else [desired_fields],
+            limit=result_per_query,
+        )
+
+        # Step 2: Flatten the search results
+        flattened_results = flatten(search_results)
+
+        # Step 3: Sort by distance (descending)
+        sorted_results = sorted(flattened_results, key=itemgetter("distance"), reverse=True)
+
+        logger.debug(f"Searched similarities: {[t['distance'] for t in sorted_results]}")
+        # Step 4: Extract the entities
+        resp = [result["entity"] for result in sorted_results]
+
+        if isinstance(desired_fields, list):
+            return resp
+        return [r.get(desired_fields) for r in resp]
+
+    async def aretrieve(
+        self,
+        query: List[str] | str,
+        collection_name: Optional[str] = None,
+        final_limit: int = 20,
+        **kwargs: Unpack[FetchKwargs],
+    ) -> List[str]:
+        """Retrieve data from the collection.
+
+        Args:
+            query (List[str] | str): The query to be used for retrieval.
+            collection_name (Optional[str]): The name of the collection. If not provided, the currently viewed collection is used.
+            final_limit (int): The final limit on the number of results to return.
+            **kwargs (Unpack[FetchKwargs]): Additional keyword arguments for retrieval.
+
+        Returns:
+            List[str]: A list of strings containing the retrieved data.
+        """
+        if isinstance(query, str):
+            query = [query]
+        return (
+            await self.afetch_document(
+                vecs=(await self.vectorize(query)),
+                desired_fields="text",
+                collection_name=collection_name,
+                **kwargs,
+            )
+        )[:final_limit]
+
+    async def aask_retrieved(
+        self,
+        question: str | List[str],
+        query: List[str] | str,
+        collection_name: Optional[str] = None,
+        extra_system_message: str = "",
+        result_per_query: int = 10,
+        final_limit: int = 20,
+        similarity_threshold: float = 0.37,
+        **kwargs: Unpack[LLMKwargs],
+    ) -> str:
+        """Asks a question by retrieving relevant documents based on the provided query.
+
+        This method performs document retrieval using the given query, then asks the
+        specified question using the retrieved documents as context.
+
+        Args:
+            question (str | List[str]): The question or list of questions to be asked.
+            query (List[str] | str): The query or list of queries used for document retrieval.
+            collection_name (Optional[str]): The name of the collection to retrieve documents from.
+                                              If not provided, the currently viewed collection is used.
+            extra_system_message (str): An additional system message to be included in the prompt.
+            result_per_query (int): The number of results to return per query. Default is 10.
+            final_limit (int): The maximum number of retrieved documents to consider. Default is 20.
+            similarity_threshold (float): The threshold for similarity, only results above this threshold will be returned.
+            **kwargs (Unpack[LLMKwargs]): Additional keyword arguments passed to the underlying `aask` method.
+
+        Returns:
+            str: A string response generated after asking with the context of retrieved documents.
+        """
+        docs = await self.aretrieve(
+            query,
+            collection_name,
+            final_limit,
+            result_per_query=result_per_query,
+            similarity_threshold=similarity_threshold,
+        )
+
+        rendered = template_manager.render_template(configs.templates.retrieved_display_template, {"docs": docs[::-1]})
+
+        logger.debug(f"Retrieved Documents: \n{rendered}")
+        return await self.aask(
+            question,
+            f"{rendered}\n\n{extra_system_message}",
+            **kwargs,
+        )

fabricatio/config.py

@@ -11,6 +11,7 @@ from pydantic import (
     FilePath,
     HttpUrl,
     NonNegativeFloat,
+    PositiveFloat,
     PositiveInt,
     SecretStr,
 )
@@ -79,6 +80,30 @@ class LLMConfig(BaseModel):
     """The maximum number of tokens to generate. Set to 8192 as per request."""
 
 
+class EmbeddingConfig(BaseModel):
+    """Embedding configuration class."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+
+    model: str = Field(default="text-embedding-ada-002")
+    """The embedding model name. """
+
+    dimensions: Optional[PositiveInt] = Field(default=None)
+    """The dimensions of the embedding. Default is None."""
+
+    timeout: Optional[PositiveInt] = Field(default=None)
+    """The timeout of the embedding model in seconds. Default is 300 seconds as per request."""
+
+    caching: bool = Field(default=False)
+    """Whether to cache the embedding. Default is True."""
+
+    api_endpoint: Optional[HttpUrl] = None
+    """The OpenAI API endpoint."""
+
+    api_key: Optional[SecretStr] = None
+    """The OpenAI API key."""
+
+
 class PymitterConfig(BaseModel):
     """Pymitter configuration class.
 
@@ -175,6 +200,9 @@ class TemplateConfig(BaseModel):
     draft_rating_weights_klee_template: str = Field(default="draft_rating_weights_klee")
     """The name of the draft rating weights klee template which will be used to draft rating weights with Klee method."""
 
+    retrieved_display_template: str = Field(default="retrieved_display")
+    """The name of the retrieved display template which will be used to display retrieved documents."""
+
 
 class MagikaConfig(BaseModel):
     """Magika configuration class."""
@@ -207,6 +235,21 @@ class ToolBoxConfig(BaseModel):
     """The name of the module containing the data."""
 
 
+class RagConfig(BaseModel):
+    """RAG configuration class."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+
+    milvus_uri: HttpUrl = Field(default=HttpUrl("http://localhost:19530"))
+    """The URI of the Milvus server."""
+    milvus_timeout: Optional[PositiveFloat] = Field(default=None)
+    """The timeout of the Milvus server."""
+    milvus_token: Optional[SecretStr] = Field(default=None)
+    """The token of the Milvus server."""
+    milvus_dimensions: Optional[PositiveInt] = Field(default=None)
+    """The dimensions of the Milvus server."""
+
+
 class Settings(BaseSettings):
     """Application settings class.
 
@@ -232,6 +275,9 @@ class Settings(BaseSettings):
     llm: LLMConfig = Field(default_factory=LLMConfig)
     """LLM Configuration"""
 
+    embedding: EmbeddingConfig = Field(default_factory=EmbeddingConfig)
+    """Embedding Configuration"""
+
     debug: DebugConfig = Field(default_factory=DebugConfig)
     """Debug Configuration"""
 
@@ -250,6 +296,9 @@ class Settings(BaseSettings):
     toolbox: ToolBoxConfig = Field(default_factory=ToolBoxConfig)
     """Toolbox Configuration"""
 
+    rag: RagConfig = Field(default_factory=RagConfig)
+    """RAG Configuration"""
+
     @classmethod
     def settings_customise_sources(
         cls,

fabricatio/core.py

@@ -38,11 +38,11 @@ class Env(BaseModel):
 
     @overload
     def on[**P, R](
-            self,
-            event: str | Event,
-            func: Optional[Callable[P, R]] = None,
-            /,
-            ttl: int = -1,
+        self,
+        event: str | Event,
+        func: Optional[Callable[P, R]] = None,
+        /,
+        ttl: int = -1,
     ) -> Callable[[Callable[P, R]], Callable[P, R]]:
         """
         Registers an event listener with a specific function that listens indefinitely or for a specified number of times.
@@ -58,11 +58,11 @@ class Env(BaseModel):
         ...
 
     def on[**P, R](
-            self,
-            event: str | Event,
-            func: Optional[Callable[P, R]] = None,
-            /,
-            ttl=-1,
+        self,
+        event: str | Event,
+        func: Optional[Callable[P, R]] = None,
+        /,
+        ttl=-1,
     ) -> Callable[[Callable[P, R]], Callable[P, R]] | Self:
         """Registers an event listener with a specific function that listens indefinitely or for a specified number of times.
 
@@ -78,14 +78,13 @@ class Env(BaseModel):
             event = event.collapse()
         if func is None:
             return self._ee.on(event, ttl=ttl)
-
         self._ee.on(event, func, ttl=ttl)
         return self
 
     @overload
     def once[**P, R](
-            self,
-            event: str | Event,
+        self,
+        event: str | Event,
     ) -> Callable[[Callable[P, R]], Callable[P, R]]:
         """
         Registers an event listener that listens only once.
@@ -100,9 +99,9 @@ class Env(BaseModel):
 
     @overload
     def once[**P, R](
-            self,
-            event: str | Event,
-            func: Callable[[Callable[P, R]], Callable[P, R]],
+        self,
+        event: str | Event,
+        func: Callable[[Callable[P, R]], Callable[P, R]],
     ) -> Self:
         """
         Registers an event listener with a specific function that listens only once.
@@ -117,9 +116,9 @@ class Env(BaseModel):
         ...
 
     def once[**P, R](
-            self,
-            event: str | Event,
-            func: Optional[Callable[P, R]] = None,
+        self,
+        event: str | Event,
+        func: Optional[Callable[P, R]] = None,
     ) -> Callable[[Callable[P, R]], Callable[P, R]] | Self:
         """Registers an event listener with a specific function that listens only once.
 
@@ -163,5 +162,20 @@ class Env(BaseModel):
             event = event.collapse()
         return await self._ee.emit_async(event, *args, **kwargs)
 
+    def emit_future[**P](self, event: str | Event, *args: P.args, **kwargs: P.kwargs) -> None:
+        """Emits an event to all registered listeners and returns a future object.
+
+        Args:
+            event (str | Event): The event to emit.
+            *args: Positional arguments to pass to the listeners.
+            **kwargs: Keyword arguments to pass to the listeners.
+
+        Returns:
+            None: The future object.
+        """
+        if isinstance(event, Event):
+            event = event.collapse()
+        return self._ee.emit_future(event, *args, **kwargs)
+
 
 env = Env()

fabricatio/models/action.py

@@ -2,7 +2,7 @@
 
 import traceback
 from abc import abstractmethod
-from asyncio import Queue
+from asyncio import Queue, create_task
 from typing import Any, Dict, Self, Tuple, Type, Union, Unpack
 
 from fabricatio.capabilities.rating import GiveRating
@@ -108,7 +108,11 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
         try:
             for step in self._instances:
                 logger.debug(f"Executing step: {step.name}")
-                modified_ctx = await step.act(await self._context.get())
+                act_task = create_task(step.act(await self._context.get()))
+                if task.is_cancelled():
+                    act_task.cancel(f"Cancelled by task: {task.name}")
+                    break
+                modified_ctx = await act_task
                 await self._context.put(modified_ctx)
                 current_action = step.name
             logger.info(f"Finished executing workflow: {self.name}")

fabricatio/models/generic.py

@@ -1,7 +1,7 @@
 """This module defines generic classes for models in the Fabricatio library."""
 
 from pathlib import Path
-from typing import Callable, List, Self
+from typing import Callable, Iterable, List, Optional, Self, Union, final
 
 import orjson
 from fabricatio._rust import blake3_hash
@@ -12,6 +12,11 @@ from pydantic import (
     BaseModel,
     ConfigDict,
     Field,
+    HttpUrl,
+    NonNegativeFloat,
+    PositiveFloat,
+    PositiveInt,
+    SecretStr,
 )
 
 
@@ -150,3 +155,104 @@ class WithDependency(Base):
                 for p in self.dependencies
             },
         )
+
+
+class ScopedConfig(Base):
+    """Class that manages a scoped configuration."""
+
+    llm_api_endpoint: Optional[HttpUrl] = None
+    """The OpenAI API endpoint."""
+
+    llm_api_key: Optional[SecretStr] = None
+    """The OpenAI API key."""
+
+    llm_timeout: Optional[PositiveInt] = None
+    """The timeout of the LLM model."""
+
+    llm_max_retries: Optional[PositiveInt] = None
+    """The maximum number of retries."""
+
+    llm_model: Optional[str] = None
+    """The LLM model name."""
+
+    llm_temperature: Optional[NonNegativeFloat] = None
+    """The temperature of the LLM model."""
+
+    llm_stop_sign: Optional[str | List[str]] = None
+    """The stop sign of the LLM model."""
+
+    llm_top_p: Optional[NonNegativeFloat] = None
+    """The top p of the LLM model."""
+
+    llm_generation_count: Optional[PositiveInt] = None
+    """The number of generations to generate."""
+
+    llm_stream: Optional[bool] = None
+    """Whether to stream the LLM model's response."""
+
+    llm_max_tokens: Optional[PositiveInt] = None
+    """The maximum number of tokens to generate."""
+
+    embedding_api_endpoint: Optional[HttpUrl] = None
+    """The OpenAI API endpoint."""
+
+    embedding_api_key: Optional[SecretStr] = None
+    """The OpenAI API key."""
+
+    embedding_timeout: Optional[PositiveInt] = None
+    """The timeout of the LLM model."""
+
+    embedding_model: Optional[str] = None
+    """The LLM model name."""
+
+    embedding_dimensions: Optional[PositiveInt] = None
+    """The dimensions of the embedding."""
+    embedding_caching: Optional[bool] = False
+    """Whether to cache the embedding result."""
+
+    milvus_uri: Optional[HttpUrl] = Field(default=None)
+    """The URI of the Milvus server."""
+    milvus_token: Optional[SecretStr] = Field(default=None)
+    """The token for the Milvus server."""
+    milvus_timeout: Optional[PositiveFloat] = Field(default=None)
+    """The timeout for the Milvus server."""
+    milvus_dimensions: Optional[PositiveInt] = Field(default=None)
+    """The dimensions of the Milvus server."""
+
+    @final
+    def fallback_to(self, other: "ScopedConfig") -> Self:
+        """Fallback to another instance's attribute values if the current instance's attributes are None.
+
+        Args:
+            other (LLMUsage): Another instance from which to copy attribute values.
+
+        Returns:
+            Self: The current instance, allowing for method chaining.
+        """
+        # Iterate over the attribute names and copy values from 'other' to 'self' where applicable
+        # noinspection PydanticTypeChecker,PyTypeChecker
+        for attr_name in ScopedConfig.model_fields:
+            # Copy the attribute value from 'other' to 'self' only if 'self' has None and 'other' has a non-None value
+            if getattr(self, attr_name) is None and (attr := getattr(other, attr_name)) is not None:
+                setattr(self, attr_name, attr)
+
+        # Return the current instance to allow for method chaining
+        return self
+
+    @final
+    def hold_to(self, others: Union["ScopedConfig", Iterable["ScopedConfig"]]) -> Self:
+        """Hold to another instance's attribute values if the current instance's attributes are None.
+
+        Args:
+            others (LLMUsage | Iterable[LLMUsage]): Another instance or iterable of instances from which to copy attribute values.
+
+        Returns:
+            Self: The current instance, allowing for method chaining.
+        """
+        if not isinstance(others, Iterable):
+            others = [others]
+        for other in others:
+            # noinspection PyTypeChecker,PydanticTypeChecker
+            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)

fabricatio/models/kwargs_types.py

@@ -5,6 +5,29 @@ from typing import List, NotRequired, TypedDict
 from pydantic import NonNegativeFloat, NonNegativeInt, PositiveInt
 
 
+class CollectionSimpleConfigKwargs(TypedDict):
+    """A type representing the configuration for a collection."""
+
+    dimension: NotRequired[int]
+    timeout: NotRequired[float]
+
+
+class FetchKwargs(TypedDict):
+    """A type representing the keyword arguments for the fetch method."""
+
+    similarity_threshold: NotRequired[float]
+    result_per_query: NotRequired[int]
+
+
+class EmbeddingKwargs(TypedDict):
+    """A type representing the keyword arguments for the embedding method."""
+
+    model: NotRequired[str]
+    dimensions: NotRequired[int]
+    timeout: NotRequired[PositiveInt]
+    caching: NotRequired[bool]
+
+
 class LLMKwargs(TypedDict):
     """A type representing the keyword arguments for the LLM (Large Language Model) usage."""
 

fabricatio/models/task.py

@@ -46,21 +46,21 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
     """
 
     name: str = Field(...)
-    """The name of the task, which should be a concise and descriptive name."""
+    """The name of the task, which should be concise and descriptive."""
 
     description: str = Field(default="")
-    """The description of the task, which should provide every details and noting about the task if provided, obeying the CEFR level rule and 5W1H rule."""
+    """A detailed explanation of the task that includes all necessary information. Should be clear and answer what, why, when, where, who, and how questions."""
 
-    goal: List[str] = Field(default=[])
-    """The goal of the task, a list of strings. The goal should be a concise and clear statement of what the task is intended to achieve, goal SHALL NOT be too broad or too narrow."""
+    goals: List[str] = Field(default=[])
+    """A list of objectives that the task aims to accomplish. Each goal should be clear and specific. Complex tasks should be broken into multiple smaller goals."""
 
     namespace: List[str] = Field(default_factory=list)
-    """The namespace of the task, a list of namespace segment, as string, if it is not directly given out, it SHALL just be a empty list meaning `NOT ASSIGNED`"""
+    """A list of string segments that identify the task's location in the system. If not specified, defaults to an empty list."""
 
     dependencies: List[str] = Field(default_factory=list)
-    """A list of file paths, These file are needed to read or write to meet a specific requirement of this task, if it is not directly given out, it SHALL just be a empty list meaning `NOT ASSIGNED`"""
+    """A list of file paths that are needed (either reading or writing) to complete this task. If not specified, defaults to an empty list."""
 
-    _output: Queue = PrivateAttr(default_factory=lambda: Queue(maxsize=1))
+    _output: Queue[T | None] = PrivateAttr(default_factory=Queue)
     """The output queue of the task."""
 
     _status: TaskStatus = PrivateAttr(default=TaskStatus.Pending)
@@ -113,7 +113,7 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
         Returns:
             Task: A new instance of the `Task` class.
         """
-        return cls(name=name, goal=goal, description=description)
+        return cls(name=name, goals=goal, description=description)
 
     def update_task(self, goal: Optional[List[str] | str] = None, description: Optional[str] = None) -> Self:
         """Update the goal and description of the task.
@@ -126,12 +126,12 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
             Task: The updated instance of the `Task` class.
         """
         if goal:
-            self.goal = goal if isinstance(goal, list) else [goal]
+            self.goals = goal if isinstance(goal, list) else [goal]
         if description:
             self.description = description
         return self
 
-    async def get_output(self) -> T:
+    async def get_output(self) -> T | None:
         """Get the output of the task.
 
         Returns:
@@ -232,6 +232,7 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
         """
         logger.info(f"Cancelling task `{self.name}`")
         self._status = TaskStatus.Cancelled
+        await self._output.put(None)
         await env.emit_async(self.cancelled_label, self)
         return self
 
@@ -243,27 +244,38 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
         """
         logger.info(f"Failing task `{self.name}`")
         self._status = TaskStatus.Failed
+        await self._output.put(None)
         await env.emit_async(self.failed_label, self)
         return self
 
-    async def publish(self) -> Self:
+    def publish(self, new_namespace: Optional[EventLike] = None) -> Self:
         """Publish the task to the event bus.
 
+        Args:
+            new_namespace(EventLike, optional): The new namespace to move the task to.
+
         Returns:
-            Task: The published instance of the `Task` class
+            Task: The published instance of the `Task` class.
         """
+        if new_namespace:
+            self.move_to(new_namespace)
         logger.info(f"Publishing task `{(label := self.pending_label)}`")
-        await env.emit_async(label, self)
+        env.emit_future(label, self)
         return self
 
-    async def delegate(self) -> T:
-        """Delegate the task to the event bus and wait for the output.
+    async def delegate(self, new_namespace: Optional[EventLike] = None) -> T | None:
+        """Delegate the task to the event.
+
+        Args:
+            new_namespace(EventLike, optional): The new namespace to move the task to.
 
         Returns:
-            T: The output of the task
+            T|None: The output of the task.
         """
+        if new_namespace:
+            self.move_to(new_namespace)
         logger.info(f"Delegating task `{(label := self.pending_label)}`")
-        await env.emit_async(label, self)
+        env.emit_future(label, self)
         return await self.get_output()
 
     @property
@@ -277,3 +289,43 @@ class Task[T](WithBriefing, WithJsonExample, WithDependency):
             configs.templates.task_briefing_template,
             self.model_dump(),
         )
+
+    def is_running(self) -> bool:
+        """Check if the task is running.
+
+        Returns:
+            bool: True if the task is running, False otherwise.
+        """
+        return self._status == TaskStatus.Running
+
+    def is_finished(self) -> bool:
+        """Check if the task is finished.
+
+        Returns:
+            bool: True if the task is finished, False otherwise.
+        """
+        return self._status == TaskStatus.Finished
+
+    def is_failed(self) -> bool:
+        """Check if the task is failed.
+
+        Returns:
+            bool: True if the task is failed, False otherwise.
+        """
+        return self._status == TaskStatus.Failed
+
+    def is_cancelled(self) -> bool:
+        """Check if the task is cancelled.
+
+        Returns:
+            bool: True if the task is cancelled, False otherwise.
+        """
+        return self._status == TaskStatus.Cancelled
+
+    def is_pending(self) -> bool:
+        """Check if the task is pending.
+
+        Returns:
+            bool: True if the task is pending, False otherwise.
+        """
+        return self._status == TaskStatus.Pending

fabricatio/models/usages.py

@@ -1,7 +1,7 @@
 """This module contains classes that manage the usage of language models and tools in tasks."""
 
 from asyncio import gather
-from typing import Callable, Dict, Iterable, List, Optional, Self, Set, Union, Unpack, overload
+from typing import Callable, Dict, Iterable, List, Optional, Self, Set, Type, Union, Unpack, overload
 
 import asyncstdlib
 import litellm
@@ -9,8 +9,8 @@ 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.kwargs_types import ChooseKwargs, GenerateKwargs, LLMKwargs
+from fabricatio.models.generic import ScopedConfig, WithBriefing
+from fabricatio.models.kwargs_types import ChooseKwargs, EmbeddingKwargs, GenerateKwargs, LLMKwargs
 from fabricatio.models.task import Task
 from fabricatio.models.tool import Tool, ToolBox
 from fabricatio.models.utils import Messages
@@ -18,48 +18,20 @@ from fabricatio.parser import JsonCapture
 from litellm import stream_chunk_builder
 from litellm.types.utils import (
     Choices,
+    EmbeddingResponse,
     ModelResponse,
     StreamingChoices,
 )
 from litellm.utils import CustomStreamWrapper
-from pydantic import Field, HttpUrl, NonNegativeFloat, NonNegativeInt, PositiveInt, SecretStr
+from pydantic import Field, NonNegativeInt, PositiveInt
 
 
-class LLMUsage(Base):
+class LLMUsage(ScopedConfig):
     """Class that manages LLM (Large Language Model) usage parameters and methods."""
 
-    llm_api_endpoint: Optional[HttpUrl] = None
-    """The OpenAI API endpoint."""
-
-    llm_api_key: Optional[SecretStr] = None
-    """The OpenAI API key."""
-
-    llm_timeout: Optional[PositiveInt] = None
-    """The timeout of the LLM model."""
-
-    llm_max_retries: Optional[PositiveInt] = None
-    """The maximum number of retries."""
-
-    llm_model: Optional[str] = None
-    """The LLM model name."""
-
-    llm_temperature: Optional[NonNegativeFloat] = None
-    """The temperature of the LLM model."""
-
-    llm_stop_sign: Optional[str | List[str]] = None
-    """The stop sign of the LLM model."""
-
-    llm_top_p: Optional[NonNegativeFloat] = None
-    """The top p of the LLM model."""
-
-    llm_generation_count: Optional[PositiveInt] = None
-    """The number of generations to generate."""
-
-    llm_stream: Optional[bool] = None
-    """Whether to stream the LLM model's response."""
-
-    llm_max_tokens: Optional[PositiveInt] = None
-    """The maximum number of tokens to generate."""
+    @classmethod
+    def _scoped_model(cls) -> Type["LLMUsage"]:
+        return LLMUsage
 
     async def aquery(
         self,
@@ -89,10 +61,8 @@ class LLMUsage(Base):
             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
-            else configs.llm.api_endpoint.unicode_string(),
+            api_key=(self.llm_api_key or configs.llm.api_key).get_secret_value(),
+            base_url=(self.llm_api_endpoint or configs.llm.api_endpoint).unicode_string(),
         )
 
     async def ainvoke(
@@ -121,13 +91,13 @@ class LLMUsage(Base):
         if isinstance(resp, ModelResponse):
             return resp.choices
         if isinstance(resp, CustomStreamWrapper):
-            if configs.debug.streaming_visible:
-                chunks = []
-                async for chunk in resp:
-                    chunks.append(chunk)
-                    print(chunk.choices[0].delta.content or "", end="")  # noqa: T201
-                return stream_chunk_builder(chunks).choices
-            return stream_chunk_builder(await asyncstdlib.list()).choices
+            if not configs.debug.streaming_visible:
+                return stream_chunk_builder(await asyncstdlib.list()).choices
+            chunks = []
+            async for chunk in resp:
+                chunks.append(chunk)
+                print(chunk.choices[0].delta.content or "", end="")  # noqa: T201
+            return stream_chunk_builder(chunks).choices
         logger.critical(err := f"Unexpected response type: {type(resp)}")
         raise ValueError(err)
 
@@ -383,39 +353,76 @@ class LLMUsage(Base):
             **kwargs,
         )
 
-    def fallback_to(self, other: "LLMUsage") -> Self:
-        """Fallback to another instance's attribute values if the current instance's attributes are None.
+
+class EmbeddingUsage(LLMUsage):
+    """A class representing the embedding model."""
+
+    async def aembedding(
+        self,
+        input_text: List[str],
+        model: Optional[str] = None,
+        dimensions: Optional[int] = None,
+        timeout: Optional[PositiveInt] = None,
+        caching: Optional[bool] = False,
+    ) -> EmbeddingResponse:
+        """Asynchronously generates embeddings for the given input text.
 
         Args:
-            other (LLMUsage): Another instance from which to copy attribute values.
+            input_text (List[str]): A list of strings to generate embeddings for.
+            model (Optional[str]): The model to use for embedding. Defaults to the instance's `llm_model` or the global configuration.
+            dimensions (Optional[int]): The dimensions of the embedding output should have, which is used to validate the result. Defaults to None.
+            timeout (Optional[PositiveInt]): The timeout for the embedding request. Defaults to the instance's `llm_timeout` or the global configuration.
+            caching (Optional[bool]): Whether to cache the embedding result. Defaults to False.
+
 
         Returns:
-            Self: The current instance, allowing for method chaining.
+            EmbeddingResponse: The response containing the embeddings.
         """
-        # Iterate over the attribute names and copy values from 'other' to 'self' where applicable
-        # noinspection PydanticTypeChecker,PyTypeChecker
-        for attr_name in LLMUsage.model_fields:
-            # Copy the attribute value from 'other' to 'self' only if 'self' has None and 'other' has a non-None value
-            if getattr(self, attr_name) is None and (attr := getattr(other, attr_name)) is not None:
-                setattr(self, attr_name, attr)
-
-        # Return the current instance to allow for method chaining
-        return self
+        return await litellm.aembedding(
+            input=input_text,
+            caching=caching or self.embedding_caching or configs.embedding.caching,
+            dimensions=dimensions or self.embedding_dimensions or configs.embedding.dimensions,
+            model=model or self.embedding_model or configs.embedding.model or self.llm_model or configs.llm.model,
+            timeout=timeout
+            or self.embedding_timeout
+            or configs.embedding.timeout
+            or self.llm_timeout
+            or configs.llm.timeout,
+            api_key=(
+                self.embedding_api_key or configs.embedding.api_key or self.llm_api_key or configs.llm.api_key
+            ).get_secret_value(),
+            api_base=(
+                self.embedding_api_endpoint
+                or configs.embedding.api_endpoint
+                or self.llm_api_endpoint
+                or configs.llm.api_endpoint
+            )
+            .unicode_string()
+            .rstrip("/"),
+            # seems embedding function takes no base_url end with a slash
+        )
 
-    def hold_to(self, others: Union["LLMUsage", Iterable["LLMUsage"]]) -> Self:
-        """Hold to another instance's attribute values if the current instance's attributes are None.
+    @overload
+    async def vectorize(self, input_text: List[str], **kwargs: Unpack[EmbeddingKwargs]) -> List[List[float]]: ...
+    @overload
+    async def vectorize(self, input_text: str, **kwargs: Unpack[EmbeddingKwargs]) -> List[float]: ...
+
+    async def vectorize(
+        self, input_text: List[str] | str, **kwargs: Unpack[EmbeddingKwargs]
+    ) -> List[List[float]] | List[float]:
+        """Asynchronously generates vector embeddings for the given input text.
 
         Args:
-            others (LLMUsage | Iterable[LLMUsage]): Another instance or iterable of instances from which to copy attribute values.
+            input_text (List[str] | str): A string or list of strings to generate embeddings for.
+            **kwargs (Unpack[EmbeddingKwargs]): Additional keyword arguments for embedding.
 
         Returns:
-            Self: The current instance, allowing for method chaining.
+            List[List[float]] | List[float]: The generated embeddings.
         """
-        for other in others:
-            # noinspection PyTypeChecker,PydanticTypeChecker
-            for attr_name in LLMUsage.model_fields:
-                if (attr := getattr(self, attr_name)) is not None and getattr(other, attr_name) is None:
-                    setattr(other, attr_name, attr)
+        if isinstance(input_text, str):
+            return (await self.aembedding([input_text], **kwargs)).data[0].get("embedding")
+
+        return [o.get("embedding") for o in (await self.aembedding(input_text, **kwargs)).data]
 
 
 class ToolBoxUsage(LLMUsage):

fabricatio/models/utils.py

@@ -1,6 +1,6 @@
 """A module containing utility classes for the models."""
 
-from typing import Dict, List, Literal, Self
+from typing import Any, Dict, List, Literal, Optional, Self
 
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -76,3 +76,52 @@ class Messages(list):
             list[dict]: A list of dictionaries representing the messages.
         """
         return [message.model_dump() for message in self]
+
+
+class MilvusData(BaseModel):
+    """A class representing data stored in Milvus."""
+
+    model_config = ConfigDict(use_attribute_docstrings=True)
+    id: Optional[int] = Field(default=None)
+    """The identifier of the data."""
+
+    vector: List[float]
+    """The vector representation of the data."""
+
+    text: str
+    """The text representation of the data."""
+
+    subject: Optional[str] = Field(default=None)
+    """A subject label that we use to demo metadata filtering later."""
+
+    def prepare_insertion(self) -> Dict[str, Any]:
+        """Prepares the data for insertion into Milvus.
+
+        Returns:
+            dict: A dictionary containing the data to be inserted into Milvus.
+        """
+        return self.model_dump(exclude_none=True)
+
+    def update_subject(self, new_subject: str) -> Self:
+        """Updates the subject label of the data.
+
+        Args:
+            new_subject (str): The new subject label.
+
+        Returns:
+            Self: The updated instance of MilvusData.
+        """
+        self.subject = new_subject
+        return self
+
+    def update_id(self, new_id: int) -> Self:
+        """Updates the identifier of the data.
+
+        Args:
+            new_id (int): The new identifier.
+
+        Returns:
+            Self: The updated instance of MilvusData.
+        """
+        self.id = new_id
+        return self

{fabricatio-0.2.2.dist-info → fabricatio-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.2
+Version: 0.2.3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -98,32 +98,32 @@ from fabricatio import Action, Role, Task, logger
 
 
 class Hello(Action):
-    """Action that says hello."""
+   """Action that says hello."""
 
-    name: str = "hello"
-    output_key: str = "task_output"
+   name: str = "hello"
+   output_key: str = "task_output"
 
-    async def _execute(self, task_input: Task[str], **_) -> Any:
-        ret = "Hello fabricatio!"
-        logger.info("executing talk action")
-        return ret
+   async def _execute(self, task_input: Task[str], **_) -> Any:
+      ret = "Hello fabricatio!"
+      logger.info("executing talk action")
+      return ret
 
 
 async def main() -> None:
-    """Main function."""
-    role = Role(
-        name="talker", 
-        description="talker role", 
-        registry={Task.pending_label: WorkFlow(name="talk", steps=(Hello,))}
-    )
+   """Main function."""
+   role = Role(
+      name="talker",
+      description="talker role",
+      registry={Task.pending_label: WorkFlow(name="talk", steps=(Hello,))}
+   )
 
-    task = Task(name="say hello", goal="say hello", description="say hello to the world")
-    result = await task.delegate()
-    logger.success(f"Result: {result}")
+   task = Task(name="say hello", goals="say hello", description="say hello to the world")
+   result = await task.delegate()
+   logger.success(f"Result: {result}")
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+   asyncio.run(main())
 ```
 
 #### Writing and Dumping Code
@@ -311,17 +311,18 @@ from fabricatio.models.task import Task
 
 toolbox_usage = ToolBoxUsage()
 
+
 async def handle_security_vulnerabilities():
-    task = Task(
-        name="Security Check",
-        goal=["Identify security vulnerabilities"],
-        description="Perform a thorough security review on the project.",
-        dependencies=["./src/main.py"]
-    )
-    
-    vulnerabilities = await toolbox_usage.gather_tools_fine_grind(task)
-    for vulnerability in vulnerabilities:
-        print(f"Found vulnerability: {vulnerability.name}")
+   task = Task(
+      name="Security Check",
+      goals=["Identify security vulnerabilities"],
+      description="Perform a thorough security review on the project.",
+      dependencies=["./src/main.py"]
+   )
+
+   vulnerabilities = await toolbox_usage.gather_tools_fine_grind(task)
+   for vulnerability in vulnerabilities:
+      print(f"Found vulnerability: {vulnerability.name}")
 ```
 
 #### Managing CTF Challenges
@@ -334,19 +335,22 @@ from fabricatio.models.task import Task
 
 toolbox_usage = ToolBoxUsage()
 
+
 async def solve_ctf_challenge(challenge_name: str, challenge_description: str, files: list[str]):
-    task = Task(
-        name=challenge_name,
-        goal=[f"Solve {challenge_name} challenge"],
-        description=challenge_description,
-        dependencies=files
-    )
-    
-    solution = await toolbox_usage.gather_tools_fine_grind(task)
-    print(f"Challenge Solved: {solution}")
+   task = Task(
+      name=challenge_name,
+      goals=[f"Solve {challenge_name} challenge"],
+      description=challenge_description,
+      dependencies=files
+   )
+
+   solution = await toolbox_usage.gather_tools_fine_grind(task)
+   print(f"Challenge Solved: {solution}")
+
 
 if __name__ == "__main__":
-    asyncio.run(solve_ctf_challenge("Binary Exploitation", "CTF Binary Exploitation Challenge", ["./challenges/binary_exploit"]))
+   asyncio.run(
+      solve_ctf_challenge("Binary Exploitation", "CTF Binary Exploitation Challenge", ["./challenges/binary_exploit"]))
 ```
 
 ### Configuration

{fabricatio-0.2.2.dist-info → fabricatio-0.2.3.dist-info}/RECORD

@@ -1,27 +1,28 @@
-fabricatio-0.2.2.dist-info/METADATA,sha256=Xnkw59IiSN4arPkzglC1JKpJACZlGkjbr5raJLdrmb8,12334
-fabricatio-0.2.2.dist-info/WHEEL,sha256=tpW5AN9B-9qsM9WW2FXG2r193YXiqexDadpKp0A2daI,96
-fabricatio-0.2.2.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
+fabricatio-0.2.3.dist-info/METADATA,sha256=uJGeKnZ9deejZ-g23WI67qGEi0AyVN0hJWZ1hw1hjWo,12291
+fabricatio-0.2.3.dist-info/WHEEL,sha256=tpW5AN9B-9qsM9WW2FXG2r193YXiqexDadpKp0A2daI,96
+fabricatio-0.2.3.dist-info/licenses/LICENSE,sha256=do7J7EiCGbq0QPbMAL_FqLYufXpHnCnXBOuqVPwSV8Y,1088
 fabricatio/actions/communication.py,sha256=NZxIIncKgJSDyBrqNebUtH_haqtxHa8ld2TZxT3CMdU,429
 fabricatio/actions/transmission.py,sha256=xpvKqbXqgpi1BWy-vUUvmd8NZ1GhRNfsYUBp-l2jLyk,862
 fabricatio/actions/__init__.py,sha256=eFmFVPQvtNgFynIXBVr3eP-vWQDWCPng60YY5LXvZgg,115
+fabricatio/capabilities/rag.py,sha256=paq2zUOfw6whIBFkKDo1Kg5Ft5YXgWiJBNKq-6uGhuU,13295
 fabricatio/capabilities/rating.py,sha256=zmTUvsUfxFgovRQzy4djL2zKRYTHmN6JY7A4lyT5uVQ,14907
 fabricatio/capabilities/task.py,sha256=d2xtrwQxXWI40UskQCR5YhHarY7ST0ppr8TjY12uWQE,5327
-fabricatio/config.py,sha256=wzaaUHZZMRCYc37M_M4qKuLOYtwdEjYtyG77-AGkqCg,11467
-fabricatio/core.py,sha256=yQK2ZrbPYDJOaNDp0Bky3muTkB-ZaQ1ld_Qfflm2dY0,5938
+fabricatio/config.py,sha256=j9dk9q_1-L2rIbunj8JzMGJUQLZ4-TAyLRYQ5BiP3B0,13232
+fabricatio/core.py,sha256=VQ_JKgUGIy2gZ8xsTBZCdr_IP7wC5aPg0_bsOmjQ588,6458
 fabricatio/decorators.py,sha256=uzsP4tFKQNjDHBkofsjjoJA0IUAaYOtt6YVedoyOqlo,6551
 fabricatio/fs/curd.py,sha256=faMstgGUiQ4k2AW3OXfvvWWTldTtKXco7QINYaMjmyA,3981
 fabricatio/fs/readers.py,sha256=Pz1-cdZYtmqr032dsroImlkFXAd0kCYY_9qVpD4UrG4,1045
 fabricatio/fs/__init__.py,sha256=lWcKYg0v3mv2LnnSegOQaTtlVDODU0vtw_s6iKU5IqQ,122
 fabricatio/journal.py,sha256=siqimKF0M_QaaOCMxtjr_BJVNyUIAQWILzE9Q4T6-7c,781
-fabricatio/models/action.py,sha256=Urs16f99CzRRAwulslgikloOAb_Ln9ZYKunKJpsAzu0,5721
+fabricatio/models/action.py,sha256=NpklAVUHYO5JIY9YLwYowZ-U8R9CFf5aC10DhLF7gxQ,5924
 fabricatio/models/events.py,sha256=mrihNEFgQ5o7qFWja1z_qX8dnaTLwPBoJdVlzxQV5oM,2719
-fabricatio/models/generic.py,sha256=WEjZ96rTyBjaBjkM6e8E4Pg_Naot4xWRvGJteqBiCCI,5133
-fabricatio/models/kwargs_types.py,sha256=nTtD3wzSpCg-NlrJ43yW6lmfeWzD2V_XGMPlL5mXzyc,1147
+fabricatio/models/generic.py,sha256=BXCweaYDSIxit3kqh0QshdvO7eRkF8RkNt1r-9rN76Q,9146
+fabricatio/models/kwargs_types.py,sha256=Xhy5LcTB1oWBGVGipLf5y_dTb7tBzMO5QAQdEfZeI9I,1786
 fabricatio/models/role.py,sha256=gYvleTeKUGDUNKPAC5B0EPMLC4jZ4vHsFHmHiVXkU6c,1830
-fabricatio/models/task.py,sha256=CBZL016mchj7X9Tnd-pqBxJ4mgFYq0tJ8Rq_22zZz4A,9905
+fabricatio/models/task.py,sha256=M6jeDFE3jX6cNV9bdOwhjHqgBHI3FKtFLWcmlqhYgcs,11419
 fabricatio/models/tool.py,sha256=WTFnpF6xZ1nJbmIOonLsGQcM-kkDCeZiAFqyil9xg2U,6988
-fabricatio/models/usages.py,sha256=iLxas1gE7MA55ZtQJJ-qu3W6JP5KLjPgmNKqNYIF6yU,23972
-fabricatio/models/utils.py,sha256=i_kpcQpct04mQFk1nbcVGV-pl1YThWu4Qk3wbewzKkc,2535
+fabricatio/models/usages.py,sha256=Rh8zz-BUVpdsOKoV4gX1yrac-bFOfWED3rkWvKIzP0E,24569
+fabricatio/models/utils.py,sha256=mXea76bd4r2jy_zx74GM4t5kCvkMu0JTOaw_VGvTCxk,3952
 fabricatio/parser.py,sha256=uLabsvF07wRKW1PoTGuGEENCx3P4mhmuO8JkmOEkKko,3522
 fabricatio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fabricatio/toolboxes/arithmetic.py,sha256=WLqhY-Pikv11Y_0SGajwZx3WhsLNpHKf9drzAqOf_nY,1369
@@ -30,7 +31,7 @@ fabricatio/toolboxes/task.py,sha256=kU4a501awIDV7GwNDuSlK3_Ym-5OhCp5sS-insTmUmQ,
 fabricatio/toolboxes/__init__.py,sha256=b13KmASO8q5fBLwew964fn9oH86ER5g-S1PgA4fZ_xs,482
 fabricatio/_rust.pyi,sha256=0wCqtwWkVxxoqprvk8T27T8QYKIAKHS7xgsmdMNjQKc,1756
 fabricatio/_rust_instances.py,sha256=dl0-yZ4UvT5g20tQgnPJpmqtkjFGXNG_YK4eLfi_ugQ,279
-fabricatio/__init__.py,sha256=opIrN8lGyT-h2If4Qez0bRuWBa3uIT9GsM9CZy7_XJ0,1100
-fabricatio/_rust.cp312-win_amd64.pyd,sha256=4hsd6r-pYsSUSW2cSq9Ik-SSTYVXacEYygliOFx2sfk,1262080
-fabricatio-0.2.2.data/scripts/tdown.exe,sha256=T_R2-mppH1q8T8LtZdR_pa7QNrdVfrC2nRQuWgalpqQ,3396608
-fabricatio-0.2.2.dist-info/RECORD,,
+fabricatio/__init__.py,sha256=E-JoEkGpl543nTbES0JGo_qOHaj2R6fz1bUcNajveys,1246
+fabricatio/_rust.cp312-win_amd64.pyd,sha256=miczlXr6tcmL9VUTUdQEUaI6GNupRPktAAqf--4wXds,1270784
+fabricatio-0.2.3.data/scripts/tdown.exe,sha256=Shuxh1PdIObKTQtXi69ra0Dxi9yllTKjdv2LoXB-l7M,3398144
+fabricatio-0.2.3.dist-info/RECORD,,