Skip to content

Build and run agents you can see, understand and trust.

fix(agent): raise the CancelError when interruption happens during the tool execution (#888)

DavdGao34a8a300bde9
diff --git a/docs/tutorial/en/src/task_long_term_memory.py b/docs/tutorial/en/src/task_long_term_memory.py
index d543c49b0..055403055 100644
--- a/docs/tutorial/en/src/task_long_term_memory.py
+++ b/docs/tutorial/en/src/task_long_term_memory.py
@@ -147,180 +147,148 @@ asyncio.run(retrieve_preferences())
#
# .. note:: We provide an example of using ReMe long-term memory in the GitHub repository under the ``examples/long_term_memory/reme`` directory.
#
-
-from agentscope.memory import ReMePersonalLongTermMemory
-
-# Create ReMe personal long-term memory instance
-reme_long_term_memory = ReMePersonalLongTermMemory(
- agent_name="Friday",
- user_name="user_123",
- model=DashScopeChatModel(
- model_name="qwen3-max",
- api_key=os.environ.get("DASHSCOPE_API_KEY"),
- stream=False,
- ),
- embedding_model=DashScopeTextEmbedding(
- model_name="text-embedding-v4",
- api_key=os.environ.get("DASHSCOPE_API_KEY"),
- dimensions=1024,
- ),
-)
-
-# %%
+# .. code-block:: python
+# :caption: Example of ReMe long-term memory setup
+#
+# from agentscope.memory import ReMePersonalLongTermMemory
+#
+# # Create ReMe personal long-term memory instance
+# reme_long_term_memory = ReMePersonalLongTermMemory(
+# agent_name="Friday",
+# user_name="user_123",
+# model=DashScopeChatModel(
+# model_name="qwen3-max",
+# api_key=os.environ.get("DASHSCOPE_API_KEY"),
+# stream=False,
+# ),
+# embedding_model=DashScopeTextEmbedding(
+# model_name="text-embedding-v4",
+# api_key=os.environ.get("DASHSCOPE_API_KEY"),
+# dimensions=1024,
+# ),
+# )
+#
+#
# The ``ReMePersonalLongTermMemory`` class provides four main methods for long-term memory operations.
# They include ``record_to_memory`` and ``retrieve_from_memory`` for tool calls,
# as well as ``record`` and ``retrieve`` for direct calls.
#
# As an example, we use ``record_to_memory`` to record user preferences.
#
-
-
-async def test_record_to_memory():
- """Test record_to_memory tool function interface"""
- async with reme_long_term_memory:
- result = await reme_long_term_memory.record_to_memory(
- thinking="The user is sharing their travel preferences and habits",
- content=[
- "I prefer to stay in homestays when traveling to Hangzhou",
- "I like to visit the West Lake in the morning",
- "I enjoy drinking Longjing tea",
- ],
- )
- # Extract result text
- result_text = " ".join(
- block.get("text", "")
- for block in result.content
- if block.get("type") == "text"
- )
- print(f"Recording result: {result_text}")
-
-
-# %%
-# output
+# .. code-block:: python
+# :caption: Example of recording to ReMe long-term memory
+#
+# async def test_record_to_memory():
+# """Test record_to_memory tool function interface"""
+# async with reme_long_term_memory:
+# result = await reme_long_term_memory.record_to_memory(
+# thinking="The user is sharing their travel preferences and habits",
+# content=[
+# "I prefer to stay in homestays when traveling to Hangzhou",
+# "I like to visit the West Lake in the morning",
+# "I enjoy drinking Longjing tea",
+# ],
+# )
+# # Extract result text
+# result_text = " ".join(
+# block.get("text", "")
+# for block in result.content
+# if block.get("type") == "text"
+# )
+# print(f"Recording result: {result_text}")
#
-# .. code-block:: console
#
-# Recording result: Successfully recorded 3 memory/memories to personal memory.
#
-
-
-# %%
# Then we use ``retrieve_from_memory`` to retrieve related memories.
#
-
-
-async def test_retrieve_from_memory():
- """Test retrieve_from_memory tool function interface"""
- async with reme_long_term_memory:
- # First record some content
- await reme_long_term_memory.record_to_memory(
- thinking="User is sharing travel preferences",
- content=[
- "I prefer to stay in homestays when traveling to Hangzhou",
- ],
- )
-
- # Then retrieve
- result = await reme_long_term_memory.retrieve_from_memory(
- keywords=["Hangzhou travel", "tea preference"],
- )
- retrieved_text = " ".join(
- block.get("text", "")
- for block in result.content
- if block.get("type") == "text"
- )
- print(f"Retrieved memories: {retrieved_text}")
-
-
-# %%
-# output
-#
-# .. code-block:: console
+# .. code-block:: python
+# :caption: Example of retrieving from ReMe long-term memory
+#
+# async def test_retrieve_from_memory():
+# """Test retrieve_from_memory tool function interface"""
+# async with reme_long_term_memory:
+# # First record some content
+# await reme_long_term_memory.record_to_memory(
+# thinking="User is sharing travel preferences",
+# content=[
+# "I prefer to stay in homestays when traveling to Hangzhou",
+# ],
+# )
+#
+# # Then retrieve
+# result = await reme_long_term_memory.retrieve_from_memory(
+# keywords=["Hangzhou travel", "tea preference"],
+# )
+# retrieved_text = " ".join(
+# block.get("text", "")
+# for block in result.content
+# if block.get("type") == "text"
+# )
+# print(f"Retrieved memories: {retrieved_text}")
#
-# Retrieved memories: Keyword 'Hangzhou travel':
-# user prefers to stay in homestays when traveling to Hangzhou
#
-# Keyword 'tea preference':
-# user prefers to stay in homestays when traveling to Hangzhou
-#
-
-# %%
# Besides the tool function interface, we can also use the ``record`` method to directly record message conversations.
-
-
-async def test_record_direct():
- """Test record direct recording method"""
- async with reme_long_term_memory:
- await reme_long_term_memory.record(
- msgs=[
- Msg(
- role="user",
- content="I work as a software engineer and prefer remote work",
- name="user",
- ),
- Msg(
- role="assistant",
- content="Understood! You're a software engineer who values remote work flexibility.",
- name="assistant",
- ),
- Msg(
- role="user",
- content="I usually start my day at 9 AM with a cup of coffee",
- name="user",
- ),
- ],
- )
- print("Successfully recorded conversation messages")
-
-
-# %%
-# output
#
-# .. code-block:: console
+# .. code-block:: python
+# :caption: Example of direct recording to ReMe long-term memory
+#
+# async def test_record_direct():
+# """Test record direct recording method"""
+# async with reme_long_term_memory:
+# await reme_long_term_memory.record(
+# msgs=[
+# Msg(
+# role="user",
+# content="I work as a software engineer and prefer remote work",
+# name="user",
+# ),
+# Msg(
+# role="assistant",
+# content="Understood! You're a software engineer who values remote work flexibility.",
+# name="assistant",
+# ),
+# Msg(
+# role="user",
+# content="I usually start my day at 9 AM with a cup of coffee",
+# name="user",
+# ),
+# ],
+# )
+# print("Successfully recorded conversation messages")
#
-# Successfully recorded conversation messages
#
-
-# %%
# Similarly, we use the ``retrieve`` method to retrieve related memories.
#
-
-
-async def test_retrieve_direct():
- """Test retrieve direct retrieval method"""
- async with reme_long_term_memory:
- # First record some content
- await reme_long_term_memory.record(
- msgs=[
- Msg(
- role="user",
- content="I work as a software engineer and prefer remote work",
- name="user",
- ),
- ],
- )
-
- # Then retrieve
- memories = await reme_long_term_memory.retrieve(
- msg=Msg(
- role="user",
- content="What do you know about my work preferences?",
- name="user",
- ),
- )
- print(
- f"Retrieved memories: {memories if memories else 'No memories found'}",
- )
-
-
-# %%
-# output
+# .. code-block:: python
+# :caption: Example of direct retrieval from ReMe long-term memory
+#
+# async def test_retrieve_direct():
+# """Test retrieve direct retrieval method"""
+# async with reme_long_term_memory:
+# # First record some content
+# await reme_long_term_memory.record(
+# msgs=[
+# Msg(
+# role="user",
+# content="I work as a software engineer and prefer remote work",
+# name="user",
+# ),
+# ],
+# )
+#
+# # Then retrieve
+# memories = await reme_long_term_memory.retrieve(
+# msg=Msg(
+# role="user",
+# content="What do you know about my work preferences?",
+# name="user",
+# ),
+# )
+# print(
+# f"Retrieved memories: {memories if memories else 'No memories found'}",
+# )
#
-# .. code-block:: console
#
-# Retrieved memories: user works as a software engineer and prefers remote work
-
-# %%
# Integration with ReAct Agent
# ----------------------------------------
# In AgentScope, the ``ReActAgent`` class receives a ``long_term_memory``
@@ -333,137 +301,97 @@ async def test_retrieve_direct():
# .. note:: To achieve the best results, the ``"agent_control"`` mode may require
# additional instructions in the system prompt.
#
-
-
-# Create ReAct agent with long-term memory (agent_control mode)
-async def test_react_agent_with_reme():
- """Test ReActAgent integration with ReMe personal memory"""
- async with reme_long_term_memory:
- agent_with_reme = ReActAgent(
- name="Friday",
- sys_prompt=(
- "You are a helpful assistant named Friday with long-term memory capabilities. "
- "\n\n## Memory Management Guidelines:\n"
- "1. **Recording Memories**: When users share personal information, preferences, "
- "habits, or facts about themselves, ALWAYS record them using `record_to_memory` "
- "for future reference.\n"
- "\n2. **Retrieving Memories**: BEFORE answering questions about the user's preferences, "
- "past information, or personal details, you MUST FIRST call `retrieve_from_memory` "
- "to check if you have any relevant stored information. Do NOT rely solely on the "
- "current conversation context.\n"
- "\n3. **When to Retrieve**: Call `retrieve_from_memory` when:\n"
- " - User asks questions like 'what do I like?', 'what are my preferences?', "
- "'what do you know about me?'\n"
- " - User asks about their past behaviors, habits, or preferences\n"
- " - User refers to information they mentioned before\n"
- " - You need context about the user to provide personalized responses\n"
- "\nAlways check your memory first before claiming you don't know something about the user."
- ),
- model=DashScopeChatModel(
- model_name="qwen3-max",
- api_key=os.environ.get("DASHSCOPE_API_KEY"),
- stream=False,
- ),
- formatter=DashScopeChatFormatter(),
- toolkit=Toolkit(),
- memory=InMemoryMemory(),
- long_term_memory=reme_long_term_memory,
- long_term_memory_mode="agent_control", # Use agent_control mode
- )
-
- # User shares preferences
- msg = Msg(
- role="user",
- content="When I travel to Hangzhou, I prefer to stay in a homestay",
- name="user",
- )
- response = await agent_with_reme(msg)
- print(f"Agent response: {response.get_text_content()}")
-
- # Clear short-term memory to test long-term memory
- await agent_with_reme.memory.clear()
-
- # Query preferences
- msg2 = Msg(
- role="user",
- content="what preference do I have?",
- name="user",
- )
- response2 = await agent_with_reme(msg2)
- print(f"Agent response: {response2.get_text_content()}")
-
-
-# %%
-# output
-#
-# .. code-block:: console
+# .. code-block:: python
+# :caption: Example of ReAct agent with ReMe long-term memory
+#
+# # Create ReAct agent with long-term memory (agent_control mode)
+# async def test_react_agent_with_reme():
+# """Test ReActAgent integration with ReMe personal memory"""
+# async with reme_long_term_memory:
+# agent_with_reme = ReActAgent(
+# name="Friday",
+# sys_prompt=(
+# "You are a helpful assistant named Friday with long-term memory capabilities. "
+# "\n\n## Memory Management Guidelines:\n"
+# "1. **Recording Memories**: When users share personal information, preferences, "
+# "habits, or facts about themselves, ALWAYS record them using `record_to_memory` "
+# "for future reference.\n"
+# "\n2. **Retrieving Memories**: BEFORE answering questions about the user's preferences, "
+# "past information, or personal details, you MUST FIRST call `retrieve_from_memory` "
+# "to check if you have any relevant stored information. Do NOT rely solely on the "
+# "current conversation context.\n"
+# "\n3. **When to Retrieve**: Call `retrieve_from_memory` when:\n"
+# " - User asks questions like 'what do I like?', 'what are my preferences?', "
+# "'what do you know about me?'\n"
+# " - User asks about their past behaviors, habits, or preferences\n"
+# " - User refers to information they mentioned before\n"
+# " - You need context about the user to provide personalized responses\n"
+# "\nAlways check your memory first before claiming you don't know something about the user."
+# ),
+# model=DashScopeChatModel(
+# model_name="qwen3-max",
+# api_key=os.environ.get("DASHSCOPE_API_KEY"),
+# stream=False,
+# ),
+# formatter=DashScopeChatFormatter(),
+# toolkit=Toolkit(),
+# memory=InMemoryMemory(),
+# long_term_memory=reme_long_term_memory,
+# long_term_memory_mode="agent_control", # Use agent_control mode
+# )
+#
+# # User shares preferences
+# msg = Msg(
+# role="user",
+# content="When I travel to Hangzhou, I prefer to stay in a homestay",
+# name="user",
+# )
+# response = await agent_with_reme(msg)
+# print(f"Agent response: {response.get_text_content()}")
+#
+# # Clear short-term memory to test long-term memory
+# await agent_with_reme.memory.clear()
+#
+# # Query preferences
+# msg2 = Msg(
+# role="user",
+# content="what preference do I have?",
+# name="user",
+# )
+# response2 = await agent_with_reme(msg2)
+# print(f"Agent response: {response2.get_text_content()}")
#
-# system: {
-# "type": "tool_result",
-# "id": "call_7de95a3382e241309b16cb9e",
-# "name": "retrieve_from_memory",
-# "output": [
-# {
-# "type": "text",
-# "text": "Keyword 'preference':\nuser prefers to stay in a homestay when traveling to Hangzhou"
-# }
-# ]
-# }
-# Friday: Based on what I know, you prefer to stay in a homestay when traveling to Hangzhou. Let me know if there's anything else you'd like me to remember or clarify!
-# Agent response: Based on what I know, you prefer to stay in a homestay when traveling to Hangzhou. Let me know if there's anything else you'd like me to remember or clarify!
#
-
-# %%
# Then we clear the short-term memory and ask the agent about the user's preferences.
#
-
-
-async def retrieve_reme_preferences():
- """Retrieve user preferences from long-term memory"""
- async with reme_long_term_memory:
- # Create agent (reusing for demonstration completeness)
- agent_with_reme = ReActAgent(
- name="Friday",
- sys_prompt="You are an assistant with long-term memory capabilities.",
- model=DashScopeChatModel(
- api_key=os.environ.get("DASHSCOPE_API_KEY"),
- model_name="qwen3-max",
- stream=False,
- ),
- formatter=DashScopeChatFormatter(),
- toolkit=Toolkit(),
- memory=InMemoryMemory(),
- long_term_memory=reme_long_term_memory,
- long_term_memory_mode="agent_control",
- )
-
- # Clear short-term memory
- await agent_with_reme.memory.clear()
- # The agent will remember previous conversations
- msg2 = Msg("user", "What are my preferences? Answer briefly.", "user")
- await agent_with_reme(msg2)
-
-
-# %%
-# output
-#
-# .. code-block:: console
-#
-# system: {
-# "type": "tool_result",
-# "id": "call_e7d354e450684ceca331a8d9",
-# "name": "retrieve_from_memory",
-# "output": [
-# {
-# "type": "text",
-# "text": "No memories found for the given keywords."
-# }
-# ]
-# }
-# Friday: I don't have any recorded information about your preferences yet. Let me know what you like or need, and I can remember it for future reference!
+# .. code-block:: python
+# :caption: Example of retrieving preferences with ReAct agent and ReMe long-term memory
+#
+# async def retrieve_reme_preferences():
+# """Retrieve user preferences from long-term memory"""
+# async with reme_long_term_memory:
+# # Create agent (reusing for demonstration completeness)
+# agent_with_reme = ReActAgent(
+# name="Friday",
+# sys_prompt="You are an assistant with long-term memory capabilities.",
+# model=DashScopeChatModel(
+# api_key=os.environ.get("DASHSCOPE_API_KEY"),
+# model_name="qwen3-max",
+# stream=False,
+# ),
+# formatter=DashScopeChatFormatter(),
+# toolkit=Toolkit(),
+# memory=InMemoryMemory(),
+# long_term_memory=reme_long_term_memory,
+# long_term_memory_mode="agent_control",
+# )
+#
+# # Clear short-term memory
+# await agent_with_reme.memory.clear()
+# # The agent will remember previous conversations
+# msg2 = Msg("user", "What are my preferences? Answer briefly.", "user")
+# await agent_with_reme(msg2)
#
-
-# %%
# Customizing Long-Term Memory
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# AgentScope provides the ``LongTermMemoryBase`` base class, which defines the basic
diff --git a/docs/tutorial/zh_CN/src/task_long_term_memory.py b/docs/tutorial/zh_CN/src/task_long_term_memory.py
index e6040de37..dedf7beca 100644
--- a/docs/tutorial/zh_CN/src/task_long_term_memory.py
+++ b/docs/tutorial/zh_CN/src/task_long_term_memory.py
@@ -135,177 +135,143 @@ asyncio.run(retrieve_preferences())
#
# .. note:: 在 GitHub 仓库的 ``examples/long_term_memory/reme`` 目录下我们提供了 ReMe 长期记忆的使用示例。
#
-
-from agentscope.memory import ReMePersonalLongTermMemory
-
-# 创建 ReMe 个人长期记忆实例
-reme_long_term_memory = ReMePersonalLongTermMemory(
- agent_name="Friday",
- user_name="user_123",
- model=DashScopeChatModel(
- model_name="qwen3-max",
- api_key=os.environ.get("DASHSCOPE_API_KEY"),
- stream=False,
- ),
- embedding_model=DashScopeTextEmbedding(
- model_name="text-embedding-v4",
- api_key=os.environ.get("DASHSCOPE_API_KEY"),
- dimensions=1024,
- ),
-)
-
-# %%
+# .. code-block:: python
+# :caption: 安装 ReMe 依赖
+#
+# from agentscope.memory import ReMePersonalLongTermMemory
+#
+# # 创建 ReMe 个人长期记忆实例
+# reme_long_term_memory = ReMePersonalLongTermMemory(
+# agent_name="Friday",
+# user_name="user_123",
+# model=DashScopeChatModel(
+# model_name="qwen3-max",
+# api_key=os.environ.get("DASHSCOPE_API_KEY"),
+# stream=False,
+# ),
+# embedding_model=DashScopeTextEmbedding(
+# model_name="text-embedding-v4",
+# api_key=os.environ.get("DASHSCOPE_API_KEY"),
+# dimensions=1024,
+# ),
+# )
+#
+#
# ``ReMePersonalLongTermMemory`` 类提供了四个操作长期记忆的方法。
# 它们分别是用于工具调用的 ``record_to_memory`` 和 ``retrieve_from_memory``,
# 以及用于直接调用的 ``record`` 和 ``retrieve``。
#
# 例如下面的例子中,我们使用 ``record_to_memory`` 记录用户偏好。
#
-
-
-async def test_record_to_memory():
- """测试 record_to_memory 工具函数接口"""
- async with reme_long_term_memory:
- result = await reme_long_term_memory.record_to_memory(
- thinking="用户正在分享他们的旅行偏好和习惯",
- content=[
- "我去杭州旅行时喜欢住民宿",
- "我喜欢早上去西湖游玩",
- "我喜欢喝龙井茶",
- ],
- )
- # 提取结果文本
- result_text = " ".join(
- block.get("text", "")
- for block in result.content
- if block.get("type") == "text"
- )
- print(f"记录结果: {result_text}")
-
-
-# %%
-# 输出
-#
-# .. code-block:: console
+# .. code-block:: python
+# :caption: 创建 ReMe 个人长期记忆实例
+#
+# async def test_record_to_memory():
+# """测试 record_to_memory 工具函数接口"""
+# async with reme_long_term_memory:
+# result = await reme_long_term_memory.record_to_memory(
+# thinking="用户正在分享他们的旅行偏好和习惯",
+# content=[
+# "我去杭州旅行时喜欢住民宿",
+# "我喜欢早上去西湖游玩",
+# "我喜欢喝龙井茶",
+# ],
+# )
+# # 提取结果文本
+# result_text = " ".join(
+# block.get("text", "")
+# for block in result.content
+# if block.get("type") == "text"
+# )
+# print(f"记录结果: {result_text}")
#
-# 记录结果: Successfully recorded 3 memory/memories to personal memory.
#
-
-
-# %%
# 然后我们使用 ``retrieve_from_memory`` 检索相关记忆。
#
-
-
-async def test_retrieve_from_memory():
- """测试 retrieve_from_memory 工具函数接口"""
- async with reme_long_term_memory:
- # 先记录一些内容
- await reme_long_term_memory.record_to_memory(
- thinking="用户正在分享旅行偏好",
- content=["我去杭州旅行时喜欢住民宿"],
- )
-
- # 然后检索
- result = await reme_long_term_memory.retrieve_from_memory(
- keywords=["杭州旅行", "茶偏好"],
- )
- retrieved_text = " ".join(
- block.get("text", "")
- for block in result.content
- if block.get("type") == "text"
- )
- print(f"检索到的记忆: {retrieved_text}")
-
-
-# %%
-# 输出
-#
-# .. code-block:: console
+# .. code-block:: python
+# :caption: 使用 retrieve_from_memory 检索记忆
+#
+# async def test_retrieve_from_memory():
+# """测试 retrieve_from_memory 工具函数接口"""
+# async with reme_long_term_memory:
+# # 先记录一些内容
+# await reme_long_term_memory.record_to_memory(
+# thinking="用户正在分享旅行偏好",
+# content=["我去杭州旅行时喜欢住民宿"],
+# )
+#
+# # 然后检索
+# result = await reme_long_term_memory.retrieve_from_memory(
+# keywords=["杭州旅行", "茶偏好"],
+# )
+# retrieved_text = " ".join(
+# block.get("text", "")
+# for block in result.content
+# if block.get("type") == "text"
+# )
+# print(f"检索到的记忆: {retrieved_text}")
#
-# 检索到的记忆: Keyword 'Hangzhou travel':
-# user prefers to stay in homestays when traveling to Hangzhou
#
-# Keyword 'tea preference':
-# user prefers to stay in homestays when traveling to Hangzhou
-#
-
-# %%
# 除了工具函数接口,我们也可以使用 ``record`` 方法直接记录消息对话。
#
-
-
-async def test_record_direct():
- """测试 record 直接记录方法"""
- async with reme_long_term_memory:
- await reme_long_term_memory.record(
- msgs=[
- Msg(
- role="user",
- content="我是一名软件工程师,喜欢远程工作",
- name="user",
- ),
- Msg(
- role="assistant",
- content="明白了!您是一名重视远程工作灵活性的软件工程师。",
- name="assistant",
- ),
- Msg(
- role="user",
- content="我通常早上9点开始工作,会先喝一杯咖啡",
- name="user",
- ),
- ],
- )
- print("成功记录了对话消息")
-
-
-# %%
-# 输出
-#
-# .. code-block:: console
+# .. code-block:: python
+# :caption: 使用 record 直接记录消息
+#
+# async def test_record_direct():
+# """测试 record 直接记录方法"""
+# async with reme_long_term_memory:
+# await reme_long_term_memory.record(
+# msgs=[
+# Msg(
+# role="user",
+# content="我是一名软件工程师,喜欢远程工作",
+# name="user",
+# ),
+# Msg(
+# role="assistant",
+# content="明白了!您是一名重视远程工作灵活性的软件工程师。",
+# name="assistant",
+# ),
+# Msg(
+# role="user",
+# content="我通常早上9点开始工作,会先喝一杯咖啡",
+# name="user",
+# ),
+# ],
+# )
+# print("成功记录了对话消息")
#
-# 成功记录了对话消息
#
-
-# %%
# 类似地,我们使用 ``retrieve`` 方法检索相关记忆。
#
-
-
-async def test_retrieve_direct():
- """测试 retrieve 直接检索方法"""
- async with reme_long_term_memory:
- # 先记录一些内容
- await reme_long_term_memory.record(
- msgs=[
- Msg(
- role="user",
- content="我是一名软件工程师,喜欢远程工作",
- name="user",
- ),
- ],
- )
-
- # 然后检索
- memories = await reme_long_term_memory.retrieve(
- msg=Msg(
- role="user",
- content="你知道我的工作偏好吗?",
- name="user",
- ),
- )
- print(f"检索到的记忆: {memories if memories else '未找到相关记忆'}")
-
-
-# %%
-# 输出
+# .. code-block:: python
+# :caption: 使用 retrieve 直接检索消息
+#
+# async def test_retrieve_direct():
+# """测试 retrieve 直接检索方法"""
+# async with reme_long_term_memory:
+# # 先记录一些内容
+# await reme_long_term_memory.record(
+# msgs=[
+# Msg(
+# role="user",
+# content="我是一名软件工程师,喜欢远程工作",
+# name="user",
+# ),
+# ],
+# )
+#
+# # 然后检索
+# memories = await reme_long_term_memory.retrieve(
+# msg=Msg(
+# role="user",
+# content="你知道我的工作偏好吗?",
+# name="user",
+# ),
+# )
+# print(f"检索到的记忆: {memories if memories else '未找到相关记忆'}")
#
-# .. code-block:: console
#
-# 检索到的记忆: user works as a software engineer and prefers remote work
-
-# %%
# 与 ReAct 智能体集成
# ----------------------------------------
# AgentScope 中的 ``ReActAgent`` 在构造函数中包含 ``long_term_memory`` 和 ``long_term_memory_mode`` 两个参数。
@@ -315,132 +281,93 @@ async def test_retrieve_direct():
#
# .. note:: 为了达到最好的效果,``"agent_control"`` 模式可能还需要在系统提示(system prompt)中添加相应的说明。
#
-
-
-# 创建带有长期记忆的 ReAct 智能体(agent_control 模式)
-async def test_react_agent_with_reme():
- """测试 ReActAgent 与 ReMe 个人记忆的集成"""
- async with reme_long_term_memory:
- agent_with_reme = ReActAgent(
- name="Friday",
- sys_prompt=(
- "你是一个名为 Friday 的助手,具有长期记忆能力。"
- "\n\n## 记忆管理指南:\n"
- "1. **记录记忆**:当用户分享个人信息、偏好、习惯或关于自己的事实时,"
- "始终使用 `record_to_memory` 记录这些信息以供将来参考。\n"
- "\n2. **检索记忆**:在回答关于用户偏好、过去信息或个人详细信息的问题之前,"
- "你必须首先调用 `retrieve_from_memory` 来检查是否有任何相关的存储信息。"
- "不要仅依赖当前对话上下文。\n"
- "\n3. **何时检索**:在以下情况下调用 `retrieve_from_memory`:\n"
- " - 用户问类似'我喜欢什么?'、'我的偏好是什么?'、"
- "'你对我了解多少?'的问题\n"
- " - 用户询问他们过去的行为、习惯或偏好\n"
- " - 用户提到他们之前提到的信息\n"
- " - 你需要关于用户的上下文来提供个性化的响应\n"
- "\n在声称不了解用户的某些信息之前,始终先检查你的记忆。"
- ),
- model=DashScopeChatModel(
- model_name="qwen3-max",
- api_key=os.environ.get("DASHSCOPE_API_KEY"),
- stream=False,
- ),
- formatter=DashScopeChatFormatter(),
- toolkit=Toolkit(),
- memory=InMemoryMemory(),
- long_term_memory=reme_long_term_memory,
- long_term_memory_mode="agent_control", # 使用 agent_control 模式
- )
-
- # 用户分享偏好
- msg = Msg(
- role="user",
- content="我去杭州旅行时,喜欢住民宿",
- name="user",
- )
- response = await agent_with_reme(msg)
- print(f"智能体响应: {response.get_text_content()}")
-
- # 清空短期记忆以测试长期记忆
- await agent_with_reme.memory.clear()
-
- # 查询偏好
- msg2 = Msg(role="user", content="我有什么偏好?", name="user")
- response2 = await agent_with_reme(msg2)
- print(f"智能体响应: {response2.get_text_content()}")
-
-
-# %%
-# 输出
-#
-# .. code-block:: console
+# .. code-block:: python
+# :caption: 创建带有长期记忆的 ReAct 智能体
+#
+# # 创建带有长期记忆的 ReAct 智能体(agent_control 模式)
+# async def test_react_agent_with_reme():
+# """测试 ReActAgent 与 ReMe 个人记忆的集成"""
+# async with reme_long_term_memory:
+# agent_with_reme = ReActAgent(
+# name="Friday",
+# sys_prompt=(
+# "你是一个名为 Friday 的助手,具有长期记忆能力。"
+# "\n\n## 记忆管理指南:\n"
+# "1. **记录记忆**:当用户分享个人信息、偏好、习惯或关于自己的事实时,"
+# "始终使用 `record_to_memory` 记录这些信息以供将来参考。\n"
+# "\n2. **检索记忆**:在回答关于用户偏好、过去信息或个人详细信息的问题之前,"
+# "你必须首先调用 `retrieve_from_memory` 来检查是否有任何相关的存储信息。"
+# "不要仅依赖当前对话上下文。\n"
+# "\n3. **何时检索**:在以下情况下调用 `retrieve_from_memory`:\n"
+# " - 用户问类似'我喜欢什么?'、'我的偏好是什么?'、"
+# "'你对我了解多少?'的问题\n"
+# " - 用户询问他们过去的行为、习惯或偏好\n"
+# " - 用户提到他们之前提到的信息\n"
+# " - 你需要关于用户的上下文来提供个性化的响应\n"
+# "\n在声称不了解用户的某些信息之前,始终先检查你的记忆。"
+# ),
+# model=DashScopeChatModel(
+# model_name="qwen3-max",
+# api_key=os.environ.get("DASHSCOPE_API_KEY"),
+# stream=False,
+# ),
+# formatter=DashScopeChatFormatter(),
+# toolkit=Toolkit(),
+# memory=InMemoryMemory(),
+# long_term_memory=reme_long_term_memory,
+# long_term_memory_mode="agent_control", # 使用 agent_control 模式
+# )
+#
+# # 用户分享偏好
+# msg = Msg(
+# role="user",
+# content="我去杭州旅行时,喜欢住民宿",
+# name="user",
+# )
+# response = await agent_with_reme(msg)
+# print(f"智能体响应: {response.get_text_content()}")
+#
+# # 清空短期记忆以测试长期记忆
+# await agent_with_reme.memory.clear()
+#
+# # 查询偏好
+# msg2 = Msg(role="user", content="我有什么偏好?", name="user")
+# response2 = await agent_with_reme(msg2)
+# print(f"智能体响应: {response2.get_text_content()}")
#
-# system: {
-# "type": "tool_result",
-# "id": "call_7de95a3382e241309b16cb9e",
-# "name": "retrieve_from_memory",
-# "output": [
-# {
-# "type": "text",
-# "text": "Keyword 'preference':\nuser prefers to stay in a homestay when traveling to Hangzhou"
-# }
-# ]
-# }
-# Friday: Based on what I know, you prefer to stay in a homestay when traveling to Hangzhou. Let me know if there's anything else you'd like me to remember or clarify!
-# Agent response: Based on what I know, you prefer to stay in a homestay when traveling to Hangzhou. Let me know if there's anything else you'd like me to remember or clarify!
#
-
-# %%
# 然后我们清空智能体的短期记忆,以避免造成干扰,并测试智能体是否会记住之前的对话。
#
-
-
-async def retrieve_reme_preferences():
- """从长期记忆中检索用户偏好"""
- async with reme_long_term_memory:
- # 创建智能体(这里可以复用之前创建的智能体,为了示例完整性重新创建)
- agent_with_reme = ReActAgent(
- name="Friday",
- sys_prompt="你是一个具有长期记忆功能的助手。",
- model=DashScopeChatModel(
- api_key=os.environ.get("DASHSCOPE_API_KEY"),
- model_name="qwen3-max",
- stream=False,
- ),
- formatter=DashScopeChatFormatter(),
- toolkit=Toolkit(),
- memory=InMemoryMemory(),
- long_term_memory=reme_long_term_memory,
- long_term_memory_mode="agent_control",
- )
-
- # 我们清空智能体的短期记忆,以避免造成干扰
- await agent_with_reme.memory.clear()
-
- # 测试智能体是否会记住之前的对话
- msg2 = Msg("user", "我有什么偏好?简要的回答我", "user")
- await agent_with_reme(msg2)
-
-
-# %%
-# 输出
-#
-# .. code-block:: console
+# .. code-block:: python
+# :caption: 测试 ReAct 智能体是否记住偏好
+#
+# async def retrieve_reme_preferences():
+# """从长期记忆中检索用户偏好"""
+# async with reme_long_term_memory:
+# # 创建智能体(这里可以复用之前创建的智能体,为了示例完整性重新创建)
+# agent_with_reme = ReActAgent(
+# name="Friday",
+# sys_prompt="你是一个具有长期记忆功能的助手。",
+# model=DashScopeChatModel(
+# api_key=os.environ.get("DASHSCOPE_API_KEY"),
+# model_name="qwen3-max",
+# stream=False,
+# ),
+# formatter=DashScopeChatFormatter(),
+# toolkit=Toolkit(),
+# memory=InMemoryMemory(),
+# long_term_memory=reme_long_term_memory,
+# long_term_memory_mode="agent_control",
+# )
+#
+# # 我们清空智能体的短期记忆,以避免造成干扰
+# await agent_with_reme.memory.clear()
+#
+# # 测试智能体是否会记住之前的对话
+# msg2 = Msg("user", "我有什么偏好?简要的回答我", "user")
+# await agent_with_reme(msg2)
#
-# system: {
-# "type": "tool_result",
-# "id": "call_e7d354e450684ceca331a8d9",
-# "name": "retrieve_from_memory",
-# "output": [
-# {
-# "type": "text",
-# "text": "No memories found for the given keywords."
-# }
-# ]
-# }
-# Friday: I don't have any recorded information about your preferences yet. Let me know what you like or need, and I can remember it for future reference!
#
-
-# %%
# 自定义长期记忆
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# AgentScope 提供了 ``LongTermMemoryBase`` 基类,它定义了长期记忆的基本接口。
diff --git a/src/agentscope/agent/_react_agent.py b/src/agentscope/agent/_react_agent.py
index 39d8831f7..f221b1f2a 100644
--- a/src/agentscope/agent/_react_agent.py
+++ b/src/agentscope/agent/_react_agent.py
@@ -488,6 +488,11 @@ class ReActAgent(ReActAgentBase):
):
await self.print(tool_res_msg, chunk.is_last)
+ # Raise the CancelledError to handle the interruption in the
+ # handle_interrupt function
+ if chunk.is_interrupted:
+ raise asyncio.CancelledError()
+
# Return message if generate_response is called successfully
if (
tool_call["name"] == self.finish_function_name
@@ -562,7 +567,10 @@ class ReActAgent(ReActAgentBase):
"I noticed that you have interrupted me. What can I "
"do for you?",
"assistant",
- metadata={},
+ metadata={
+ # Expose this field to indicate the interruption
+ "is_interrupted": True,
+ },
)
await self.print(response_msg, True)