agently 4.0.7__py3-none-any.whl → 4.0.7.2__py3-none-any.whl

agently/_default_init.py

@@ -46,6 +46,10 @@ def _load_default_plugins(plugin_manager: "PluginManager"):
 
     plugin_manager.register("ToolManager", AgentlyToolManager)
 
+    from agently.builtins.plugins.Session.AgentlyMemoSession import AgentlyMemoSession
+
+    plugin_manager.register("Session", AgentlyMemoSession)
+
 
 def _load_default_settings(settings: "Settings"):
     settings.load("yaml_file", f"{str(Path(__file__).resolve().parent)}/_default_settings.yaml")

agently/_default_settings.yaml

@@ -16,6 +16,7 @@
 storage:
   db_url: "sqlite+aiosqlite:///localstorage.db"
 prompt:
+  add_current_time: False
   role_mapping:
     system: system
     developer: developer
@@ -43,6 +44,7 @@ runtime:
   show_model_logs: False
   show_tool_logs: False
   show_trigger_flow_logs: False
+  httpx_log_level: "WARNING"
 plugins:
   ToolManager:
-    activate: AgentlyToolManager
+    activate: AgentlyToolManager

agently/base.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import logging
 from typing import Any, Literal, Type, TYPE_CHECKING, TypeVar, Generic, cast
 
 from agently.utils import Settings, create_logger, FunctionShifter, DataFormatter
@@ -37,6 +38,10 @@ _hook_default_event_handlers(event_center)
 async_system_message = event_center.async_system_message
 system_message = event_center.system_message
 logger = create_logger()
+httpx_level_name = settings.get("runtime.httpx_log_level", "WARNING")
+httpx_level = getattr(logging, str(httpx_level_name).upper(), logging.WARNING)
+logging.getLogger("httpx").setLevel(httpx_level)
+logging.getLogger("httpcore").setLevel(httpx_level)
 tool = Tool(plugin_manager, settings)
 _agently_messenger = event_center.create_messenger("Agently")
 
@@ -70,11 +75,13 @@ settings.update_mappings(
                     "runtime.show_model_logs": True,
                     "runtime.show_tool_logs": True,
                     "runtime.show_trigger_flow_logs": True,
+                    "runtime.httpx_log_level": "INFO",
                 },
                 False: {
                     "runtime.show_model_logs": False,
                     "runtime.show_tool_logs": False,
                     "runtime.show_trigger_flow_logs": False,
+                    "runtime.httpx_log_level": "WARNING",
                 },
             }
         }
@@ -85,6 +92,7 @@ settings.update_mappings(
 # BaseAgent + Extensions = Agent
 from agently.builtins.agent_extensions import (
     ToolExtension,
+    SessionExtension,
     KeyWaiterExtension,
     AutoFuncExtension,
     ConfigurePromptExtension,
@@ -92,6 +100,7 @@ from agently.builtins.agent_extensions import (
 
 
 class Agent(
+    SessionExtension,
     ToolExtension,
     KeyWaiterExtension,
     AutoFuncExtension,
@@ -117,7 +126,16 @@ class AgentlyMain(Generic[A]):
         self.tool = tool
         self.AgentType = AgentType
 
-        self.set_settings = self.settings.set_settings
+        def set_settings(key: str, value: "SerializableValue", *, auto_load_env: bool = False):
+            self.settings.set_settings(key, value, auto_load_env=auto_load_env)
+            if key in ("runtime.httpx_log_level", "debug"):
+                level_name = self.settings.get("runtime.httpx_log_level", "WARNING")
+                level = getattr(logging, str(level_name).upper(), logging.WARNING)
+                logging.getLogger("httpx").setLevel(level)
+                logging.getLogger("httpcore").setLevel(level)
+            return self
+
+        self.set_settings = set_settings
 
     def set_debug_console(self, debug_console_status: Literal["ON", "OFF"]):
         match debug_console_status:

agently/builtins/agent_extensions/ChatSessionExtension.py

@@ -16,7 +16,7 @@
 import uuid
 import yaml
 
-from typing import Any, Literal, TYPE_CHECKING, cast
+from typing import Any, Literal, Sequence, TYPE_CHECKING, cast
 
 from agently.core import BaseAgent
 from agently.types.data import ChatMessage
@@ -208,7 +208,7 @@ class ChatSessionExtension(BaseAgent):
         self._record_output_mode = mode
         return self
 
-    def add_chat_history(self, chat_history: list[dict[str, Any] | ChatMessage] | dict[str, Any] | ChatMessage):
+    def add_chat_history(self, chat_history: Sequence[dict[str, Any] | ChatMessage] | dict[str, Any] | ChatMessage):
         super().add_chat_history(chat_history)
         if self._activated_chat_session is not None:
             self.chat_session_runtime.set(self._activated_chat_session, self.prompt.get("chat_history"))

agently/builtins/agent_extensions/SessionExtension.py

@@ -0,0 +1,294 @@
+# Copyright 2023-2025 AgentEra(Agently.Tech)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import inspect
+import json
+import yaml
+
+from typing import Any, Sequence, TYPE_CHECKING
+
+from agently.core import BaseAgent
+from agently.core.Session import Session
+from agently.utils import DataPathBuilder, FunctionShifter
+
+if TYPE_CHECKING:
+    from agently.types.data import ChatMessage
+    from agently.core import Prompt
+    from agently.core.ModelRequest import ModelResponseResult
+    from agently.utils import Settings
+
+
+class SessionExtension(BaseAgent):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._session: Session | None = None
+        self._record_handler = None
+
+        self.settings.setdefault("session.record.input.paths", [], inherit=True)
+        self.settings.setdefault("session.record.input.mode", "all", inherit=True)
+        self.settings.setdefault("session.record.output.paths", [], inherit=True)
+        self.settings.setdefault("session.record.output.mode", "all", inherit=True)
+
+        self.extension_handlers.append("request_prefixes", self._session_request_prefix)
+        self.extension_handlers.append("finally", self._session_finally)
+
+        # Sync wrappers for async-first methods
+        self.set_chat_history = FunctionShifter.syncify(self.async_set_chat_history)
+        self.add_chat_history = FunctionShifter.syncify(self.async_add_chat_history)
+        self.reset_chat_history = FunctionShifter.syncify(self.async_reset_chat_history)
+
+    @property
+    def session(self) -> Session | None:
+        return self._session
+
+    def attach_session(self, session: Session | None = None, *, mode: str | None = None):
+        if session is None:
+            session = Session(parent_settings=self.settings, agent=self, plugin_manager=self.plugin_manager)
+        if mode is not None:
+            session.configure(mode=mode)
+        self._session = session
+        return self
+
+    def enable_quick_session(self, session: Session | None = None, *, load: dict[str, Any] | str | None = None):
+        if self._session is None:
+            self.attach_session(session=session)
+        assert self._session is not None
+        if load is not None:
+            if isinstance(load, dict):
+                self._session.load_json(json.dumps(load, ensure_ascii=True))
+            elif isinstance(load, str):
+                self._session.load_yaml(load)
+            else:
+                raise TypeError(f"Invalid session load data type: {type(load)}")
+        # Minimal session: no memo, no truncation, only record full chat history.
+        self._session.configure(
+            mode="lite",
+            limit={"chars": 0, "messages": 0},
+            every_n_turns=0,
+        )
+        return self
+
+    def disable_quick_session(self):
+        return self.detach_session()
+
+    def detach_session(self):
+        self._session = None
+        return self
+
+    def set_record_handler(self, handler):
+        self._record_handler = handler
+        return self
+
+    def enable_session_lite(
+        self,
+        *,
+        chars: int | None = None,
+        messages: int | None = None,
+        every_n_turns: int | None = None,
+        session: Session | None = None,
+    ):
+        if self._session is None:
+            self.attach_session(session=session)
+        assert self._session is not None
+        self._session.use_lite(chars=chars, messages=messages, every_n_turns=every_n_turns)
+        return self
+
+    def enable_session_memo(
+        self,
+        *,
+        chars: int | None = None,
+        messages: int | None = None,
+        every_n_turns: int | None = None,
+        session: Session | None = None,
+    ):
+        if self._session is None:
+            self.attach_session(session=session)
+        assert self._session is not None
+        self._session.use_memo(chars=chars, messages=messages, every_n_turns=every_n_turns)
+        return self
+
+    def _normalize_chat_history(
+        self, chat_history: Sequence[dict[str, Any] | ChatMessage] | dict[str, Any] | ChatMessage
+    ):
+        if not isinstance(chat_history, list):
+            return [chat_history]
+        return chat_history
+
+    def _stringify_content(self, content: Any):
+        if content is None:
+            return None
+        if isinstance(content, dict):
+            return yaml.safe_dump(content)
+        if isinstance(content, (str, list)):
+            return content
+        return str(content)
+
+    def _collect_record_input(self, prompt: "Prompt") -> list[dict[str, Any]]:
+        record_input_paths = self.settings.get("session.record.input.paths", [])
+        record_input_mode = self.settings.get("session.record.input.mode", "all")
+
+        if isinstance(record_input_paths, str):
+            record_input_paths = [record_input_paths]
+
+        if not isinstance(record_input_paths, list) or len(record_input_paths) == 0:
+            user_input = prompt.get("input", None)
+            if user_input not in (None, ""):
+                content = self._stringify_content(user_input)
+                if content not in (None, ""):
+                    return [{"role": "user", "content": content}]
+            try:
+                messages = prompt.to_messages()
+            except Exception:
+                return []
+            if messages:
+                content = messages[-1].get("content")
+                if content not in (None, ""):
+                    return [{"role": "user", "content": content}]
+            return []
+
+        content: Any = {}
+        for entry in record_input_paths:
+            if isinstance(entry, str):
+                prompt_key, path = entry, None
+            elif isinstance(entry, (list, tuple)) and len(entry) >= 2:
+                prompt_key, path = entry[0], entry[1]
+            else:
+                continue
+
+            if path is None:
+                value = prompt.get(str(prompt_key))
+                if value is None:
+                    continue
+                if record_input_mode == "first":
+                    return [{"role": "user", "content": self._stringify_content(value)}]
+                if not isinstance(content, dict):
+                    content = {}
+                content[prompt_key] = value
+            else:
+                prompt_value = prompt.get(str(prompt_key))
+                if isinstance(prompt_value, dict):
+                    path_value = DataPathBuilder.get_value_by_path(prompt_value, str(path))
+                    if path_value is None:
+                        continue
+                    if record_input_mode == "first":
+                        return [{"role": "user", "content": self._stringify_content(path_value)}]
+                    if not isinstance(content, dict):
+                        content = {}
+                    if prompt_key not in content or not isinstance(content[prompt_key], dict):
+                        content[prompt_key] = {}
+                    content[prompt_key][str(path)] = path_value
+
+        if content in (None, {}, []):
+            return []
+        return [{"role": "user", "content": self._stringify_content(content)}]
+
+    def _get_result_text(self, result: "ModelResponseResult"):
+        return result.full_result_data.get("text_result")
+
+    async def _collect_record_output(self, result: "ModelResponseResult") -> list[dict[str, Any]]:
+        record_output_paths = self.settings.get("session.record.output.paths", [])
+        record_output_mode = self.settings.get("session.record.output.mode", "all")
+
+        if isinstance(record_output_paths, str):
+            record_output_paths = [record_output_paths]
+
+        if not isinstance(record_output_paths, list) or len(record_output_paths) == 0:
+            assistant_text = self._get_result_text(result)
+            if assistant_text not in (None, ""):
+                return [{"role": "assistant", "content": assistant_text}]
+            return []
+
+        parsed_result = result.full_result_data.get("parsed_result")
+        if isinstance(parsed_result, dict):
+            content: Any = {}
+            for path in record_output_paths:
+                if not isinstance(path, str):
+                    continue
+                path_key = DataPathBuilder.convert_slash_to_dot(path) if "/" in path else path
+                path_value = DataPathBuilder.get_value_by_path(parsed_result, path_key)
+                if path_value is None:
+                    continue
+                if record_output_mode == "first":
+                    return [{"role": "assistant", "content": self._stringify_content(path_value)}]
+                if not isinstance(content, dict):
+                    content = {}
+                content[path_key] = path_value
+            if isinstance(content, dict) and content:
+                return [{"role": "assistant", "content": self._stringify_content(content)}]
+
+        assistant_text = self._get_result_text(result)
+        if assistant_text not in (None, ""):
+            return [{"role": "assistant", "content": assistant_text}]
+        return []
+
+    def _reset_session_history(self):
+        assert self._session is not None
+        self._session.full_chat_history = []
+        self._session.current_chat_history = []
+        self._session._turns = 0
+        self._session._last_resize_turn = 0
+        self._session._memo_cursor = 0
+
+    async def async_set_chat_history(self, chat_history: Sequence[dict[str, Any] | ChatMessage]):
+        if self._session is None:
+            return super().set_chat_history(chat_history)
+        self._reset_session_history()
+        for message in self._normalize_chat_history(chat_history):
+            self._session.append_message(message)
+        return self
+
+    async def async_add_chat_history(
+        self,
+        chat_history: Sequence[dict[str, Any] | ChatMessage] | dict[str, Any] | ChatMessage,
+    ):
+        if self._session is None:
+            return super().add_chat_history(chat_history)
+        messages = self._normalize_chat_history(chat_history)
+        if not messages:
+            return self
+        for message in messages:
+            self._session.append_message(message)
+        await self._session.async_resize()
+        return self
+
+    async def async_reset_chat_history(self):
+        if self._session is None:
+            return super().reset_chat_history()
+        self._reset_session_history()
+        return self
+
+    async def _session_request_prefix(self, prompt: "Prompt", _settings: "Settings"):
+        if self._session is None:
+            return
+        prompt.set("chat_history", self._session.current_chat_history)
+
+    async def _session_finally(self, result: "ModelResponseResult", _settings: "Settings"):
+        if self._session is None:
+            return
+        if self._record_handler is not None:
+            handler_result = self._record_handler(result)
+            if inspect.isawaitable(handler_result):
+                handler_result = await handler_result
+            if handler_result:
+                await self.async_add_chat_history(handler_result)
+            return
+
+        prompt = result.prompt
+        messages: list[dict[str, Any]] = []
+        messages.extend(self._collect_record_input(prompt))
+        messages.extend(await self._collect_record_output(result))
+        if messages:
+            await self.async_add_chat_history(messages)

agently/builtins/agent_extensions/__init__.py

@@ -14,6 +14,7 @@
 
 
 from .ToolExtension import ToolExtension
+from .SessionExtension import SessionExtension
 from .KeyWaiterExtension import KeyWaiterExtension
 from .AutoFuncExtension import AutoFuncExtension
 from .ConfigurePromptExtension import ConfigurePromptExtension

agently/builtins/plugins/PromptGenerator/AgentlyPromptGenerator.py

@@ -35,7 +35,7 @@ from pydantic import (
 
 from agently.types.plugins import PromptGenerator
 from agently.types.data import PromptModel, ChatMessageContent, TextMessageContent
-from agently.utils import SettingsNamespace, DataFormatter
+from agently.utils import SettingsNamespace, DataFormatter, TimeInfo
 
 if TYPE_CHECKING:
     from pydantic import BaseModel
@@ -47,7 +47,13 @@ if TYPE_CHECKING:
 class AgentlyPromptGenerator(PromptGenerator):
     name = "AgentlyPromptGenerator"
 
-    DEFAULT_SETTINGS = {}
+    DEFAULT_SETTINGS = {
+        "$global": {
+            "prompt": {
+                "add_current_time": False,
+            }
+        }
+    }
 
     def __init__(
         self,
@@ -310,6 +316,9 @@ class AgentlyPromptGenerator(PromptGenerator):
             merged_role_mapping.update(role_mapping)
 
         prompt_text_list.append(f"{ (merged_role_mapping['user'] if 'user' in merged_role_mapping else 'user') }:")
+        if self.settings.get("prompt.add_current_time") is True:
+            prompt_text_list.append(f"[current time]: { TimeInfo.get_current_time() }")
+            prompt_text_list.append("")
 
         # system & developer
         if prompt_object.system:
@@ -394,6 +403,21 @@ class AgentlyPromptGenerator(PromptGenerator):
         if isinstance(role_mapping, dict):
             merged_role_mapping.update(role_mapping)
 
+        add_current_time = self.settings.get("prompt.add_current_time") is True
+        current_time_prefix = f"[current time]: { TimeInfo.get_current_time() }\n\n" if add_current_time else ""
+
+        def _prepend_current_time_text(text: str) -> str:
+            return f"{ current_time_prefix }{ text }" if add_current_time else text
+
+        def _prepend_current_time_rich(content: list[dict[str, Any]]) -> list[dict[str, Any]]:
+            if not add_current_time:
+                return content
+            for item in content:
+                if item.get("type") == "text":
+                    item["text"] = _prepend_current_time_text(str(item.get("text", "")))
+                    return content
+            return [{"type": "text", "text": current_time_prefix}] + content
+
         # system & developer
         if prompt_object.system:
             prompt_messages.append(
@@ -507,7 +531,9 @@ class AgentlyPromptGenerator(PromptGenerator):
             and not prompt_object.attachment
         ):
             role = merged_role_mapping["user"] if "user" in merged_role_mapping else "user"
-            prompt_messages.append({"role": role, "content": DataFormatter.sanitize(prompt_object.input)})
+            prompt_messages.append(
+                {"role": role, "content": _prepend_current_time_text(DataFormatter.sanitize(prompt_object.input))}
+            )
         # special occasion: only attachment
         elif (
             prompt_object.attachment
@@ -521,19 +547,15 @@ class AgentlyPromptGenerator(PromptGenerator):
         ):
             role = merged_role_mapping["user"] if "user" in merged_role_mapping else "user"
             if rich_content:
-                prompt_messages.append(
-                    {
-                        "role": role,
-                        "content": [content.model_dump() for content in prompt_object.attachment],
-                    }
-                )
+                attachment_content = [content.model_dump() for content in prompt_object.attachment]
+                prompt_messages.append({"role": role, "content": _prepend_current_time_rich(attachment_content)})
             else:
                 for one_content in prompt_object.attachment:
                     if one_content.type == "text" and isinstance(one_content, TextMessageContent):
                         prompt_messages.append(
                             {
                                 "role": role,
-                                "content": one_content.text,
+                                "content": _prepend_current_time_text(one_content.text),
                             }
                         )
                     else:
@@ -550,7 +572,7 @@ class AgentlyPromptGenerator(PromptGenerator):
                 user_message_content.append(
                     {
                         "type": "text",
-                        "text": "\n".join(self._generate_main_prompt(prompt_object)),
+                        "text": _prepend_current_time_text("\n".join(self._generate_main_prompt(prompt_object))),
                     }
                 )
                 # extend attachment content
@@ -581,7 +603,9 @@ class AgentlyPromptGenerator(PromptGenerator):
                                 f"Skipped content: unable to put attachment content into prompt messages when `rich_content` == False\n"
                                 f"Content: {str(one_content.model_dump())}"
                             )
-                prompt_messages.append({"role": role, "content": "\n".join(user_message_content)})
+                prompt_messages.append(
+                    {"role": role, "content": _prepend_current_time_text("\n".join(user_message_content))}
+                )
 
         return prompt_messages
 
@@ -589,13 +613,29 @@ class AgentlyPromptGenerator(PromptGenerator):
         fields = {}
         validators = {}
 
-        def ensure_list_and_cast(v: Any, target_type: type):
+        def ensure_list_and_cast(v: Any, target_type: Any):
             if not isinstance(v, list):
                 v = [v]
-            return [
-                (target_type(item) if target_type is not Any and not isinstance(item, target_type) else item)
-                for item in v
-            ]
+            casted = []
+            for item in v:
+                if target_type is Any or not isinstance(target_type, type):
+                    casted.append(item)
+                    continue
+                target_type = cast(type, target_type)
+                if isinstance(item, target_type):
+                    casted.append(item)
+                    continue
+                if isinstance(item, Mapping):
+                    model_validate = getattr(target_type, "model_validate", None)
+                    if callable(model_validate):
+                        casted.append(model_validate(item))
+                        continue
+                    parse_obj = getattr(target_type, "parse_obj", None)
+                    if callable(parse_obj):
+                        casted.append(parse_obj(item))
+                        continue
+                casted.append(target_type(item))
+            return casted
 
         if isinstance(schema, Mapping):
             for field_name, field_type_schema in schema.items():