agently 4.0.5.3__tar.gz → 4.0.5.5__tar.gz

{agently-4.0.5.3 → agently-4.0.5.5}/PKG-INFO

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

{agently-4.0.5.3 → agently-4.0.5.5}/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",
@@ -200,17 +203,17 @@ class OpenAICompatible(ModelRequester):
         agently_request_dict["data"] = request_data
 
         # headers
-        headers = DataFormatter.to_str_key_dict(
+        headers: dict[str, str] = DataFormatter.to_str_key_dict(
             self.plugin_settings.get("headers"),
             value_format="str",
-            default={},
+            default_value={},
         )
         headers.update({"Connection": "close"})
         ## set
         agently_request_dict["headers"] = headers
 
         # client options
-        client_options = DataFormatter.to_str_key_dict(self.plugin_settings.get("client_options"))
+        client_options = DataFormatter.to_str_key_dict(self.plugin_settings.get("client_options"), default_value={})
         ## proxy
         proxy = self.plugin_settings.get("proxy", None)
         if proxy:
@@ -225,7 +228,8 @@ class OpenAICompatible(ModelRequester):
                     "write": 30.0,
                     "pool": 30.0,
                 },
-            )
+            ),
+            default_value={},
         )
         timeout = Timeout(**timeout_configs)
         client_options.update({"timeout": timeout})
@@ -236,7 +240,16 @@ class OpenAICompatible(ModelRequester):
         request_options = DataFormatter.to_str_key_dict(
             self.plugin_settings.get("request_options"),
             value_format="serializable",
+            default_value={},
         )
+        request_options_in_prompt = self.prompt.get("options", {})
+        if request_options_in_prompt:
+            request_options.update(request_options_in_prompt)
+            request_options = DataFormatter.to_str_key_dict(
+                request_options,
+                value_format="serializable",
+                default_value={},
+            )
         ## !: ensure model
         request_options.update(
             {
@@ -245,18 +258,22 @@ class OpenAICompatible(ModelRequester):
                     DataFormatter.to_str_key_dict(
                         self.plugin_settings.get("default_model"),
                         value_format="serializable",
-                        default={self.model_type: self.plugin_settings.get("default_model")},
+                        default_key=self.model_type,
                     )[self.model_type],
                 )
             }
         )
         ## !: ensure stream
-        is_stream = self.plugin_settings.get("stream", True)
+        is_stream = self.plugin_settings.get("stream")
+        if is_stream is None:
+            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
@@ -264,10 +281,14 @@ class OpenAICompatible(ModelRequester):
         path_mapping = DataFormatter.to_str_key_dict(
             self.plugin_settings.get("path_mapping"),
             value_format="str",
+            default_value={},
         )
         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)
@@ -309,16 +330,31 @@ class OpenAICompatible(ModelRequester):
         auth = DataFormatter.to_str_key_dict(
             self.plugin_settings.get("auth", "None"),
             value_format="serializable",
-            default={"api_key": self.plugin_settings.get("auth", "None")},
+            default_key="api_key",
         )
-        headers_with_auth = {**request_data.headers, "Authorization": f"Bearer { auth['api_key'] }"}
+        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):
+            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"])
+        else:
+            headers_with_auth = request_data.headers.copy()
 
         # request
         # stream request
         if self.model_type in ("chat", "completions") and request_data.stream:
             async with AsyncClient(**request_data.client_options) as client:
                 client.headers.update(headers_with_auth)
-                full_request_data = DataFormatter.to_str_key_dict(request_data.data, value_format="serializable")
+                full_request_data = DataFormatter.to_str_key_dict(
+                    request_data.data,
+                    value_format="serializable",
+                    default_value={},
+                )
                 full_request_data.update(request_data.request_options)
                 try:
                     async for sse in await self._aiter_sse_with_retry(
@@ -331,22 +367,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"
@@ -373,15 +421,29 @@ class OpenAICompatible(ModelRequester):
         else:
             async with AsyncClient(**request_data.client_options) as client:
                 client.headers.update(headers_with_auth)
-                full_request_data = DataFormatter.to_str_key_dict(request_data.data, value_format="serializable")
+                full_request_data = DataFormatter.to_str_key_dict(
+                    request_data.data,
+                    value_format="serializable",
+                    default_value={},
+                )
                 full_request_data.update(request_data.request_options)
                 try:
                     response = await client.post(
                         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"
@@ -450,6 +512,7 @@ class OpenAICompatible(ModelRequester):
                         loaded_message,
                         role_mapping,
                         style=content_mapping_style,
+                        default="assistant",
                     )
                     if role:
                         meta.update({"role": role})

{agently-4.0.5.3 → agently-4.0.5.5}/agently/core/Agent.py

@@ -110,7 +110,7 @@ class BaseAgent:
 
     def reset_chat_history(self):
         if "chat_history" in self.prompt:
-            del self.prompt["chat_history"]
+            self.prompt.set("chat_history", [])
         return self
 
     def set_chat_history(self, chat_history: "list[dict[str, Any] | ChatMessage]"):
@@ -121,6 +121,8 @@ class BaseAgent:
         return self
 
     def add_chat_history(self, chat_history: "list[dict[str, Any] | ChatMessage] | dict[str, Any] | ChatMessage"):
+        if not isinstance(chat_history, list):
+            chat_history = [chat_history]
         self.prompt.set("chat_history", chat_history)
         return self
 
@@ -252,3 +254,15 @@ class BaseAgent:
         else:
             self.request.prompt.set("output", prompt, mappings)
         return self
+
+    def options(
+        self,
+        options: dict[str, Any],
+        *,
+        always: bool = False,
+    ):
+        if always:
+            self.prompt.set("options", options)
+        else:
+            self.request.prompt.set("options", options)
+        return self

{agently-4.0.5.3 → agently-4.0.5.5}/agently/core/Prompt.py

@@ -191,5 +191,5 @@ class Prompt(RuntimeData):
         else:
             super().append(key, value)
 
-    def get(self, key: "PromptStandardSlot | None" = None, default: Any | None = None, inherit: bool = True):
+    def get(self, key: "PromptStandardSlot | None" = None, default: T = None, inherit: bool = True) -> Any | T:
         return super().get(key, default=default, inherit=inherit)

{agently-4.0.5.3 → agently-4.0.5.5}/agently/types/data/prompt.py

@@ -122,6 +122,7 @@ PromptStandardSlot = Literal[
     "attachment",
     "output",
     "output_format",
+    "options",
 ]
 
 
@@ -144,6 +145,7 @@ class PromptModel(BaseModel):
     attachment: Annotated[list[ChatMessageContent], PlainValidator(validate_attachment)] = []
     output: Any = None
     output_format: OutputFormat | Any = None
+    options: dict[str, Any] = {}
 
     model_config = ConfigDict(extra="allow")
 

{agently-4.0.5.3 → agently-4.0.5.5}/agently/utils/DataFormatter.py

@@ -23,12 +23,15 @@ from typing import (
     get_args,
     overload,
     TYPE_CHECKING,
+    TypeVar,
 )
 from pydantic import BaseModel
 
 if TYPE_CHECKING:
     from agently.types.data import SerializableValue, KwargsType
 
+T = TypeVar("T")
+
 
 class DataFormatter:
     @staticmethod
@@ -101,9 +104,10 @@ class DataFormatter:
         value: Any,
         *,
         value_format: None = None,
-        default: dict[str, Any] | None = None,
+        default_key: str,
+        default_value: T = None,
         inconvertible_warning: bool = False,
-    ) -> dict[str, Any]: ...
+    ) -> dict[str, Any | T]: ...
 
     @overload
     @staticmethod
@@ -111,9 +115,10 @@ class DataFormatter:
         value: Any,
         *,
         value_format: Literal["serializable"],
-        default: dict[str, "SerializableValue"] | None = None,
+        default_key: str,
+        default_value: T = None,
         inconvertible_warning: bool = False,
-    ) -> dict[str, "SerializableValue"]: ...
+    ) -> dict[str, "SerializableValue" | T]: ...
 
     @overload
     @staticmethod
@@ -121,18 +126,64 @@ class DataFormatter:
         value: Any,
         *,
         value_format: Literal["str"],
-        default: dict[str, str] | None = None,
+        default_key: str,
+        default_value: T = None,
         inconvertible_warning: bool = False,
-    ) -> dict[str, str]: ...
+    ) -> dict[str, str | T]: ...
+
+    @overload
+    @staticmethod
+    def to_str_key_dict(
+        value: Any,
+        *,
+        value_format: None = None,
+        default_key: None,
+        default_value: T = None,
+        inconvertible_warning: bool = False,
+    ) -> dict[str, Any] | T: ...
+
+    @overload
+    @staticmethod
+    def to_str_key_dict(
+        value: Any,
+        *,
+        value_format: Literal["serializable"],
+        default_key: None,
+        default_value: T = None,
+        inconvertible_warning: bool = False,
+    ) -> dict[str, "SerializableValue"] | T: ...
+
+    @overload
+    @staticmethod
+    def to_str_key_dict(
+        value: Any,
+        *,
+        value_format: Literal["str"],
+        default_key: None,
+        default_value: T = None,
+        inconvertible_warning: bool = False,
+    ) -> dict[str, str | T] | T: ...
+
+    @overload
+    @staticmethod
+    def to_str_key_dict(
+        value: Any,
+        *,
+        value_format: Literal['serializable', 'str'] | None = None,
+        default_key: str | None = None,
+        default_value: T = None,
+        inconvertible_warning: bool = False,
+    ) -> dict[str, Any] | T: ...
 
     @staticmethod
     def to_str_key_dict(
         value: Any,
         *,
         value_format: Literal["serializable", "str"] | None = None,
-        default: dict[str, Any] | None = None,
+        default_key: str | None = None,
+        default_value: T = None,
         inconvertible_warning: bool = False,
-    ):
+    ) -> dict[str, Any] | T:
         if isinstance(value, Mapping):
             if value_format is None:
                 return {str(DataFormatter.sanitize(k)): v for k, v in value.items()}
@@ -147,7 +198,14 @@ class DataFormatter:
                     f"Value: { value }\n"
                     "Tips: You can provide parameter 'default_key' to allow DataFormatter.to_str_key_dict() convert non-dictionary value to a dictionary { default_key: value } automatically."
                 )
-            return default if default is not None else {}
+            # restructure value to {default_key: value}
+            if default_key is not None:
+                return DataFormatter.to_str_key_dict(
+                    {default_key: value},
+                    value_format=value_format,
+                    default_value=default_value,
+                )
+            return default_value
 
     @staticmethod
     def to_str(value: Any) -> str:

{agently-4.0.5.3 → agently-4.0.5.5}/agently/utils/RuntimeData.py

@@ -392,7 +392,7 @@ class RuntimeData:
             case "yaml":
                 return yaml.safe_dump(serializable_data)
             case "toml":
-                return toml.dumps(DataFormatter.to_str_key_dict(serializable_data))
+                return toml.dumps(DataFormatter.to_str_key_dict(serializable_data, default_key="data"))
 
     def __delitem__(self, key: Any):
         if isinstance(key, str) and "." in key:

{agently-4.0.5.3 → agently-4.0.5.5}/pyproject.toml

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