agently 4.0.5.4__tar.gz → 4.0.5.6__tar.gz

{agently-4.0.5.4 → agently-4.0.5.6}/PKG-INFO

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

{agently-4.0.5.4 → agently-4.0.5.6}/agently/builtins/plugins/ModelRequester/OpenAICompatible.py

@@ -84,6 +84,8 @@ class OpenAICompatible(ModelRequester):
         "$mappings": {
             "path_mappings": {
                 "OpenAICompatible": "plugins.ModelRequester.OpenAICompatible",
+                "OpenAI": "plugins.ModelRequester.OpenAICompatible",
+                "OAIClient": "plugins.ModelRequester.OpenAICompatible",
             },
         },
         "model_type": "chat",
@@ -98,6 +100,7 @@ class OpenAICompatible(ModelRequester):
         "proxy": None,
         "request_options": {},
         "base_url": "https://api.openai.com/v1",
+        "full_url": None,
         "path_mapping": {
             "chat": "/chat/completions",
             "completions": "/completions",
@@ -181,13 +184,25 @@ class OpenAICompatible(ModelRequester):
                 request_data = {"prompt": self.prompt.to_text()}
             case "embeddings":
                 sanitized_input = DataFormatter.sanitize(self.prompt["input"])
-                request_data = {
-                    "input": (
-                        str(sanitized_input)
-                        if isinstance(sanitized_input, (str, int, float, bool)) or sanitized_input is None
-                        else yaml.safe_dump(sanitized_input)
-                    )
-                }
+                if isinstance(sanitized_input, list):
+                    request_data = {
+                        "input": [
+                            (
+                                str(item)
+                                if isinstance(item, (str, int, float, bool)) or item is None
+                                else yaml.safe_dump(item)
+                            )
+                            for item in sanitized_input
+                        ],
+                    }
+                else:
+                    request_data = {
+                        "input": (
+                            str(sanitized_input)
+                            if isinstance(sanitized_input, (str, int, float, bool)) or sanitized_input is None
+                            else yaml.safe_dump(sanitized_input)
+                        )
+                    }
             case _:
                 self._messenger.error(
                     TypeError(
@@ -261,12 +276,19 @@ class OpenAICompatible(ModelRequester):
             }
         )
         ## !: ensure stream
-        is_stream = self.plugin_settings.get("stream", True)
+        is_stream = self.plugin_settings.get("stream")
+        if is_stream is None:
+            if self.model_type == "embeddings":
+                is_stream = False
+            else:
+                is_stream = True
         request_options.update({"stream": is_stream})
         ## set
         agently_request_dict["request_options"] = request_options
 
         # request url
+        ## get full url
+        full_url = self.plugin_settings.get("full_url")
         ## get base url
         base_url = str(self.plugin_settings.get("base_url"))
         base_url = base_url[:-1] if base_url[-1] == "/" else base_url
@@ -278,7 +300,10 @@ class OpenAICompatible(ModelRequester):
         )
         path_mapping = {k: v if v[0] == "/" else f"/{ v }" for k, v in path_mapping.items()}
         ## set
-        request_url = f"{ base_url }{ path_mapping[self.model_type] }"
+        if isinstance(full_url, str):
+            request_url = full_url
+        else:
+            request_url = f"{ base_url }{ path_mapping[self.model_type] }"
         agently_request_dict["request_url"] = request_url
 
         return AgentlyRequestData(**agently_request_dict)
@@ -357,22 +382,34 @@ class OpenAICompatible(ModelRequester):
                         json=full_request_data,
                         headers=headers_with_auth,
                     )
-                    content_type = response.headers.get("Content-Type", "")
-                    if content_type.startswith("application/json"):
-                        try:
-                            error_json = response.json()
-                        except Exception:
-                            error_json = await response.aread()
-                            error_json = json.loads(error_json.decode())
-                        error = error_json["error"]
-                        error_title = f"{ error['code'] if 'code' in error else 'unknown_code' } - { error['type'] if 'type' in error else 'unknown_type' }"
-                        error_detail = error["message"] if "message" in error else ""
-                        yield "error", error_detail
-                    else:
+                    # Raise status code >= 400
+                    if response.status_code >= 400:
+                        e = RequestError(
+                            f"Status Code: { response.status_code }\n" f"Request Data: {full_request_data}"
+                        )
                         self._messenger.error(
-                            "Error: SSE Error\n" f"Detail: {e}\n" f"Request Data: {full_request_data}", status="FAILED"
+                            e,
+                            status="FAILED",
                         )
                         yield "error", e
+                    else:
+                        content_type = response.headers.get("Content-Type", "")
+                        if content_type.startswith("application/json"):
+                            try:
+                                error_json = response.json()
+                            except Exception:
+                                error_json = await response.aread()
+                                error_json = json.loads(error_json.decode())
+                            error = error_json["error"]
+                            error_title = f"{ error['code'] if 'code' in error else 'unknown_code' } - { error['type'] if 'type' in error else 'unknown_type' }"
+                            error_detail = error["message"] if "message" in error else ""
+                            yield "error", error_detail
+                        else:
+                            self._messenger.error(
+                                "Error: SSE Error\n" f"Detail: {e}\n" f"Request Data: {full_request_data}",
+                                status="FAILED",
+                            )
+                            yield "error", e
                 except HTTPStatusError as e:
                     self._messenger.error(
                         "Error: HTTP Status Error\n"
@@ -410,8 +447,18 @@ class OpenAICompatible(ModelRequester):
                         request_data.request_url,
                         json=full_request_data,
                     )
-                    yield "message", response.content.decode()
-                    yield "message", "[DONE]"
+                    if response.status_code >= 400:
+                        e = RequestError(
+                            f"Status Code: { response.status_code }\n" f"Request Data: {full_request_data}"
+                        )
+                        self._messenger.error(
+                            e,
+                            status="FAILED",
+                        )
+                        yield "error", e
+                    else:
+                        yield "message", response.content.decode()
+                        yield "message", "[DONE]"
                 except HTTPStatusError as e:
                     self._messenger.error(
                         "Error: HTTP Status Error\n"
@@ -480,6 +527,7 @@ class OpenAICompatible(ModelRequester):
                         loaded_message,
                         role_mapping,
                         style=content_mapping_style,
+                        default="assistant",
                     )
                     if role:
                         meta.update({"role": role})
@@ -503,6 +551,9 @@ class OpenAICompatible(ModelRequester):
                             yield "extra", {extra_key: extra_value}
             else:
                 done_content = None
+                if self.model_type == "embeddings" and done_mapping is None:
+                    done_mapping = "data"
+                    content_mapping_style = "dot"
                 if done_mapping:
                     done_content = DataLocator.locate_path_in_dict(
                         message_record,
@@ -513,16 +564,20 @@ class OpenAICompatible(ModelRequester):
                     yield "done", done_content
                 else:
                     yield "done", content_buffer
-                done_message = message_record
-                if "message" not in done_message["choices"][0]:
-                    done_message["choices"][0].update({"message": {}})
-                done_message["choices"][0]["message"].update(
-                    {
-                        "role": meta["role"] if "role" in meta else "assistant",
-                        "content": done_content if done_content else content_buffer,
-                    }
-                )
-                yield "original_done", done_message
+                match self.model_type:
+                    case "embeddings":
+                        yield "original_done", message_record
+                    case "_":
+                        done_message = message_record
+                        if "message" not in done_message["choices"][0]:
+                            done_message["choices"][0].update({"message": {}})
+                        done_message["choices"][0]["message"].update(
+                            {
+                                "role": meta["role"] if "role" in meta else "assistant",
+                                "content": done_content if done_content else content_buffer,
+                            }
+                        )
+                        yield "original_done", done_message
                 if finish_reason_mapping:
                     meta.update(
                         {

{agently-4.0.5.4 → agently-4.0.5.6}/agently/builtins/plugins/ResponseParser/AgentlyResponseParser.py

@@ -153,12 +153,12 @@ class AgentlyResponseParser(ResponseParser):
                         self.full_result_data["original_done"] = data
                     case "done":
                         self.full_result_data["text_result"] = str(data)
-                        if buffer != self.full_result_data["text_result"]:
-                            warnings.warn(
-                                "Buffered streaming result is not exactly the same as final result.\n"
-                                f"Buffered Result: { buffer }\n"
-                                f"Final Result: { self.full_result_data['text_result'] }\n"
-                            )
+                        # if buffer != self.full_result_data["text_result"]:
+                        #     warnings.warn(
+                        #         "Buffered streaming result is not exactly the same as final result.\n"
+                        #         f"Buffered Result: { buffer }\n"
+                        #         f"Final Result: { self.full_result_data['text_result'] }\n"
+                        #     )
                         if self._prompt_object.output_format == "json":
                             cleaned_json = DataLocator.locate_output_json(str(data), self._prompt_object.output)
                             if cleaned_json:
@@ -204,7 +204,14 @@ class AgentlyResponseParser(ResponseParser):
                                     self.settings,
                                 )
                         else:
-                            self.full_result_data["parsed_result"] = str(data)
+                            if (
+                                isinstance(data, list)
+                                and isinstance(data[0], dict)
+                                and "object" in data[0]
+                                and data[0]["object"] == "embedding"
+                            ):
+                                data = [item["embedding"] for item in data]
+                            self.full_result_data["parsed_result"] = data
                             if self.settings.get("$log.cancel_logs") is not True:
                                 await async_system_message(
                                     "MODEL_REQUEST",

agently-4.0.5.6/agently/integrations/chromadb.py

@@ -0,0 +1,86 @@
+from agently.utils import LazyImport
+
+LazyImport.import_package("chromadb")
+
+import json
+
+from chromadb.api.types import EmbeddingFunction, Documents, Embedding, Embeddings
+
+from typing import Callable, TypedDict, Any, cast
+from agently.core import BaseAgent
+
+
+class ChromaDataDictOptional(TypedDict, total=False):
+    metadata: dict[Any, Any]
+    id: Any
+    embedding: Embedding
+
+
+class ChromaDataDict(ChromaDataDictOptional):
+    document: str
+
+
+class ChromaData:
+    def __init__(
+        self,
+        original_data: ChromaDataDict | list[ChromaDataDict],
+        *,
+        embedding_function: Callable[[str | list[str]], Embeddings] | None = None,
+        agent: BaseAgent | None = None,
+    ):
+        self._original_data = original_data if isinstance(original_data, list) else [original_data]
+        if embedding_function:
+            self._embedding_function = embedding_function
+        elif agent:
+
+            def embedding_function_by_agent(texts: str | list[str]) -> Embeddings:
+                return agent.input(texts).start()
+
+            self._embedding_function = embedding_function_by_agent
+        else:
+            self._embedding_function = None
+        self._chroma_data = {
+            "documents": [],
+            "metadatas": [],
+            "ids": [],
+            "embeddings": [],
+        }
+        if self._embedding_function is not None:
+            documents = [data["document"] for data in self._original_data]
+            embeddings = self._embedding_function(documents)
+            self._chroma_data["embeddings"] = embeddings
+            for index, data in enumerate(self._original_data):
+                data["embedding"] = embeddings[index]
+        else:
+            del self._chroma_data["embeddings"]
+        for index, data in enumerate(self._original_data):
+            self._chroma_data["documents"].append(data["document"])
+            self._chroma_data["metadatas"].append(data["metadata"] if "metadata" in data else None)
+            self._chroma_data["ids"].append(data["id"] if "id" in data else str(index))
+
+    def get_kwargs(self):
+        return self._chroma_data
+
+    def get_original_data(self):
+        return self._original_data
+
+
+class ChromaEmbeddingFunction(EmbeddingFunction):
+    def __init__(
+        self, *, embedding_function: Callable[[list[str]], Embeddings] | None = None, agent: BaseAgent | None = None
+    ):
+        if embedding_function:
+            self.embedding_function = embedding_function
+        elif agent:
+
+            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'."
+            )
+
+    def __call__(self, documents: Documents) -> Embeddings:
+        return self.embedding_function([document for document in documents])

{agently-4.0.5.4 → agently-4.0.5.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agently"
-version = "4.0.5.4"
+version = "4.0.5.6"
 description = ""
 authors = [
     {name = "Agently Team",email = "developer@agently.tech"},