agently 4.0.6.6__py3-none-any.whl → 4.0.6.8__py3-none-any.whl

agently/builtins/agent_extensions/ConfigurePromptExtension.py

@@ -188,6 +188,7 @@ class ConfigurePromptExtension(BaseAgent):
                 "Cannot execute YAML prompt configures, expect prompt configures as a dictionary data but got:"
                 f"{ prompt }"
             )
+        return self
 
     def load_json_prompt(self, path_or_content: str, mappings: dict[str, Any] | None = None):
         path = Path(path_or_content)
@@ -209,3 +210,4 @@ class ConfigurePromptExtension(BaseAgent):
                 "Cannot execute JSON prompt configures, expect prompt configures as a dictionary data but got:"
                 f"{ prompt }"
             )
+        return self

agently/builtins/plugins/ModelRequester/OpenAICompatible.py

@@ -351,13 +351,13 @@ class OpenAICompatible(ModelRequester):
         api_key = self.plugin_settings.get("api_key", None)
         if api_key is not None and auth["api_key"] == "None":
             auth["api_key"] = str(api_key)
-        if "api_key" in auth:
-            headers_with_auth = {**request_data.headers, "Authorization": f"Bearer { auth['api_key'] }"}
-        elif "headers" in auth and isinstance(auth["headers"], dict):
+        if "headers" in auth and isinstance(auth["headers"], dict):
             headers_with_auth = {**request_data.headers, **auth["headers"]}
         elif "body" in auth and isinstance(auth["body"], dict):
             headers_with_auth = request_data.headers.copy()
             request_data.data.update(**auth["body"])
+        if "api_key" in auth and auth["api_key"] != "None":
+            headers_with_auth = {**request_data.headers, "Authorization": f"Bearer { auth['api_key'] }"}
         else:
             headers_with_auth = request_data.headers.copy()
 

agently/builtins/plugins/PromptGenerator/AgentlyPromptGenerator.py

@@ -649,7 +649,12 @@ class AgentlyPromptGenerator(PromptGenerator):
                         }
                     )
 
-            return create_model(name, **fields, **validators)
+            return create_model(
+                name,
+                __config__={'extra': 'allow'},
+                **fields,
+                **validators,
+            )
         else:
             item_type = Any
             if len(schema) > 0:

agently/core/ModelRequest.py

@@ -22,12 +22,13 @@ ContentKindTuple: TypeAlias = Literal["all", "delta", "original"]
 ContentKindStreaming: TypeAlias = Literal["instant", "streaming_parse"]
 
 from agently.core import Prompt, ExtensionHandlers
-from agently.utils import Settings, FunctionShifter, DataFormatter
+from agently.utils import Settings, FunctionShifter, DataFormatter, DataLocator
 
 if TYPE_CHECKING:
     from agently.core import PluginManager
     from agently.types.data import AgentlyModelResponseMessage, PromptStandardSlot, StreamingData, SerializableValue
     from agently.types.plugins import ModelRequester, ResponseParser
+    from pydantic import BaseModel
 
 
 class ModelResponseResult:
@@ -39,6 +40,7 @@ class ModelResponseResult:
         response_generator: AsyncGenerator["AgentlyModelResponseMessage", None],
         plugin_manager: "PluginManager",
         settings: Settings,
+        extension_handlers: ExtensionHandlers,
     ):
         self.agent_name = agent_name
         self.plugin_manager = plugin_manager
@@ -50,19 +52,145 @@ class ModelResponseResult:
                 str(self.settings["plugins.ResponseParser.activate"]),
             ),
         )
-        _response_parser = ResponseParser(agent_name, response_id, prompt, response_generator, self.settings)
+        self._response_id = response_id
+        self._extension_handlers = extension_handlers
+        self._response_parser = ResponseParser(agent_name, response_id, prompt, response_generator, self.settings)
         self.prompt = prompt
-        self.full_result_data = _response_parser.full_result_data
-        self.get_meta = _response_parser.get_meta
-        self.async_get_meta = _response_parser.async_get_meta
-        self.get_text = _response_parser.get_text
-        self.async_get_text = _response_parser.async_get_text
-        self.get_data = _response_parser.get_data
-        self.async_get_data = _response_parser.async_get_data
-        self.get_data_object = _response_parser.get_data_object
-        self.async_get_data_object = _response_parser.async_get_data_object
-        self.get_generator = _response_parser.get_generator
-        self.get_async_generator = _response_parser.get_async_generator
+        self.full_result_data = self._response_parser.full_result_data
+        self.get_meta = self._response_parser.get_meta
+        self.async_get_meta = self._response_parser.async_get_meta
+        self.get_text = self._response_parser.get_text
+        self.async_get_text = self._response_parser.async_get_text
+        # self.get_data = self._response_parser.get_data
+        # self.async_get_data = self._response_parser.async_get_data
+        # self.get_data_object = self._response_parser.get_data_object
+        # self.async_get_data_object = self._response_parser.async_get_data_object
+        self.get_data = FunctionShifter.syncify(self.async_get_data)
+        self.get_data_object = FunctionShifter.syncify(self.async_get_data_object)
+        self.get_generator = self._response_parser.get_generator
+        self.get_async_generator = self._response_parser.get_async_generator
+
+    @overload
+    async def async_get_data(
+        self,
+        *,
+        type: Literal['parsed'],
+        ensure_keys: list[str],
+        key_style: Literal["dot", "slash"] = "dot",
+        max_retries: int = 3,
+        raise_ensure_failure: bool = True,
+        _retry_count: int = 0,
+    ) -> dict[str, Any]: ...
+
+    @overload
+    async def async_get_data(
+        self,
+        *,
+        type: Literal['original', 'parsed', 'all'] = "parsed",
+        ensure_keys: list[str] | None = None,
+        key_style: Literal["dot", "slash"] = "dot",
+        max_retries: int = 3,
+        raise_ensure_failure: bool = True,
+        _retry_count: int = 0,
+    ) -> Any: ...
+
+    async def async_get_data(
+        self,
+        *,
+        type: Literal['original', 'parsed', 'all'] = "parsed",
+        ensure_keys: list[str] | None = None,
+        key_style: Literal["dot", "slash"] = "dot",
+        max_retries: int = 3,
+        raise_ensure_failure: bool = True,
+        _retry_count: int = 0,
+    ) -> Any:
+        if type == "parsed" and ensure_keys:
+            try:
+                data = await self._response_parser.async_get_data(type=type)
+                for ensure_key in ensure_keys:
+                    EMPTY = object()
+                    if DataLocator.locate_path_in_dict(data, ensure_key, key_style, default=EMPTY) is EMPTY:
+                        raise
+                return data
+            except:
+                from agently.base import async_system_message
+
+                await async_system_message(
+                    "MODEL_REQUEST",
+                    {
+                        "agent_name": self.agent_name,
+                        "response_id": self._response_id,
+                        "content": {
+                            "stage": "No Target Data in Response, Preparing Retry",
+                            "detail": f"\n[Response]: { await self.async_get_text() }\n"
+                            f"[Retried Times]: { _retry_count }",
+                        },
+                    },
+                    self.settings,
+                )
+
+                if _retry_count < max_retries:
+                    return await ModelResponse(
+                        self.agent_name,
+                        self.plugin_manager,
+                        self.settings,
+                        self.prompt,
+                        self._extension_handlers,
+                    ).result.async_get_data(
+                        type=type,
+                        ensure_keys=ensure_keys,
+                        key_style=key_style,
+                        max_retries=max_retries,
+                        raise_ensure_failure=raise_ensure_failure,
+                        _retry_count=_retry_count + 1,
+                    )
+                else:
+                    if raise_ensure_failure:
+                        raise ValueError(
+                            f"Can not generate ensure keys { ensure_keys } within { max_retries } retires."
+                        )
+                    else:
+                        return await self._response_parser.async_get_data(type=type)
+        return await self._response_parser.async_get_data(type=type)
+
+    @overload
+    async def async_get_data_object(
+        self,
+        *,
+        ensure_keys: list[str],
+        key_style: Literal["dot", "slash"] = "dot",
+        max_retries: int = 3,
+        raise_ensure_failure: bool = True,
+    ) -> "BaseModel": ...
+
+    @overload
+    async def async_get_data_object(
+        self,
+        *,
+        ensure_keys: None,
+        key_style: Literal["dot", "slash"] = "dot",
+        max_retries: int = 3,
+        raise_ensure_failure: bool = True,
+    ) -> "BaseModel | None": ...
+
+    async def async_get_data_object(
+        self,
+        *,
+        ensure_keys: list[str] | None = None,
+        key_style: Literal["dot", "slash"] = "dot",
+        max_retries: int = 3,
+        raise_ensure_failure: bool = True,
+    ):
+        if ensure_keys:
+            await self.async_get_data(
+                ensure_keys=ensure_keys,
+                key_style=key_style,
+                max_retries=max_retries,
+                _retry_count=0,
+                raise_ensure_failure=raise_ensure_failure,
+            )
+            return await self._response_parser.async_get_data_object()
+        return await self._response_parser.async_get_data_object()
 
 
 class ModelResponse:
@@ -98,8 +226,8 @@ class ModelResponse:
             self._get_response_generator(),
             self.plugin_manager,
             self.settings,
+            self.extension_handlers,
         )
-        self.get_result = self.result
         self.get_meta = self.result.get_meta
         self.async_get_meta = self.result.async_get_meta
         self.get_text = self.result.get_text
@@ -406,7 +534,7 @@ class ModelRequest:
         self.prompt.clear()
         return response
 
-    async def get_result(self):
+    def get_result(self):
         return self.get_response().result
 
     async def async_get_meta(self):
@@ -419,11 +547,35 @@ class ModelRequest:
         self,
         *,
         type: Literal['original', 'parsed', 'all'] = "parsed",
+        ensure_keys: list[str] | None = None,
+        key_style: Literal["dot", "slash"] = "dot",
+        max_retries: int = 3,
+        raise_ensure_failure: bool = True,
     ):
-        return await self.get_response().async_get_data(type=type)
+        response = self.get_response()
+        return await response.async_get_data(
+            type=type,
+            ensure_keys=ensure_keys,
+            key_style=key_style,
+            max_retries=max_retries,
+            raise_ensure_failure=raise_ensure_failure,
+        )
 
-    async def async_get_data_object(self):
-        return await self.get_response().async_get_data_object()
+    async def async_get_data_object(
+        self,
+        *,
+        ensure_keys: list[str] | None = None,
+        key_style: Literal["dot", "slash"] = "dot",
+        max_retries: int = 3,
+        raise_ensure_failure: bool = True,
+    ):
+        response = self.get_response()
+        return await response.async_get_data_object(
+            ensure_keys=ensure_keys,
+            key_style=key_style,
+            max_retries=max_retries,
+            raise_ensure_failure=raise_ensure_failure,
+        )
 
     @overload
     def get_generator(

agently/integrations/chromadb.py

@@ -1,10 +1,13 @@
-from agently.utils import LazyImport, FunctionShifter
+from agently.utils import LazyImport
 
 LazyImport.import_package("chromadb")
 
-from typing import Callable, TypedDict, Any, TYPE_CHECKING
+from typing import Literal, Callable, TypedDict, Any, TYPE_CHECKING, overload
+from itertools import zip_longest
 
-from chromadb.api.types import EmbeddingFunction, DefaultEmbeddingFunction
+from chromadb import Client as ChromaDBClient
+from chromadb.config import Settings
+from chromadb.api.types import EmbeddingFunction
 
 if TYPE_CHECKING:
     from chromadb.api.types import (
@@ -13,9 +16,10 @@ if TYPE_CHECKING:
         Embeddings,
         QueryResult,
         Schema,
-        CollectionMetadata,
         DataLoader,
         Loadable,
+        Where,
+        WhereDocument,
     )
     from chromadb.api.collection_configuration import CreateCollectionConfiguration
     from chromadb.api import ClientAPI
@@ -83,29 +87,54 @@ class ChromaResults:
         *,
         queries: str | list[str],
         results: "QueryResult",
+        distance: float | None = None,
     ):
         if isinstance(queries, str):
             queries = [queries]
-        if len(queries) != len(results["documents"] or []):
+
+        ids = results.get("ids") or []
+        documents = results.get("documents")
+        metadatas = results.get("metadatas")
+        distances = results.get("distances")
+
+        if ids and len(queries) != len(ids):
             raise ValueError(
-                f"The length of queries does not equal the length of results.\nQueries: { queries }\nResults: { results }"
+                f"The length of queries does not equal the length of results['ids'].\nQueries: {queries}\nIds: {ids}"
             )
+
         self._chroma_results = results
-        self._results = {}
-        for query_index, query in enumerate(queries):
-            for result_index, id in enumerate(results["ids"][query_index]):
-                result = {
-                    "id": id,
-                    "document": results["documents"][query_index][result_index] if results["documents"] else None,
-                    "metadata": results["metadatas"][query_index][result_index] if results["metadatas"] else None,
-                    "distance": results["distances"][query_index][result_index] if results["distances"] else None,
-                }
-                self._results[query] = result
+        self._results: dict[str, list[dict]] = {}
+
+        doc_iter = documents if documents is not None else []
+        meta_iter = metadatas if metadatas is not None else []
+        dist_iter = distances if distances is not None else []
+
+        for query, row_ids, row_documents, row_metadatas, row_distances in zip_longest(
+            queries, ids, doc_iter, meta_iter, dist_iter, fillvalue=None
+        ):
+            row_ids = row_ids or []
+            query_results: list[dict[str, Any]] = []
+            for id_, doc, meta, dist in zip_longest(
+                row_ids, row_documents or [], row_metadatas or [], row_distances or [], fillvalue=None
+            ):
+                query_result = {"id": id_, "document": doc, "metadata": meta, "distance": dist}
+                if distance is None:
+                    query_results.append(query_result)
+                else:
+                    if isinstance(dist, (int, float)) and dist < distance:
+                        query_results.append(query_result)
+
+            if query:
+                self._results[query] = query_results
 
     def get_original_results(self):
         return self._chroma_results
 
-    def get(self):
+    def get(self, *, simplify_single_result: bool = False):
+        if simplify_single_result:
+            results = list(self._results.values())
+            if len(results) == 1:
+                return results[0]
         return self._results
 
 
@@ -113,55 +142,142 @@ class ChromaEmbeddingFunction(EmbeddingFunction):
     def __init__(
         self,
         *,
-        embedding_function: "Callable[[list[str]], Embeddings] | None" = None,
-        agent: "BaseAgent | None" = None,
+        embedding_agent: "BaseAgent",
     ):
-        if embedding_function:
-            self.embedding_function = embedding_function
-        elif agent:
+        def embedding_function_by_agent(texts: list[str]) -> "Embeddings":
+            return embedding_agent.input(texts).start()
 
-            def embedding_function_by_agent(texts: list[str]) -> "Embeddings":
-                return agent.input(texts).start()
-
-            self.embedding_function = embedding_function_by_agent
-        else:
-            raise ValueError(
-                f"ChromaEmbeddingFunction() requires at least one definition for 'embedding_function' or 'agent'."
-            )
+        self.embedding_function = embedding_function_by_agent
 
-    def __call__(self, documents: "Documents") -> "Embeddings":
+    def __call__(self, documents: "Documents | list[str] | str") -> "Embeddings":
+        if isinstance(documents, str):
+            documents = [documents]
         return self.embedding_function([document for document in documents])
 
 
 class ChromaCollection:
+
     def __init__(
         self,
-        conn: "ClientAPI",
         collection_name: str,
         *,
+        conn: "ClientAPI | None" = None,
         schema: "Schema | None" = None,
         configuration: "CreateCollectionConfiguration | None" = None,
-        metadata: None = None,
-        embedding_function: EmbeddingFunction | None = None,
-        agent: "BaseAgent | None" = None,
+        metadata: dict[str, Any] | None = None,
+        embedding_agent: "BaseAgent | None" = None,
         data_loader: "DataLoader[Loadable] | None" = None,
         get_or_create: bool = False,
+        hnsw_space: Literal["l2", "cosine", "ip"] = "cosine",
     ):
-        if embedding_function:
-            self._embedding_function = embedding_function
-        elif agent:
-            self._embedding_function = ChromaEmbeddingFunction(agent=agent)
-        else:
-            self._embedding_function = DefaultEmbeddingFunction()
+        if conn is None:
+            conn = ChromaDBClient(Settings(anonymized_telemetry=False))
+
+        if metadata is None:
+            metadata = {}
+
+        metadata["hnsw:space"] = hnsw_space
+
+        self.embedding_function = (
+            ChromaEmbeddingFunction(embedding_agent=embedding_agent) if embedding_agent is not None else None
+        )
 
         self._collection = conn.create_collection(
             collection_name,
             schema=schema,
             configuration=configuration,
             metadata=metadata,
-            embedding_function=embedding_function,
+            embedding_function=self.embedding_function,
             data_loader=data_loader,
             get_or_create=get_or_create,
         )
 
-    def add(self): ...
+    def add(
+        self,
+        data: ChromaDataDict | list[ChromaDataDict] | ChromaData,
+        *,
+        embedding_function: "Callable[[str | list[str]], Embeddings] | None" = None,
+    ):
+        embedding_function = embedding_function or self.embedding_function
+        if embedding_function is None:
+            raise NotImplementedError(
+                f"Embedding function must be assigned either in ChromaCollection initialize or .add() method."
+            )
+        if not isinstance(data, ChromaData):
+            data = ChromaData(data, embedding_function=embedding_function)
+        self._collection.add(**data.get_kwargs())
+        return self
+
+    @overload
+    def query(
+        self,
+        query_or_queries: str,
+        *,
+        embedding_function: "Callable[[str | list[str]], Embeddings] | None" = None,
+        top_n: int | None = None,
+        where: "Where | None" = None,
+        where_document: "WhereDocument | None" = None,
+        distance: float | None = None,
+    ) -> list[dict[str, Any]]: ...
+
+    @overload
+    def query(
+        self,
+        query_or_queries: list[str],
+        *,
+        embedding_function: "Callable[[str | list[str]], Embeddings] | None" = None,
+        top_n: int | None = None,
+        where: "Where | None" = None,
+        where_document: "WhereDocument | None" = None,
+        distance: float | None = None,
+    ) -> dict[str, list[dict[str, Any]]]: ...
+
+    def query(
+        self,
+        query_or_queries: str | list[str],
+        *,
+        embedding_function: "Callable[[str | list[str]], Embeddings] | None" = None,
+        top_n: int | None = None,
+        where: "Where | None" = None,
+        where_document: "WhereDocument | None" = None,
+        distance: float | None = None,
+    ):
+        embedding_function = embedding_function or self.embedding_function
+        if embedding_function is None:
+            raise NotImplementedError(
+                f"Embedding function must be assigned either in ChromaCollection initialize or .query() method."
+            )
+        if not isinstance(query_or_queries, list):
+            query_or_queries = [query_or_queries]
+        return ChromaResults(
+            queries=query_or_queries,
+            results=self._collection.query(
+                query_embeddings=embedding_function(query_or_queries),
+                n_results=top_n or 10,
+                where=where,
+                where_document=where_document,
+            ),
+            distance=distance,
+        ).get(simplify_single_result=True)
+
+    def query_embeddings(
+        self,
+        embeddings_dict: dict[str, "Embedding"],
+        *,
+        top_n: int | None = None,
+        where: "Where | None" = None,
+        where_document: "WhereDocument | None" = None,
+        distance: float | None = None,
+    ):
+        queries = [query for query in embeddings_dict.keys()]
+        embeddings = [embeddings for embeddings in embeddings_dict.values()]
+        return ChromaResults(
+            queries=queries,
+            results=self._collection.query(
+                query_embeddings=embeddings,
+                n_results=top_n or 10,
+                where=where,
+                where_document=where_document,
+            ),
+            distance=distance,
+        ).get(simplify_single_result=True)

{agently-4.0.6.6.dist-info → agently-4.0.6.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agently
-Version: 4.0.6.6
+Version: 4.0.6.8
 Summary: 
 License: Apache-2.0
 License-File: LICENSE

{agently-4.0.6.6.dist-info → agently-4.0.6.8.dist-info}/RECORD

@@ -4,15 +4,15 @@ agently/_default_settings.yaml,sha256=6woqJ2tjg_jl6kwSOwmTMETfVraHidort2smf0Is_q
 agently/base.py,sha256=PY-HgIQesv3_oBsU25Fwe96C35C4GgpaFdxLBUwh-AA,4692
 agently/builtins/agent_extensions/AutoFuncExtension.py,sha256=TmwMazwPzb5WXfDqfedY5yZOOMTFIHqaB9Bte29adUc,2433
 agently/builtins/agent_extensions/ChatSessionExtension.py,sha256=Y6mvnsfAY0rykKtfp-tApwJy5O4SS-YEt2-jaWr83uc,12034
-agently/builtins/agent_extensions/ConfigurePromptExtension.py,sha256=A5rYGTa0oSh1N0CdtHQSypFJqcQJm5v5CcCWRnI7iP0,10190
+agently/builtins/agent_extensions/ConfigurePromptExtension.py,sha256=vURsWcy5UnKppBNOAy0ZnY03yMY3QqH7j3ZeixS8VOo,10230
 agently/builtins/agent_extensions/KeyWaiterExtension.py,sha256=Rf8dB8Yt3_9IJifpiE-Rn6lLIXqZjaNp94lnX6Betgw,5555
 agently/builtins/agent_extensions/ToolExtension.py,sha256=S3jjumHiauEQ-m46Zkh-1I9ih02kKoj8sBEU82woz1E,6886
 agently/builtins/agent_extensions/__init__.py,sha256=IxWRQogF8PCVNXeY7D4qhGukEx3JFvfLlUW2x0FbyfA,852
 agently/builtins/hookers/ConsoleHooker.py,sha256=aJdDj_nG8CiwyelA505zvtpzBSwD52nFIkBRDJGgq3Y,8099
 agently/builtins/hookers/PureLoggerHooker.py,sha256=fzN0OfhQzgns4KeCNH-qcdm-BdQT0W2kqEmt3Zp2pYI,1906
 agently/builtins/hookers/SystemMessageHooker.py,sha256=nU5rOzcuXKdaTXWix3jhZ-4QoD4cMQJZo02wNTpZpjI,5396
-agently/builtins/plugins/ModelRequester/OpenAICompatible.py,sha256=ApH6EKAWY66eKpm-BtK6qID73CelLFA_7EfJ4zvRH1k,25233
-agently/builtins/plugins/PromptGenerator/AgentlyPromptGenerator.py,sha256=KMlXKH44MExTaGnu5cmLtvYT3aXOQiXOZN-F4JeVnJE,28514
+agently/builtins/plugins/ModelRequester/OpenAICompatible.py,sha256=xX-iy3qgToD8jIrPsL1NufMb6dlf0SVmX0rPjAkPSQ0,25261
+agently/builtins/plugins/PromptGenerator/AgentlyPromptGenerator.py,sha256=6ME04zMI2fsBeVPZtDG3AynUfY8Ulz4UUDjyp6VJRhA,28624
 agently/builtins/plugins/ResponseParser/AgentlyResponseParser.py,sha256=FEhfsiHB4Bx7HfghnObklLj08j8IVwGh0WEVD6U-G3U,17445
 agently/builtins/plugins/ToolManager/AgentlyToolManager.py,sha256=oaqte5LAryZQMD6vuEbKhe6kOLUyZTRZswC1MDFiYxw,9138
 agently/builtins/plugins/__init__.py,sha256=wj4_U9TTekc2CmjppbXKUREDFRXFX1y0ySOW-CxQuok,801
@@ -22,7 +22,7 @@ agently/builtins/tools/__init__.py,sha256=pFOWgH2C3xRvgQo3UVdkj4yHjF9nNtmoVHmOZf
 agently/core/Agent.py,sha256=HbUqlCWFgtziavN8r-2RFQyrbHMMxKA6y-io-0CY8TA,9022
 agently/core/EventCenter.py,sha256=sknU5w9MpGDQgMOF9c5k4PfM4SNT5X_LrpYte2HaFNM,10861
 agently/core/ExtensionHandlers.py,sha256=88iSAW50bgMshB56cTgKg30eOjZQyXiJY1en4w7afWY,2076
-agently/core/ModelRequest.py,sha256=LetLuKwWXtmC7JWd2UinW2e-egJhxUMZ__L0SOvu3c4,17399
+agently/core/ModelRequest.py,sha256=OAsNRKFiSAR_dfAdWO6efgUSQat8rHGfZ-zkiSPVNDc,22943
 agently/core/PluginManager.py,sha256=oUnXbe1ilQTOWwnENxtGtV6wG-yZriCxniqfuxuTFO0,4354
 agently/core/Prompt.py,sha256=8SlqytnAIM_FIWbY2Jx-T7yOs_jqmkz9cux8-2iOCjA,8023
 agently/core/Tool.py,sha256=PNYf_BwVefr8IOqf5asLaVq2fU7hQaFJwJVj3S4fq84,1871
@@ -37,7 +37,7 @@ agently/core/TriggerFlow/process/ForEachProcess.py,sha256=oBI7KIpnj2tbczt_cTJCNv
 agently/core/TriggerFlow/process/MatchCaseProcess.py,sha256=-NpbAlXq054juNkFCsDdWsIBMoHHKV1-cEsgndcd9KY,7888
 agently/core/TriggerFlow/process/__init__.py,sha256=BP5bAr9LRVVD83KFqXeprgTmXA1iCSOSsD509BtoX_E,753
 agently/core/__init__.py,sha256=CPglSpW5oEEmWpCpdvv9wK4myXmVipjuZm5HtMq6Vxo,1214
-agently/integrations/chromadb.py,sha256=Hsp2cNZ_D3WK_OkYwlYBRvYpwBEgFGf7PuQW-ckUWwA,5693
+agently/integrations/chromadb.py,sha256=hLrjwsU_d4SOGRX0bf-55uiA73YarIzRa8ORFnwu3W8,9797
 agently/types/__init__.py,sha256=xb8GMY-ULncO_PY9rfRUsyi12wAQQJx8gAAnoM30uZA,592
 agently/types/data/__init__.py,sha256=qladqSEqcAUW_XzdTDl4cvaraq_DpANy3aZbIPxoygk,1627
 agently/types/data/event.py,sha256=LFQW7MN_QGOis3XV-8K6jNXWsLvT7tYxo4BZbUBCpfI,1790
@@ -70,7 +70,7 @@ agently/utils/Storage.py,sha256=E7QyNJ9T0yOUafPgdP90La698hgLMSGjhJ7qCEHzxxw,9438
 agently/utils/StreamingJSONCompleter.py,sha256=aZ9zuGUTQlP-QKbXHUZCf6EtVuG49MKn8xdhw0VhDEA,4292
 agently/utils/StreamingJSONParser.py,sha256=sPPJOtj5OYvsrukRErcoxRl4yuV1zDuf7pQ_pvw_Zow,21116
 agently/utils/__init__.py,sha256=7MDln5OVkqFEdhhuG8VTdr2q02UWwCj-udndwzWV_iQ,1280
-agently-4.0.6.6.dist-info/METADATA,sha256=wNMoonuHHBsLZHqe94S5YV6Cae2B_EvCzQS8FMbRiYU,7112
-agently-4.0.6.6.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-agently-4.0.6.6.dist-info/licenses/LICENSE,sha256=Y5ZgAdYgMFigPT8dhN18dTLRtBshOSfWhTDRO1t0Cq4,11360
-agently-4.0.6.6.dist-info/RECORD,,
+agently-4.0.6.8.dist-info/METADATA,sha256=DRFbHp8XxD7LoxfOy2KvqFfJKqKVU4gbV7nYj0Qp5Cc,7112
+agently-4.0.6.8.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+agently-4.0.6.8.dist-info/licenses/LICENSE,sha256=Y5ZgAdYgMFigPT8dhN18dTLRtBshOSfWhTDRO1t0Cq4,11360
+agently-4.0.6.8.dist-info/RECORD,,