aient 1.1.94__tar.gz → 1.1.96__tar.gz

{aient-1.1.94 → aient-1.1.96}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aient
-Version: 1.1.94
+Version: 1.1.96
 Summary: Aient: The Awakening of Agent.
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{aient-1.1.94 → aient-1.1.96}/aient/architext/architext/core.py

@@ -4,10 +4,28 @@ import asyncio
 import logging
 import hashlib
 import mimetypes
+import uuid
+import threading
 from dataclasses import dataclass
 from abc import ABC, abstractmethod
 from typing import List, Dict, Any, Optional, Union, Callable
 
+# Global, thread-safe registry for providers created within f-strings
+_fstring_provider_registry = {}
+_registry_lock = threading.Lock()
+
+def _register_provider(provider: 'ContextProvider') -> str:
+    """Registers a provider and returns a unique placeholder."""
+    with _registry_lock:
+        provider_id = f"__provider_placeholder_{uuid.uuid4().hex}__"
+        _fstring_provider_registry[provider_id] = provider
+        return provider_id
+
+def _retrieve_provider(placeholder: str) -> Optional['ContextProvider']:
+    """Retrieves a provider from the registry."""
+    with _registry_lock:
+        return _fstring_provider_registry.pop(placeholder, None)
+
 # 1. 核心数据结构: ContentBlock
 @dataclass
 class ContentBlock:
@@ -18,6 +36,11 @@ class ContentBlock:
 class ContextProvider(ABC):
     def __init__(self, name: str):
         self.name = name; self._cached_content: Optional[str] = None; self._is_stale: bool = True
+
+    def __str__(self):
+        # This allows the object to be captured when used inside an f-string.
+        return _register_provider(self)
+
     def mark_stale(self): self._is_stale = True
     async def refresh(self):
         if self._is_stale:
@@ -63,15 +86,23 @@ class Texts(ContextProvider):
 
     async def render(self) -> Optional[str]:
         if self._is_dynamic:
-            return self._text()
-        return self._text
+            # Ensure dynamic content returns a string, even if empty
+            result = self._text()
+            return result if result is not None else ""
+        # Ensure static content returns a string, even if empty
+        return self._text if self._text is not None else ""
 
 class Tools(ContextProvider):
-    def __init__(self, tools_json: List[Dict]): super().__init__("tools"); self._tools_json = tools_json
+    def __init__(self, tools_json: Optional[List[Dict]] = None):
+        super().__init__("tools")
+        self._tools_json = tools_json or []
     def update(self, tools_json: List[Dict]):
         self._tools_json = tools_json
         self.mark_stale()
-    async def render(self) -> str: return f"<tools>{str(self._tools_json)}</tools>"
+    async def render(self) -> Optional[str]:
+        if not self._tools_json:
+            return None
+        return f"<tools>{str(self._tools_json)}</tools>"
 
 class Files(ContextProvider):
     def __init__(self, *paths: Union[str, List[str]]):
@@ -176,7 +207,23 @@ class Message(ABC):
         processed_items = []
         for item in initial_items:
             if isinstance(item, str):
-                processed_items.append(Texts(text=item))
+                # Check if the string contains placeholders from f-string rendering
+                import re
+                placeholder_pattern = re.compile(r'(__provider_placeholder_[a-f0-9]{32}__)')
+                parts = placeholder_pattern.split(item)
+
+                if len(parts) > 1: # Placeholders were found
+                    for part in parts:
+                        if not part: continue
+                        if placeholder_pattern.match(part):
+                            provider = _retrieve_provider(part)
+                            if provider:
+                                processed_items.append(provider)
+                        else:
+                            processed_items.append(Texts(text=part))
+                else: # No placeholders, just a regular string
+                    processed_items.append(Texts(text=item))
+
             elif isinstance(item, Message):
                 processed_items.extend(item.providers())
             elif isinstance(item, ContextProvider):
@@ -201,8 +248,13 @@ class Message(ABC):
         self._parent_messages: Optional['Messages'] = None
 
     def _render_content(self) -> str:
-        blocks = [item.get_content_block() for item in self._items]
-        return "\n\n".join(b.content for b in blocks if b and b.content)
+        final_parts = []
+        for item in self._items:
+            block = item.get_content_block()
+            if block and block.content is not None:
+                final_parts.append(block.content)
+
+        return "".join(final_parts)
 
     def pop(self, name: str) -> Optional[ContextProvider]:
         popped_item = None

{aient-1.1.94 → aient-1.1.96}/aient/architext/test/test.py

@@ -143,11 +143,12 @@ class TestContextManagement(unittest.IsolatedAsyncioTestCase):
         popped_image = messages.pop("image")
         self.assertIsNotNone(popped_image)
 
-        # 3. Render again, should fall back to string content
+        # 3. Render again, should fall back to string content and seamlessly join texts
         rendered_str = messages.render() # No refresh needed
         content_str = rendered_str[0]['content']
         self.assertIsInstance(content_str, str)
-        self.assertEqual(content_str, "Look at this:\n\nAny thoughts?")
+        # With the new render logic, adjacent texts are joined with ""
+        self.assertEqual(content_str, "Look at this:Any thoughts?")
 
         # Clean up
         import os
@@ -884,7 +885,11 @@ class TestContextManagement(unittest.IsolatedAsyncioTestCase):
         # If there's no content, the message itself might not be rendered.
         # Let's assume an empty provider results in the message not rendering.
         await deferred_text_provider.refresh()
-        self.assertIsNone(deferred_text_provider.get_content_block())
+        # With the new logic, it should return a block with an empty string
+        content_block = deferred_text_provider.get_content_block()
+        self.assertIsNotNone(content_block)
+        self.assertEqual(content_block.content, "")
+
 
         rendered_initial = await messages.render_latest()
         self.assertEqual(len(rendered_initial), 0)
@@ -899,6 +904,100 @@ class TestContextManagement(unittest.IsolatedAsyncioTestCase):
         self.assertEqual(len(rendered_updated), 1)
         self.assertEqual(rendered_updated[0]['content'], "This is the new content.")
 
+    async def test_z4_direct_fstring_usage(self):
+        """直接使用 f-string 语法，并预期其能够被处理"""
+
+        # 这个测试将直接使用用户期望的 f-string 语法。
+        # 由于 Python 的限制，这行代码会立即对 f-string 求值，
+        # 导致 providers 的字符串表示形式（而不是 provider 对象本身）被插入。
+        # 因此，这个测试最初会失败。
+        f_string_message = f"""<user_info>
+The user's OS version is {Texts(name="os_version")}.
+Tools: {Tools()}
+Files: {Files()}
+Current time: {Texts(name="current_time")}
+</user_info>"""
+
+        # 借助新的 f-string 处理机制，UserMessage 现在可以直接消费 f-string 的结果。
+        messages = Messages(UserMessage(f_string_message))
+
+        # 初始渲染时，provider 的内容应该为空
+        rendered_initial = await messages.render_latest()
+
+        # With the new simplest rendering logic, the output should match the f-string exactly,
+        # with empty strings for the providers and no leading whitespace.
+        expected_initial = (
+            "<user_info>\n"
+            "The user's OS version is .\n"
+            "Tools: \n"
+            "Files: \n"
+            "Current time: \n"
+            "</user_info>"
+        )
+        self.assertEqual(rendered_initial[0]['content'].strip(), expected_initial.strip())
+
+        # 现在，尝试通过 provider 更新内容。这应该会成功。
+        messages.provider("os_version").update("TestOS")
+        messages.provider("tools").update([{"name": "test_tool"}])
+        messages.provider("current_time").update("2025-12-25")
+
+        test_file = "fstring_test.txt"
+        with open(test_file, "w") as f: f.write("content from f-string test")
+
+        try:
+            messages.provider("files").update(test_file)
+
+            rendered_final = await messages.render_latest()
+            final_content = rendered_final[0]['content']
+
+            # 断言内容已经被成功更新
+            tools_str = "<tools>[{'name': 'test_tool'}]</tools>"
+            files_str = f"<latest_file_content><file><file_path>fstring_test.txt</file_path><file_content>content from f-string test</file_content></file>\n</latest_file_content>"
+
+            expected_final = f"""<user_info>
+The user's OS version is TestOS.
+Tools: {tools_str}
+Files: {files_str}
+Current time: 2025-12-25
+</user_info>"""
+            self.assertEqual(final_content.strip(), expected_final.strip())
+        finally:
+            if os.path.exists(test_file):
+                os.remove(test_file)
+
+    async def test_z5_fstring_with_dynamic_lambda(self):
+        """测试 f-string 消息是否支持动态 lambda 函数"""
+        from datetime import datetime
+        import time
+
+        # 这个测试将验证 f-string 是否能正确处理包含 lambda 的动态 provider
+        f_string_message = f"""<user_info>
+The user's OS version is {Texts(name="os_version")}.
+Current time: {Texts(lambda: datetime.now().strftime("%Y-%m-%d %H:%M:%S"))}
+</user_info>"""
+
+        messages = Messages(UserMessage(f_string_message))
+        messages.provider("os_version").update("TestOS")
+
+        # 第一次渲染
+        rendered1 = await messages.render_latest()
+        content1 = rendered1[0]['content']
+        self.assertIn("TestOS", content1)
+
+        time1_str_part = content1.split("Current time:")[1].strip().split("\n")[0]
+
+
+        # 等待一秒
+        time.sleep(1)
+
+        # 第二次渲染
+        rendered2 = await messages.render_latest()
+        content2 = rendered2[0]['content']
+        time2_str_part = content2.split("Current time:")[1].strip().split("\n")[0]
+
+        # 验证两次渲染的时间戳不同
+        self.assertNotEqual(time1_str_part, time2_str_part, "f-string 中的动态 lambda 内容在两次渲染之间应该更新")
+
 
 # ==============================================================================
 # 6. 演示

{aient-1.1.94 → aient-1.1.96}/aient.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aient
-Version: 1.1.94
+Version: 1.1.96
 Summary: Aient: The Awakening of Agent.
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{aient-1.1.94 → aient-1.1.96}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aient"
-version = "1.1.94"
+version = "1.1.96"
 description = "Aient: The Awakening of Agent."
 readme = "README.md"
 requires-python = ">=3.11"