beswarm 0.2.82__py3-none-any.whl → 0.2.83__py3-none-any.whl

beswarm/aient/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
@@ -203,7 +204,7 @@ class TestContextManagement(unittest.IsolatedAsyncioTestCase):
 
         # 验证是否真的从 Message 对象中弹出了
         self.assertIs(popped_provider, self.tools_provider, "应该从 SystemMessage 中成功弹出 provider")
-        self.assertNotIn(self.tools_provider, system_message.providers(), "provider 不应再存在于 SystemMessage 的 providers 列表中")
+        self.assertNotIn(self.tools_provider, system_message.provider(), "provider 不应再存在于 SystemMessage 的 provider 列表中")
 
         # 3. 核心问题：检查顶层 Messages 的索引
         # 在理想情况下，直接修改子消息应该同步更新顶层索引。
@@ -236,8 +237,8 @@ class TestContextManagement(unittest.IsolatedAsyncioTestCase):
 
         # 验证弹出的消息是否正确
         self.assertIsInstance(popped_message, UserMessage)
-        self.assertEqual(len(popped_message.providers()), 1)
-        self.assertEqual(popped_message.providers()[0].name, user_provider.name)
+        self.assertEqual(len(popped_message.provider()), 1)
+        self.assertEqual(popped_message.provider()[0].name, user_provider.name)
 
         # 验证 Messages 对象的当前状态
         self.assertEqual(len(messages), 2)
@@ -417,13 +418,13 @@ class TestContextManagement(unittest.IsolatedAsyncioTestCase):
         user_message = UserMessage(self.files_provider, "This is a raw string.")
 
         # 验证 _items 列表中的第二个元素是否是 Texts 类的实例
-        self.assertEqual(len(user_message.providers()), 2)
-        self.assertIsInstance(user_message.providers()[0], Files)
-        self.assertIsInstance(user_message.providers()[1], Texts)
+        self.assertEqual(len(user_message.provider()), 2)
+        self.assertIsInstance(user_message.provider()[0], Files)
+        self.assertIsInstance(user_message.provider()[1], Texts)
 
         # 验证转换后的 Texts provider 内容是否正确
         # 我们需要异步地获取内容
-        text_provider = user_message.providers()[1]
+        text_provider = user_message.provider()[1]
         await text_provider.refresh() # 手动刷新以获取内容
         content_block = text_provider.get_content_block()
         self.assertIsNotNone(content_block)
@@ -445,7 +446,7 @@ class TestContextManagement(unittest.IsolatedAsyncioTestCase):
         # 3. 测试RoleMessage工厂类
         factory_user_msg = RoleMessage('user', "Factory-created string.")
         self.assertIsInstance(factory_user_msg, UserMessage)
-        self.assertIsInstance(factory_user_msg.providers()[0], Texts)
+        self.assertIsInstance(factory_user_msg.provider()[0], Texts)
 
         # 4. 测试无效类型
         with self.assertRaises(TypeError):
@@ -460,12 +461,12 @@ class TestContextManagement(unittest.IsolatedAsyncioTestCase):
         ]
         user_message_mixed = UserMessage(mixed_content_list)
 
-        self.assertEqual(len(user_message_mixed.providers()), 2)
-        self.assertIsInstance(user_message_mixed.providers()[0], Texts)
-        self.assertIsInstance(user_message_mixed.providers()[1], Images)
+        self.assertEqual(len(user_message_mixed.provider()), 2)
+        self.assertIsInstance(user_message_mixed.provider()[0], Texts)
+        self.assertIsInstance(user_message_mixed.provider()[1], Images)
 
         # 验证内容
-        providers = user_message_mixed.providers()
+        providers = user_message_mixed.provider()
         await asyncio.gather(*[p.refresh() for p in providers]) # 刷新所有providers
         self.assertEqual(providers[0].get_content_block().content, 'Describe the following image.')
         self.assertEqual(providers[1].get_content_block().content, 'data:image/png;base64,VGhpcyBpcyBhIGR1bW15IGltYWdlIGZpbGUu')
@@ -477,9 +478,9 @@ class TestContextManagement(unittest.IsolatedAsyncioTestCase):
         ]
         user_message_text_only = UserMessage(text_only_list)
 
-        self.assertEqual(len(user_message_text_only.providers()), 2)
-        self.assertIsInstance(user_message_text_only.providers()[0], Texts)
-        self.assertIsInstance(user_message_text_only.providers()[1], Texts)
+        self.assertEqual(len(user_message_text_only.provider()), 2)
+        self.assertIsInstance(user_message_text_only.provider()[0], Texts)
+        self.assertIsInstance(user_message_text_only.provider()[1], Texts)
 
         # 3. 在 Messages 容器中测试
         messages = Messages(UserMessage(mixed_content_list))
@@ -522,9 +523,9 @@ class TestContextManagement(unittest.IsolatedAsyncioTestCase):
 
         # 3. 验证新消息的类型和内容
         self.assertIsInstance(new_message, UserMessage, "结果应该是一个 UserMessage 实例")
-        self.assertEqual(len(new_message.providers()), 2, "新消息应该包含两个 provider")
+        self.assertEqual(len(new_message.provider()), 2, "新消息应该包含两个 provider")
 
-        providers = new_message.providers()
+        providers = new_message.provider()
         self.assertIsInstance(providers[0], Texts, "第一个 provider 应该是 Texts 类型")
         self.assertIsInstance(providers[1], Texts, "第二个 provider 应该是 Texts 类型")
 
@@ -535,14 +536,14 @@ class TestContextManagement(unittest.IsolatedAsyncioTestCase):
         self.assertEqual(providers[1].get_content_block().content, "hello", "第二个 provider 的内容应该是 'hello'")
 
         # 4. 验证原始消息没有被修改
-        self.assertEqual(len(original_message.providers()), 1, "原始消息不应该被修改")
+        self.assertEqual(len(original_message.provider()), 1, "原始消息不应该被修改")
 
         # 5. 测试 UserMessage + "string"
         new_message_add = original_message + "world"
         self.assertIsInstance(new_message_add, UserMessage)
-        self.assertEqual(len(new_message_add.providers()), 2)
+        self.assertEqual(len(new_message_add.provider()), 2)
 
-        providers_add = new_message_add.providers()
+        providers_add = new_message_add.provider()
         await asyncio.gather(*[p.refresh() for p in providers_add])
         self.assertEqual(providers_add[0].get_content_block().content, "hello")
         self.assertEqual(providers_add[1].get_content_block().content, "world")
@@ -552,9 +553,9 @@ class TestContextManagement(unittest.IsolatedAsyncioTestCase):
         # 1. 测试 "str" + UserMessage
         combined_message = "hi" + UserMessage("hello")
         self.assertIsInstance(combined_message, UserMessage)
-        self.assertEqual(len(combined_message.providers()), 2)
+        self.assertEqual(len(combined_message.provider()), 2)
 
-        providers = combined_message.providers()
+        providers = combined_message.provider()
         await asyncio.gather(*[p.refresh() for p in providers])
         self.assertEqual(providers[0].get_content_block().content, "hi")
         self.assertEqual(providers[1].get_content_block().content, "hello")
@@ -562,9 +563,9 @@ class TestContextManagement(unittest.IsolatedAsyncioTestCase):
         # 2. 测试 UserMessage(UserMessage(...)) 扁平化
         # 按照用户的要求，UserMessage(UserMessage(...)) 应该被扁平化
         nested_message = UserMessage(UserMessage("item1", "item2"))
-        self.assertEqual(len(nested_message.providers()), 2)
+        self.assertEqual(len(nested_message.provider()), 2)
 
-        providers_nested = nested_message.providers()
+        providers_nested = nested_message.provider()
         self.assertIsInstance(providers_nested[0], Texts)
         self.assertIsInstance(providers_nested[1], Texts)
 
@@ -575,9 +576,9 @@ class TestContextManagement(unittest.IsolatedAsyncioTestCase):
         # 3. 结合 1 和 2，测试用户的完整场景
         final_message = UserMessage("hi" + UserMessage("hello"))
         self.assertIsInstance(final_message, UserMessage)
-        self.assertEqual(len(final_message.providers()), 2)
+        self.assertEqual(len(final_message.provider()), 2)
 
-        providers_final = final_message.providers()
+        providers_final = final_message.provider()
         await asyncio.gather(*[p.refresh() for p in providers_final])
         self.assertEqual(providers_final[0].get_content_block().content, "hi")
         self.assertEqual(providers_final[1].get_content_block().content, "hello")
@@ -819,6 +820,488 @@ class TestContextManagement(unittest.IsolatedAsyncioTestCase):
             if os.path.exists(test_file):
                 os.remove(test_file)
 
+    async def test_z_dynamic_texts_provider(self):
+        """测试 Texts provider 是否支持可调用对象以实现动态内容"""
+        import time
+        from datetime import datetime
+
+        # 1. 使用 lambda 函数创建一个动态的 Texts provider
+        # 每次调用 render 时，它都应该返回当前时间
+        dynamic_text_provider = Texts(lambda: datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
+        messages = Messages(UserMessage(dynamic_text_provider))
+
+        # 2. 第一次渲染
+        rendered1 = await messages.render_latest()
+        time1_str = rendered1[0]['content']
+        self.assertIsNotNone(time1_str)
+
+        # 3. 等待一秒钟
+        time.sleep(1)
+
+        # 4. 第二次渲染，并期望内容已更新
+        rendered2 = await messages.render_latest()
+        time2_str = rendered2[0]['content']
+        self.assertIsNotNone(time2_str)
+
+        # 5. 验证两次渲染的时间戳不同
+        self.assertNotEqual(time1_str, time2_str, "动态 Texts provider 的内容在两次渲染之间应该更新")
+
+    async def test_z2_dynamic_texts_with_prefix(self):
+        """测试动态 Texts provider 包含静态前缀时也能正确更新"""
+        import time
+        from datetime import datetime
+        import platform
+
+        # 1. 创建一个包含静态前缀和动态内容的 provider
+        # 正确的用法是将整个表达式放入 lambda
+        dynamic_provider = Texts(lambda: f"平台信息：{platform.platform()}, 时间：{datetime.now().isoformat()}")
+        messages = Messages(UserMessage(dynamic_provider))
+
+        # 2. 第一次渲染
+        rendered1 = await messages.render_latest()
+        content1 = rendered1[0]['content']
+        self.assertIn("平台信息：", content1)
+
+        # 3. 等待一秒
+        time.sleep(1)
+
+        # 4. 第二次渲染
+        rendered2 = await messages.render_latest()
+        content2 = rendered2[0]['content']
+        self.assertIn("平台信息：", content2)
+
+        # 5. 验证两次内容不同（因为时间戳变了）
+        self.assertNotEqual(content1, content2, "包含静态前缀的动态 provider 内容应该更新")
+
+    async def test_z3_deferred_text_update_via_provider(self):
+        """测试 Texts(name=...) 初始化, 然后通过 provider 更新内容"""
+        # This test is expected to fail with a TypeError on the next line
+        # because the current Texts.__init__ requires 'text'.
+        deferred_text_provider = Texts(name="deferred_content")
+
+        messages = Messages(UserMessage(deferred_text_provider))
+
+        # Initial render: with no text, it should probably render to an empty string.
+        # 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()
+        # 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)
+
+        # 3. Get provider and update content
+        provider = messages.provider("deferred_content")
+        self.assertIsNotNone(provider)
+        provider.update("This is the new content.")
+
+        # 4. Re-render and validate
+        rendered_updated = await messages.render_latest()
+        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 内容在两次渲染之间应该更新")
+
+    def test_z6_direct_content_access(self):
+        """测试通过 .content 属性直接访问 Texts 内容"""
+        # 1. 测试静态内容
+        static_text = Texts("Hello, Architext!")
+        self.assertEqual(static_text.content, "Hello, Architext!")
+
+        # 2. 测试动态内容
+        from datetime import datetime
+        current_time_str = datetime.now().isoformat()
+        dynamic_text = Texts(lambda: current_time_str)
+        self.assertEqual(dynamic_text.content, current_time_str)
+
+        # 3. 测试更新后的内容访问
+        static_text.update("Updated content.")
+        self.assertEqual(static_text.content, "Updated content.")
+
+        # 4. 测试 None 和空字符串
+        none_text = Texts(name="none_text") # Provide a name when text is None
+        self.assertEqual(none_text.content, "")
+
+        empty_text = Texts("")
+        self.assertEqual(empty_text.content, "")
+
+    async def test_z7_provider_visibility(self):
+        """测试 provider 的可见性标志是否能正常工作"""
+        # 1. 初始化 provider，visible 默认为 True
+        text_provider = Texts("Hello, World!", name="greeting")
+        self.assertTrue(text_provider.visible)
+
+        messages = Messages(SystemMessage(text_provider))
+
+        # 2. 初始渲染，内容应该可见
+        rendered_visible = await messages.render_latest()
+        self.assertEqual(len(rendered_visible), 1)
+        self.assertEqual(rendered_visible[0]['content'], "Hello, World!")
+
+        # 3. 设置为不可见
+        provider = messages.provider("greeting")
+        provider.visible = False
+        self.assertFalse(provider.visible)
+
+        # 4. 再次渲染，内容应该消失
+        # 因为 visibility 变化会 mark_stale，所以需要 render_latest
+        rendered_invisible = await messages.render_latest()
+        self.assertEqual(len(rendered_invisible), 0, "设置为不可见后，消息应该不被渲染")
+
+        # 5. 再次设置为可见
+        provider.visible = True
+        self.assertTrue(provider.visible)
+
+        # 6. 渲染，内容应该再次出现
+        rendered_visible_again = await messages.render_latest()
+        self.assertEqual(len(rendered_visible_again), 1)
+        self.assertEqual(rendered_visible_again[0]['content'], "Hello, World!")
+
+    async def test_z8_bulk_provider_visibility_control(self):
+        """测试通过名称批量控制和豁免provider的可见性"""
+        # 1. 创建多个同名 provider
+        messages = Messages(
+            UserMessage(
+                Texts("First explanation.", name="explanation"),
+                Texts("Second explanation.", name="explanation"),
+                Texts("Some other text."),
+                Texts("Third explanation.", name="explanation")
+            )
+        )
+
+        # 2. 初始渲染，所有 "explanation" 都应该可见
+        rendered_initial = await messages.render_latest()
+        self.assertIn("First explanation.", rendered_initial[0]['content'])
+        self.assertIn("Second explanation.", rendered_initial[0]['content'])
+        self.assertIn("Third explanation.", rendered_initial[0]['content'])
+
+        # 3. 获取所有名为 "explanation" 的 provider
+        explanation_providers = messages.provider("explanation")
+        self.assertIsInstance(explanation_providers, ProviderGroup)
+        self.assertEqual(len(explanation_providers), 3)
+
+        # 4. 将所有 "explanation" provider 设置为不可见
+        # 这是需要实现的新语法
+        explanation_providers.visible = False
+        for p in explanation_providers:
+             self.assertFalse(p.visible)
+
+        # 5. 渲染，所有 "explanation" 的内容都应该消失
+        rendered_hidden = await messages.render_latest()
+        self.assertNotIn("First explanation.", rendered_hidden[0]['content'])
+        self.assertNotIn("Second explanation.", rendered_hidden[0]['content'])
+        self.assertNotIn("Third explanation.", rendered_hidden[0]['content'])
+        self.assertIn("Some other text.", rendered_hidden[0]['content'])
+
+        # 6. 将最后一个 "explanation" provider 设置回可见
+        # 这是需要实现的另一个新语法
+        explanation_providers[-1].visible = True
+        self.assertTrue(explanation_providers[-1].visible)
+        self.assertFalse(explanation_providers[0].visible)
+
+        # 7. 最终渲染，只应看到最后一个 "explanation"
+        rendered_final = await messages.render_latest()
+        self.assertNotIn("First explanation.", rendered_final[0]['content'])
+        self.assertNotIn("Second explanation.", rendered_final[0]['content'])
+        self.assertIn("Third explanation.", rendered_final[0]['content'])
+        self.assertIn("Some other text.", rendered_final[0]['content'])
+
+    async def test_z9_rolemessage_content_access(self):
+        """测试是否支持 RoleMessage.content 来访问渲染好的内容"""
+        # 1. 创建一个简单的 UserMessage
+        user_message = UserMessage("你好, Architext!")
+        # 对于简单的 Texts, refresh 不是必须的, 但这是个好习惯
+        # Message 类本身没有 refresh, 调用其 providers 的 refresh
+        for p in user_message.provider():
+            await p.refresh()
+
+        # 2. 直接访问 .content 属性
+        # 在实现该功能前，这行代码会因 AttributeError 而失败
+        self.assertEqual(user_message.content, "你好, Architext!")
+
+        # 3. 创建一个多模态消息
+        multimodal_message = AssistantMessage(
+            "这是一张图片:",
+            Images(url="data:image/png;base64,FAKE_IMG_DATA")
+        )
+        for p in multimodal_message.provider():
+            await p.refresh()
+
+        # 4. 访问多模态消息的 .content 属性，期望返回一个列表
+        content_list = multimodal_message.content
+        self.assertIsInstance(content_list, list)
+        self.assertEqual(len(content_list), 2)
+        self.assertEqual(content_list[0]['type'], 'text')
+        self.assertEqual(content_list[1]['type'], 'image_url')
+
+        # 5. 测试通过 RoleMessage 工厂创建的消息
+        role_message = RoleMessage('user', "通过工厂创建的内容")
+        for p in role_message.provider():
+            await p.refresh()
+        self.assertEqual(role_message.content, "通过工厂创建的内容")
+
+    async def test_za_message_indexing_and_length(self):
+        """测试 Message 对象是否支持通过索引访问 provider 以及获取长度"""
+        # 1. 创建一个 UserMessage
+        mess = UserMessage(
+            Texts("some instruction"),
+            Texts("hi", name="done")
+        )
+
+        # 2. 测试获取长度
+        # 这在实现 __len__ 之前会失败
+        self.assertEqual(len(mess), 2)
+
+        # 3. 测试通过索引访问
+        # 这在修改 __getitem__ 之前会失败
+        self.assertEqual(mess[-1].name, "done")
+        self.assertEqual(mess[0].name, Texts("some instruction").name)
+        self.assertEqual(mess[0], Texts("some instruction"))
+
+        # 4. 测试索引越界
+        with self.assertRaises(IndexError):
+            _ = mess[2]
+
+    async def test_zb_message_provider_by_name(self):
+        """测试是否可以通过名称从 Message 对象中获取 provider"""
+        # 1. 创建一个包含命名 provider 的 Message
+        message = UserMessage(
+            Texts("Some instruction", name="instruction"),
+            Tools([{"name": "a_tool"}], name="tools"),
+            Texts("Another instruction", name="instruction")
+        )
+
+        # 2. 测试获取单个 provider
+        tools_provider = message.provider("tools")
+        self.assertIsInstance(tools_provider, Tools)
+        self.assertEqual(tools_provider.name, "tools")
+
+        # 3. 测试获取多个同名 provider
+        instruction_providers = message.provider("instruction")
+        self.assertIsInstance(instruction_providers, ProviderGroup)
+        self.assertEqual(len(instruction_providers), 2)
+        self.assertTrue(all(isinstance(p, Texts) for p in instruction_providers))
+
+        # 4. 测试获取不存在的 provider
+        non_existent_provider = message.provider("non_existent")
+        self.assertIsNone(non_existent_provider)
+
+    async def test_zc_slicing_support(self):
+        """测试 Messages 对象是否支持切片操作"""
+        m1 = SystemMessage("1")
+        m2 = UserMessage("2")
+        m3 = AssistantMessage("3")
+        m4 = UserMessage("4")
+        messages = Messages(m1, m2, m3, m4)
+
+        # 1. Test basic slicing
+        sliced_messages = messages[1:3]
+        self.assertIsInstance(sliced_messages, Messages)
+        self.assertEqual(len(sliced_messages), 2)
+        self.assertIs(sliced_messages[0], m2)
+        self.assertIs(sliced_messages[1], m3)
+
+        # 2. Test slicing with open end
+        sliced_messages_open = messages[2:]
+        self.assertIsInstance(sliced_messages_open, Messages)
+        self.assertEqual(len(sliced_messages_open), 2)
+        self.assertIs(sliced_messages_open[0], m3)
+        self.assertIs(sliced_messages_open[1], m4)
+
+        # 3. Test slicing with open start
+        sliced_messages_start = messages[:2]
+        self.assertIsInstance(sliced_messages_start, Messages)
+        self.assertEqual(len(sliced_messages_start), 2)
+        self.assertIs(sliced_messages_start[0], m1)
+        self.assertIs(sliced_messages_start[1], m2)
+
+        # 4. Test slicing a single element
+        sliced_single = messages[2:3]
+        self.assertIsInstance(sliced_single, Messages)
+        self.assertEqual(len(sliced_single), 1)
+        self.assertIs(sliced_single[0], m3)
+
+    async def test_zd_slice_assignment(self):
+        """测试 Messages 对象的切片赋值功能"""
+        # 1. Setup initial Messages objects
+        m1 = SystemMessage("1")
+        m2 = UserMessage("2")
+        m3 = AssistantMessage("3")
+        m4 = UserMessage("4")
+        messages1 = Messages(m1, m2, m3, m4)
+
+        m5 = SystemMessage("5")
+        m6 = UserMessage("6")
+        messages2 = Messages(m5, m6)
+
+        # 2. Perform slice assignment
+        # This should replace elements from index 1 onwards in messages1
+        # with all elements from messages2
+        messages1[1:] = messages2
+
+        # 3. Verify the result
+        self.assertEqual(len(messages1), 3) # Should be m1, m5, m6
+        self.assertIs(messages1[0], m1)
+        self.assertIs(messages1[1], m5)
+        self.assertIs(messages1[2], m6)
+
+        # 4. Test assigning from a slice, with different roles to prevent merging
+        messages3 = Messages(UserMessage("A"), AssistantMessage("B"), UserMessage("C"))
+        messages4 = Messages(SystemMessage("X"), AssistantMessage("Y"))
+
+        self.assertEqual(len(messages3), 3) # Verify length before assignment
+
+        messages3[1:2] = messages4[1:] # Replace AssistantMessage("B") with AssistantMessage("Y")
+
+        # We need to refresh to access .content property correctly
+        await messages3.refresh()
+
+        self.assertEqual(len(messages3), 3)
+        self.assertEqual(messages3[0].content, "A")
+        self.assertEqual(messages3[1].content, "Y")
+        self.assertEqual(messages3[2].content, "C")
+        self.assertIsInstance(messages3[1], AssistantMessage)
+
+    async def test_ze_fstring_lambda_serialization(self):
+        """测试包含 lambda 的 f-string 消息是否可以被序列化和反序列化"""
+        import platform
+        import os
+
+        # 1. 创建一个使用 f-string 和 lambda 的动态消息
+        f_string_message = f"""系统信息: {Texts(lambda: platform.platform())}"""
+        messages_to_save = Messages(SystemMessage(f_string_message))
+
+        # 2. 定义一个临时文件路径
+        test_file_path = "test_lambda_serialization.pkl"
+
+        # 3. 序列化和反序列化
+        try:
+            # 保存
+            messages_to_save.save(test_file_path)
+
+            # 确认文件已创建
+            self.assertTrue(os.path.exists(test_file_path))
+
+            # 加载
+            messages_loaded = Messages.load(test_file_path)
+
+            # 验证加载的对象
+            self.assertIsNotNone(messages_loaded)
+            self.assertIsInstance(messages_loaded, Messages)
+            self.assertEqual(len(messages_loaded), 1)
+
+            # 4. 渲染加载后的消息以验证 lambda 是否仍然有效
+            rendered = await messages_loaded.render_latest()
+
+            self.assertEqual(len(rendered), 1)
+            self.assertIn("系统信息:", rendered[0]['content'])
+            # 验证 platform.platform() 的结果是否在渲染内容中
+            self.assertIn(platform.platform(), rendered[0]['content'])
+
+        except Exception as e:
+            # 如果出现任何异常，测试失败
+            self.fail(f"序列化或反序列化带有 lambda 的 f-string 消息时出错: {e}")
+        finally:
+            # 5. 清理临时文件
+            if os.path.exists(test_file_path):
+                os.remove(test_file_path)
+
 
 # ==============================================================================
 # 6. 演示

beswarm/aient/aient/models/chatgpt.py

@@ -97,13 +97,8 @@ class chatgpt(BaseLLM):
         Initialize Chatbot with API key (from https://platform.openai.com/account/api-keys)
         """
         super().__init__(api_key, engine, api_url, system_prompt, proxy, timeout, max_tokens, temperature, top_p, presence_penalty, frequency_penalty, reply_count, truncate_limit, use_plugins=use_plugins, print_log=print_log)
-        self.conversation: dict[str, list[dict]] = {
-            "default": [
-                {
-                    "role": "system",
-                    "content": self.system_prompt,
-                },
-            ],
+        self.conversation: dict[str, Messages] = {
+            "default": Messages(SystemMessage(self.system_prompt)),
         }
         if cache_messages:
             self.conversation["default"] = cache_messages
@@ -261,10 +256,16 @@ class chatgpt(BaseLLM):
             "image": True
         }
 
+        done_message = self.conversation[convo_id].provider("done")
+        if self.check_done and done_message:
+            done_message.visible = False
+            if self.conversation[convo_id][-1][-1].name == "done":
+                self.conversation[convo_id][-1][-1].visible = True
+
         # 构造请求数据
         request_data = {
             "model": model or self.engine,
-            "messages": self.conversation[convo_id].render_latest() if pass_history else Messages(
+            "messages": await self.conversation[convo_id].render_latest() if pass_history else Messages(
                 SystemMessage(self.system_prompt, self.conversation[convo_id].provider("files")),
                 UserMessage(prompt)
             ),