Agent: loop avoid

Author: JohnRichard4096

docs/guide/api-reference/classes/AgentRuntime.md

@@ -19,7 +19,7 @@ This class encapsulates the complexity of ChatObject and provides a simplified A
 
 - `config` ([AmritaConfig](AmritaConfig.md)): Amrita configuration object containing global configuration settings
 - `preset` ([ModelPreset](ModelPreset.md)): Model preset configuration defining basic model parameters and settings
-- `strategy` (type[AgentStrategy], optional): Agent strategy class, defaults to AmritaAgentStrategy
+- `strategy` (type[AgentStrategy], optional): Agent strategy class, defaults to ReActAgentStrategy
 - `template` (Template | str, optional): Train template to render system role message, defaults to DEFAULT_TEMPLATE
 - `session` (SessionData | str | None, optional): Session data or session ID string for restoring existing sessions. If None, a new session will be created
 - `train` (dict[str, str] | Message[str] | None, optional): Training data (system prompts), can be in dictionary format or as a Message object

docs/guide/api-reference/classes/ChatObject.md

@@ -40,7 +40,7 @@ The ChatObject class is the primary interface for conversations with the AI.
 - `auto_create_session` (bool): Whether to automatically create a session if it does not exist (default: False)
 - `train_template` (Template): Jinja2 template used to format system message (default: DEFAULT_TEMPLATE)
 - `jinja2_vars` (dict[str, Any] | None): Variables to be passed to the template system for custom template variables (default: None). **Important**: Keys in this dictionary must NOT match built-in variable names (`train`, `memory`, `chatobj`, `config`) as this would cause a TypeError due to duplicate keyword arguments.
-- `agent_strategy` (type[AgentStrategy]): Agent strategy to be used for execution (default: AmritaAgentStrategy)
+- `agent_strategy` (type[AgentStrategy]): Agent strategy to be used for execution (default: ReActAgentStrategy)
 - `hook_args` (tuple[Any, ...]): Positional arguments passed to event handlers when events are triggered (default: empty tuple)
 - `hook_kwargs` (dict[str, Any] | None): Keyword arguments passed to event handlers when events are triggered (default: None)
 - `exception_ignored` (tuple[type[BaseException], ...]): Exception types that should be ignored and raised again in event handlers (default: empty tuple)

…reference/classes/AmritaAgentStrategy.md …-reference/classes/ReActAgentStrategy.mddocs/guide/api-reference/classes/AmritaAgentStrategy.md renamed to docs/guide/api-reference/classes/ReActAgentStrategy.md docs/guide/api-reference/classes/AmritaAgentStrategy.md renamed to docs/guide/api-reference/classes/ReActAgentStrategy.md

@@ -1,6 +1,6 @@
-# AmritaAgentStrategy
+# ReActAgentStrategy
 
-The AmritaAgentStrategy is a strategy for executing an agent in RAG and Agent mode.
+The ReActAgentStrategy is a strategy for executing an agent in RAG and Agent mode.
 
 This strategy implements the 'agent-mixed' category, allowing it to dynamically handle both retrieval-augmented generation scenarios and standard iterative tool calling agents within the same execution framework.
 
@@ -56,7 +56,7 @@ The 'agent-mixed' category allows the strategy to dynamically handle both retrie
 
 ```python
 from amrita_core.agent.context import StrategyContext
-from amrita_core.builtins.agent import AmritaAgentStrategy
+from amrita_core.builtins.agent import ReActAgentStrategy
 
 # Create strategy context
 ctx = StrategyContext(
@@ -66,6 +66,6 @@ ctx = StrategyContext(
 )
 
 # Create and use the strategy
-strategy = AmritaAgentStrategy(ctx)
+strategy = ReActAgentStrategy(ctx)
 should_continue = await strategy.single_execute()
 ```

docs/guide/builtins.md

@@ -75,9 +75,9 @@ AmritaCore provides built-in adapters for multiple LLM providers, implementing t
 
 AmritaCore includes a comprehensive intelligent agent system capable of autonomously using tools to complete tasks.
 
-### 9.3.1 AmritaAgentStrategy
+### 9.3.1 ReActAgentStrategy
 
-The `AmritaAgentStrategy` is the built-in agent strategy that implements the `"agent-mixed"` category, supporting both retrieval-augmented generation (RAG) and iterative tool calling within the same execution framework.
+The `ReActAgentStrategy` is the built-in agent strategy that implements the `"agent-mixed"` category, supporting both retrieval-augmented generation (RAG) and iterative tool calling within the same execution framework.
 
 **Key Features**:
 

docs/guide/concepts/agent-strategy.md

@@ -76,12 +76,12 @@ class MyCustomAgentStrategy(AgentStrategy):
 
 ### Using Built-in Strategies
 
-AmritaCore provides the `AmritaAgentStrategy` as a built-in implementation that supports the `"agent-mixed"` category:
+AmritaCore provides the `ReActAgentStrategy` as a built-in implementation that supports the `"agent-mixed"` category:
 
 ```python
 import asyncio
 from amrita_core import create_agent, minimal_init
-from amrita_core.builtins.agent import AmritaAgentStrategy
+from amrita_core.builtins.agent import ReActAgentStrategy
 
 async def use_builtin_strategy():
     # Initialize AmritaCore
@@ -91,7 +91,7 @@ async def use_builtin_strategy():
     agent = create_agent(
         url="https://api.example.com",
         key="your-api-key",
-        strategy=AmritaAgentStrategy
+        strategy=ReActAgentStrategy
     )
 
     # Use the agent
@@ -119,7 +119,7 @@ The `StrategyContext` provides all necessary information for strategy execution:
 1. **Choose the Right Category**: Select the strategy category that best matches your use case
 2. **Leverage Framework Features**: Use built-in features like tool calling limits, error handling, and response streaming
 3. **Handle Errors Gracefully**: Implement proper error handling in your strategy methods
-4. **Use Built-in Strategies When Possible**: Start with `AmritaAgentStrategy` before creating custom implementations
+4. **Use Built-in Strategies When Possible**: Start with `ReActAgentStrategy` before creating custom implementations
 5. **Test Thoroughly**: Ensure your strategy handles edge cases and error conditions properly
 
 ## Example: Custom RAG Strategy

docs/zh/guide/api-reference/classes/AgentRuntime.md

@@ -19,7 +19,7 @@ AgentRuntime 类是 ChatObject 的高级包装器，提供可重用的 agent 操
 
 - `config` ([AmritaConfig](AmritaConfig.md)): 包含全局配置设置的 Amrita 配置对象
 - `preset` ([ModelPreset](ModelPreset.md)): 定义基本模型参数和设置的模型预设配置
-- `strategy` (type[AgentStrategy], 可选): agent 策略类，默认为 AmritaAgentStrategy
+- `strategy` (type[AgentStrategy], 可选): agent 策略类，默认为 ReActAgentStrategy
 - `template` (Template | str, 可选): 用于渲染系统角色消息的训练模板，默认为 DEFAULT_TEMPLATE
 - `session` (SessionData | str | None, 可选): 用于恢复现有会话的会话数据或会话 ID 字符串。如果为 None，则会创建新会话
 - `train` (dict[str, str] | Message[str] | None, 可选): 训练数据（系统提示），可以是字典格式或 Message 对象

docs/zh/guide/api-reference/classes/ChatObject.md

@@ -40,7 +40,7 @@ ChatObject 类是与 AI 进行对话的主要接口。
 - `auto_create_session` (bool): 如果会话不存在，是否自动创建（默认：False）
 - `train_template` (Template): 用于格式化系统消息的 Jinja2 模板（默认：DEFAULT_TEMPLATE）
 - `jinja2_vars` (dict[str, Any] | None): 传递给模板系统的变量，用于自定义模板变量（默认：None）。**重要**：此字典中的键必须 NOT 与内置变量名（`train`、`memory`、`chatobj`、`config`）匹配，否则会导致 TypeError，因为重复的关键字参数在 Python 中是不允许的。
-- `agent_strategy` (type[AgentStrategy]): 用于执行的 Agent 策略（默认：AmritaAgentStrategy）
+- `agent_strategy` (type[AgentStrategy]): 用于执行的 Agent 策略（默认：ReActAgentStrategy）
 - `hook_args` (tuple[Any, ...]): 触发事件时传递给事件处理器的位置参数（默认：空元组）
 - `hook_kwargs` (dict[str, Any] | None): 触发事件时传递给事件处理器的关键字参数（默认：None）
 - `exception_ignored` (tuple[type[BaseException], ...]): 在事件处理器中应该被忽略并重新抛出的异常类型（默认：空元组）

…reference/classes/AmritaAgentStrategy.md …-reference/classes/ReActAgentStrategy.mddocs/zh/guide/api-reference/classes/AmritaAgentStrategy.md renamed to docs/zh/guide/api-reference/classes/ReActAgentStrategy.md docs/zh/guide/api-reference/classes/AmritaAgentStrategy.md renamed to docs/zh/guide/api-reference/classes/ReActAgentStrategy.md

@@ -1,6 +1,6 @@
-# AmritaAgentStrategy
+# ReActAgentStrategy
 
-AmritaAgentStrategy 是用于在 RAG 和 Agent 模式下执行 agent 的策略。
+ReActAgentStrategy 是用于在 RAG 和 Agent 模式下执行 agent 的策略。
 
 该策略实现了 'agent-mixed' 类别，允许在同一执行框架内动态处理检索增强生成场景和标准迭代工具调用 agent。
 
@@ -56,7 +56,7 @@ AmritaAgentStrategy 是用于在 RAG 和 Agent 模式下执行 agent 的策略
 
 ```python
 from amrita_core.agent.context import StrategyContext
-from amrita_core.builtins.agent import AmritaAgentStrategy
+from amrita_core.builtins.agent import ReActAgentStrategy
 
 # 创建策略上下文
 ctx = StrategyContext(
@@ -66,6 +66,6 @@ ctx = StrategyContext(
 )
 
 # 创建并使用策略
-strategy = AmritaAgentStrategy(ctx)
+strategy = ReActAgentStrategy(ctx)
 should_continue = await strategy.single_execute()
 ```

docs/zh/guide/builtins.md

@@ -75,9 +75,9 @@ AmritaCore 提供了多个LLM提供商的内置适配器，实现了 `ModelAdapt
 
 AmritaCore 包含一个全面的智能体系统，能够自主使用工具完成任务。
 
-### 9.3.1 AmritaAgentStrategy
+### 9.3.1 ReActAgentStrategy
 
-`AmritaAgentStrategy` 是内置的Agent策略，实现了 `"agent-mixed"` 类别，支持在同一执行框架内同时处理检索增强生成（RAG）和迭代工具调用。
+`ReActAgentStrategy` 是内置的Agent策略，实现了 `"agent-mixed"` 类别，支持在同一执行框架内同时处理检索增强生成（RAG）和迭代工具调用。
 
 **关键特性**：
 

docs/zh/guide/concepts/agent-strategy.md

@@ -76,12 +76,12 @@ class MyCustomAgentStrategy(AgentStrategy):
 
 ### 使用内置策略
 
-AmritaCore 提供了 `AmritaAgentStrategy` 作为内置实现，支持 `"agent-mixed"` 类别：
+AmritaCore 提供了 `ReActAgentStrategy` 作为内置实现，支持 `"agent-mixed"` 类别：
 
 ```python
 import asyncio
 from amrita_core import create_agent, minimal_init
-from amrita_core.builtins.agent import AmritaAgentStrategy
+from amrita_core.builtins.agent import ReActAgentStrategy
 
 async def use_builtin_strategy():
     # 初始化 AmritaCore
@@ -91,7 +91,7 @@ async def use_builtin_strategy():
     agent = create_agent(
         url="https://api.example.com",
         key="your-api-key",
-        strategy=AmritaAgentStrategy
+        strategy=ReActAgentStrategy
     )
 
     # 使用 agent
@@ -119,7 +119,7 @@ if __name__ == "__main__":
 1. **选择正确的类别**: 选择最适合您用例的策略类别
 2. **利用框架功能**: 使用内置功能如工具调用限制、错误处理和响应流
 3. **优雅地处理错误**: 在策略方法中实现适当的错误处理
-4. **尽可能使用内置策略**: 在创建自定义实现之前，先从 `AmritaAgentStrategy` 开始
+4. **尽可能使用内置策略**: 在创建自定义实现之前，先从 `ReActAgentStrategy` 开始
 5. **彻底测试**: 确保您的策略能正确处理边缘情况和错误条件
 
 ## 示例：自定义 RAG 策略