agently 4.0.5.3__tar.gz → 4.0.6.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agently
-Version: 4.0.5.3
+Version: 4.0.6.2
 Summary: 
 License: Apache-2.0
 License-File: LICENSE
@@ -19,9 +19,9 @@ Requires-Dist: greenlet (>=3.2.3,<4.0.0)
 Requires-Dist: httpx (>=0.28.1,<0.29.0)
 Requires-Dist: httpx-sse (>=0.4.1,<0.5.0)
 Requires-Dist: json5 (>=0.12.0,<0.13.0)
+Requires-Dist: packaging (>=25.0,<26.0)
 Requires-Dist: pydantic (>=2.11.7,<3.0.0)
 Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
-Requires-Dist: sqlmodel (>=0.0.24,<0.0.25)
 Requires-Dist: stamina (>=25.1.0,<26.0.0)
 Requires-Dist: toml (>=0.10.2,<0.11.0)
 Description-Content-Type: text/markdown

{agently-4.0.5.3 → agently-4.0.6.2}/agently/_default_settings.yaml

@@ -22,6 +22,18 @@ prompt:
     assistant: assistant
     user: user
     _: assistant
+  prompt_title_mapping:
+    system: "SYSTEM"
+    developer: "DEVELOPER DIRECTIONS"
+    chat_history: "CHAT HISTORY"
+    info: "INFO"
+    tools: "TOOLS"
+    action_results: "ACTION RESULTS"
+    instruct: "INSTRUCT"
+    examples: "EXAMPLES"
+    input: "INPUT"
+    output: "OUTPUT"
+    output_requirement: "OUTPUT REQUIREMENT"
 response:
   streaming_parse: False
   streaming_parse_path_style: dot

{agently-4.0.5.3 → agently-4.0.6.2}/agently/builtins/agent_extensions/ConfigurePromptExtension.py

@@ -38,11 +38,13 @@ class ConfigurePromptExtension(BaseAgent):
                 output_desc = output_prompt_value[".desc"]
             if output_type or output_desc:
                 return (
-                    output_type if output_type is not None else Any,
+                    self._generate_output_value(output_type) if output_type is not None else Any,
                     output_desc,
                 )
             else:
-                return output_prompt_value
+                return {key: self._generate_output_value(value) for key, value in output_prompt_value.items()}
+        elif isinstance(output_prompt_value, list):
+            return [self._generate_output_value(item) for item in output_prompt_value]
         else:
             return output_prompt_value
 

{agently-4.0.5.3 → agently-4.0.6.2}/agently/builtins/agent_extensions/KeyWaiterExtension.py

@@ -19,6 +19,7 @@ from typing import Any, Callable
 from agently.core import BaseAgent
 from agently.utils import FunctionShifter, GeneratorConsumer
 
+
 class KeyWaiterExtension(BaseAgent):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -48,7 +49,7 @@ class KeyWaiterExtension(BaseAgent):
 
     def __get_consumer(self):
         response = self.get_response()
-        return GeneratorConsumer(response.get_async_generator(content="instant"))
+        return GeneratorConsumer(response.get_async_generator(type="instant"))
 
     async def async_get_key_result(
         self,

{agently-4.0.5.3 → agently-4.0.6.2}/agently/builtins/agent_extensions/ToolExtension.py

@@ -119,7 +119,7 @@ class ToolExtension(BaseAgent):
                 },
             )
             tool_judgement_response = tool_judgement_request.get_response()
-            tool_judgement_result = tool_judgement_response.get_async_generator(content="instant")
+            tool_judgement_result = tool_judgement_response.get_async_generator(type="instant")
             async for instant in tool_judgement_result:
                 if instant.path == "use_tool" and instant.is_complete:
                     if instant.value is False:

{agently-4.0.5.3 → agently-4.0.6.2}/agently/builtins/plugins/ModelRequester/OpenAICompatible.py

@@ -46,6 +46,7 @@ class ContentMapping(TypedDict):
     id: str | None
     role: str | None
     delta: str | None
+    tool_calls: str | None
     done: str | None
     usage: str | None
     finish_reason: str | None
@@ -84,6 +85,8 @@ class OpenAICompatible(ModelRequester):
         "$mappings": {
             "path_mappings": {
                 "OpenAICompatible": "plugins.ModelRequester.OpenAICompatible",
+                "OpenAI": "plugins.ModelRequester.OpenAICompatible",
+                "OAIClient": "plugins.ModelRequester.OpenAICompatible",
             },
         },
         "model_type": "chat",
@@ -98,6 +101,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",
@@ -111,11 +115,11 @@ class OpenAICompatible(ModelRequester):
             "id": "id",
             "role": "choices[0].delta.role",
             "delta": "choices[0].delta.content",
+            "tool_calls": "choices[0].delta.tool_calls",
             "done": None,
             "usage": "usage",
             "finish_reason": "choices[0].finish_reason",
             "extra_delta": {
-                "tool_calls": "choices[0].delta.tool_calls",
                 "function_call": "choices[0].delta.function_call",
             },
             "extra_done": None,
@@ -181,13 +185,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(
@@ -200,17 +216,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 +241,8 @@ class OpenAICompatible(ModelRequester):
                     "write": 30.0,
                     "pool": 30.0,
                 },
-            )
+            ),
+            default_value={},
         )
         timeout = Timeout(**timeout_configs)
         client_options.update({"timeout": timeout})
@@ -236,7 +253,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 +271,25 @@ 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:
+            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
@@ -264,10 +297,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,44 +346,82 @@ 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:
+                    has_done = False
                     async for sse in await self._aiter_sse_with_retry(
                         client, "POST", request_data.request_url, json=full_request_data, headers=headers_with_auth
                     ):
                         yield sse.event, sse.data
+                        if sse.data.strip() == "[DONE]":
+                            has_done = False
+                    if not has_done:
+                        yield "message", "[DONE]"
                 except SSEError as e:
                     response = await client.post(
                         request_data.request_url,
                         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 ""
+                            self._messenger.error(
+                                f"Error: { error_title }\n"
+                                f"Detail: {error_detail }\n"
+                                f"Request Data: {full_request_data}",
+                                status="FAILED",
+                            )
+                            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 +448,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"
@@ -420,6 +509,7 @@ class OpenAICompatible(ModelRequester):
         id_mapping = content_mapping["id"]
         role_mapping = content_mapping["role"]
         delta_mapping = content_mapping["delta"]
+        tool_calls_mapping = content_mapping["tool_calls"]
         done_mapping = content_mapping["done"]
         usage_mapping = content_mapping["usage"]
         finish_reason_mapping = content_mapping["finish_reason"]
@@ -450,6 +540,7 @@ class OpenAICompatible(ModelRequester):
                         loaded_message,
                         role_mapping,
                         style=content_mapping_style,
+                        default="assistant",
                     )
                     if role:
                         meta.update({"role": role})
@@ -462,6 +553,14 @@ class OpenAICompatible(ModelRequester):
                     if delta:
                         content_buffer += str(delta)
                         yield "delta", delta
+                if tool_calls_mapping:
+                    tool_calls = DataLocator.locate_path_in_dict(
+                        loaded_message,
+                        tool_calls_mapping,
+                        style=content_mapping_style,
+                    )
+                    if tool_calls:
+                        yield "tool_calls", tool_calls
                 if extra_delta_mapping:
                     for extra_key, extra_path in extra_delta_mapping.items():
                         extra_value = DataLocator.locate_path_in_dict(
@@ -473,6 +572,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,
@@ -483,16 +585,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(
                         {