rootdriver 0.2.0__tar.gz → 0.3.0__tar.gz

{rootdriver-0.2.0/rootdriver.egg-info → rootdriver-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rootdriver
-Version: 0.2.0
+Version: 0.3.0
 Summary: Rooted in Origin, Driving All Things
 Author-email: zimvir <zimvir@qq.com>
 License: MIT
@@ -24,6 +24,7 @@ Requires-Dist: pytest>=7.0.0; extra == "dev"
 - **工具调用**：支持 function calling，自动执行工具并返回结果
 - **状态管理**：支持内存和数据库持久化检查点
 - **异常体系**：完整的异常类层次结构
+- **异步支持**：全面异步支持，并发多 Agent / 工具调用
 
 ## 安装
 
@@ -74,6 +75,29 @@ response = agent.react("帮我查下上海天气")
 print(response)
 ```
 
+### 异步用法
+
+```python
+import asyncio
+from rootdriver import Agent, AgentLLM, OpenAIAdapter
+
+async def main():
+    agent = Agent(agent_llm=AgentLLM(...))
+
+    # 单次异步对话
+    response = await agent.atalk("你好")
+    print(response)
+
+    # 并发多个 Agent
+    results = await asyncio.gather(
+        agent.areact("问题1"),
+        agent.areact("问题2"),
+        agent.areact("问题3"),
+    )
+
+asyncio.run(main())
+```
+
 ## 核心组件
 
 | 组件 | 说明 |

rootdriver-0.2.0/PKG-INFO → rootdriver-0.3.0/README.md

@@ -1,111 +1,122 @@
-Metadata-Version: 2.4
-Name: rootdriver
-Version: 0.2.0
-Summary: Rooted in Origin, Driving All Things
-Author-email: zimvir <zimvir@qq.com>
-License: MIT
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-Requires-Dist: openai>=1.0.0
-Requires-Dist: pydantic>=2.0.0
-Provides-Extra: dev
-Requires-Dist: pytest>=7.0.0; extra == "dev"
-
-# RootDriver
-
-根源出发，驱动万物
-
-一个轻量级的 Python AI Agent 开发框架，支持单智能体和多智能体应用。
-
-## 特性
-
-- **简洁易用**：装饰器方式定义工具，快速构建 Agent
-- **模块化设计**：LLM 适配器、工具系统、会话管理解耦
-- **工具调用**：支持 function calling，自动执行工具并返回结果
-- **状态管理**：支持内存和数据库持久化检查点
-- **异常体系**：完整的异常类层次结构
-
-## 安装
-
-```bash
-pip install rootdriver
-```
-
-## 快速开始
-
-### 定义工具
-
-```python
-from rootdriver import tool
-
-@tool
-def get_weather(city: str) -> str:
-    """获取城市天气"""
-    return f"{city} 晴天"
-```
-
-### 创建 Agent
-
-```python
-from rootdriver import Agent, AgentLLM, OpenAIAdapter
-
-agent = Agent(
-    agent_llm=AgentLLM(
-        adapter=OpenAIAdapter(
-            api_key="YOUR_API_KEY",
-            base_url="BASE_URL"
-        ),
-        model="gpt-4",
-    ),
-    tools=[get_weather],
-    system_prompt="你是一个有用的助手",
-)
-
-# 单次对话
-response = agent.talk("北京天气怎么样？")
-print(response)
-```
-
-### 使用工具
-
-```python
-# 完整对话循环（包含工具调用）
-response = agent.react("帮我查下上海天气")
-print(response)
-```
-
-## 核心组件
-
-| 组件 | 说明 |
-|------|------|
-| `Agent` | 智能体入口，整合 LLM、工具、会话 |
-| `Engine` | 核心引擎，处理对话循环和工具调用 |
-| `Conversation` | 会话管理，维护消息历史 |
-| `LLM` | LLM 调用封装 |
-| `Tool` | 工具集合，管理所有可调用工具 |
-| `State` | 状态管理，支持检查点和持久化 |
-
-## 项目结构
-
-```
-rootdriver/
-├── agent.py           # Agent 智能体
-├── engine.py          # 引擎核心
-├── conversation.py    # 对话管理
-├── state.py           # 状态管理
-├── exception.py       # 异常定义
-├── llm/
-│   ├── llm.py         # LLM 封装
-│   ├── base_adapter.py    # 适配器基类
-│   └── adapter/
-│       └── openai_adapter.py  # OpenAI 适配器
-├── tool/
-│   ├── base_tool.py   # 工具基类
-│   └── tools.py       # 工具集
-├── types/             # 类型定义
-└── utils/             # 工具函数
-```
-
-## License
-
-MIT
+# RootDriver
+
+根源出发，驱动万物
+
+一个轻量级的 Python AI Agent 开发框架，支持单智能体和多智能体应用。
+
+## 特性
+
+- **简洁易用**：装饰器方式定义工具，快速构建 Agent
+- **模块化设计**：LLM 适配器、工具系统、会话管理解耦
+- **工具调用**：支持 function calling，自动执行工具并返回结果
+- **状态管理**：支持内存和数据库持久化检查点
+- **异常体系**：完整的异常类层次结构
+- **异步支持**：全面异步支持，并发多 Agent / 工具调用
+
+## 安装
+
+```bash
+pip install rootdriver
+```
+
+## 快速开始
+
+### 定义工具
+
+```python
+from rootdriver import tool
+
+@tool
+def get_weather(city: str) -> str:
+    """获取城市天气"""
+    return f"{city} 晴天"
+```
+
+### 创建 Agent
+
+```python
+from rootdriver import Agent, AgentLLM, OpenAIAdapter
+
+agent = Agent(
+    agent_llm=AgentLLM(
+        adapter=OpenAIAdapter(
+            api_key="YOUR_API_KEY",
+            base_url="BASE_URL"
+        ),
+        model="gpt-4",
+    ),
+    tools=[get_weather],
+    system_prompt="你是一个有用的助手",
+)
+
+# 单次对话
+response = agent.talk("北京天气怎么样？")
+print(response)
+```
+
+### 使用工具
+
+```python
+# 完整对话循环（包含工具调用）
+response = agent.react("帮我查下上海天气")
+print(response)
+```
+
+### 异步用法
+
+```python
+import asyncio
+from rootdriver import Agent, AgentLLM, OpenAIAdapter
+
+async def main():
+    agent = Agent(agent_llm=AgentLLM(...))
+
+    # 单次异步对话
+    response = await agent.atalk("你好")
+    print(response)
+
+    # 并发多个 Agent
+    results = await asyncio.gather(
+        agent.areact("问题1"),
+        agent.areact("问题2"),
+        agent.areact("问题3"),
+    )
+
+asyncio.run(main())
+```
+
+## 核心组件
+
+| 组件 | 说明 |
+|------|------|
+| `Agent` | 智能体入口，整合 LLM、工具、会话 |
+| `Engine` | 核心引擎，处理对话循环和工具调用 |
+| `Conversation` | 会话管理，维护消息历史 |
+| `LLM` | LLM 调用封装 |
+| `Tool` | 工具集合，管理所有可调用工具 |
+| `State` | 状态管理，支持检查点和持久化 |
+
+## 项目结构
+
+```
+rootdriver/
+├── agent.py           # Agent 智能体
+├── engine.py          # 引擎核心
+├── conversation.py    # 对话管理
+├── state.py           # 状态管理
+├── exception.py       # 异常定义
+├── llm/
+│   ├── llm.py         # LLM 封装
+│   ├── base_adapter.py    # 适配器基类
+│   └── adapter/
+│       └── openai_adapter.py  # OpenAI 适配器
+├── tool/
+│   ├── base_tool.py   # 工具基类
+│   └── tools.py       # 工具集
+├── types/             # 类型定义
+└── utils/             # 工具函数
+```
+
+## License
+
+MIT

{rootdriver-0.2.0 → rootdriver-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rootdriver"
-version = "0.2.0"
+version = "0.3.0"
 description = "Rooted in Origin, Driving All Things"
 readme = "README.md"
 license = {text = "MIT"}
@@ -22,5 +22,8 @@ dev = [
     "pytest>=7.0.0",
 ]
 
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
 [tool.setuptools]
 packages = ["rootdriver"]

{rootdriver-0.2.0 → rootdriver-0.3.0}/rootdriver/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 __author__ = "zimvir"
 __email__ = "zimvir@qq.com"
 

{rootdriver-0.2.0 → rootdriver-0.3.0}/rootdriver/agent.py

@@ -1,6 +1,6 @@
 from pathlib import Path
 from uuid import uuid4
-
+import asyncio
 from .engine import Engine
 from .llm import LLM
 from .conversation import Conversation
@@ -19,7 +19,7 @@ class Agent:
         system_prompt: str | None = None,
 
         db_path: str| None = None,
-        # retry: int = 3,
+        # llm_retry: int = 3,
         # timeout: float | None = None,
     ):
         self.id = id if id else uuid4().hex
@@ -47,4 +47,15 @@ class Agent:
         return self.engine.invoke(build_user_message(input_prompt)).content
 
 
+    """==========异步部分=========="""
+    async def areact(self, input_prompt:str) -> "str":
+        """一次 react 异步循环"""
+        response = await self.engine.arun(build_user_message(input_prompt))
+        return response.content
+
+    async def atalk(self, input_prompt:str) -> "str":
+        """一次 agent 异步调用"""
+        return await self.engine.ainvoke(build_user_message(input_prompt)).content
+
+
 

{rootdriver-0.2.0 → rootdriver-0.3.0}/rootdriver/engine.py

@@ -1,4 +1,4 @@
-
+import asyncio
 
 from .llm import LLM
 from .conversation import Conversation
@@ -14,18 +14,16 @@ class Engine:
         self.model = model
 
     def invoke(self, input_message:Message) -> Message:
+        """但系调用llm，并存入记忆，无tool调用"""
         self.conversation.append(input_message)
         message = self.chat()
         return message
 
     def chat(self) -> Message:
         """
-
         1. 读会话消息
         2. 大模型交流
         3. 追加会话消息
-        4. 判断 是否调用工具
-        5. 是： tool 返回结果并追加，否： 追加并返回
         """
         # 1. 读会话消息
         message = self.conversation.get_messages()
@@ -41,17 +39,9 @@ class Engine:
 
     def deal_tool_or_output(self, response_message:Message) -> Message|None:
         """
-                1. 追加输入
-                2. 读会话消息
-                3. 大模型交流
-                4. 追加会话消息
-                5. 判断 是否调用工具
-                6. 是： tool 返回结果并追加，否： 追加并返回
-
-
-                Returns:
-
-                """
+        5. 判断 是否调用工具
+        6. 是： tool 返回结果并追加，否： 追加并返回
+        """
 
         # 5. 判断 是否调用工具
         if response_message.tool_calls:
@@ -106,3 +96,68 @@ class Engine:
         """把 LLM 响应转成 Message 。"""
         return response.message
 
+    """==========异步部分=========="""
+    async def ainvoke(self, input_message:Message) -> Message:
+        """但系调用llm，并存入记忆，无tool调用"""
+        self.conversation.append(input_message)
+        message = await self.achat()
+        return message
+
+
+    async def achat(self) -> Message:
+        """
+        1. 读会话消息
+        2. 大模型交流
+        3. 追加会话消息
+        """
+        # 1. 读会话消息
+        message = self.conversation.get_messages()
+
+        # 2. llm交互
+        response = await self.llm.ainvoke(self.messages_to_llm_request(message))
+
+        # 3. 追加会话消息
+        response_message = self.llm_response_to_message(response)
+        self.conversation.append(response_message)
+
+        return response_message
+
+    async def adeal_tool_or_output(self, response_message:Message) -> Message|None:
+        """
+        5. 判断 是否调用工具
+        6. 是： tool 返回结果并追加，否： 追加并返回
+        """
+
+        # 5. 判断 是否调用工具
+        if response_message.tool_calls:
+            # 6. 是： tool 返回结果追加
+            tool_results = await self.tool.ainvoke_many(response_message.tool_calls)
+            self.conversation.append_many([build_tool_message(tool_result.tool_call_id, tool_result.content) for tool_result in tool_results])
+            return None
+        else:
+            # 6. 否： 追加并返回
+            return response_message
+
+
+    async def arun(self, input_message:Message) ->Message:
+        """
+        1. 追加输入
+        2. 读会话消息
+        3. 大模型交流
+        4. 追加会话消息
+        5. 判断 是否调用工具
+        6. 是： tool 返回结果并追加，否： 追加并返回
+
+
+        Returns:
+
+        """
+        self.conversation.append(input_message)
+        while True:
+
+            response_message = await self.achat()
+            result = await self.adeal_tool_or_output(response_message)
+            if result is None:
+                continue
+            elif isinstance(result, Message):
+                return result

rootdriver-0.2.0/README.md → rootdriver-0.3.0/rootdriver.egg-info/PKG-INFO

@@ -1,98 +1,135 @@
-# RootDriver
-
-根源出发，驱动万物
-
-一个轻量级的 Python AI Agent 开发框架，支持单智能体和多智能体应用。
-
-## 特性
-
-- **简洁易用**：装饰器方式定义工具，快速构建 Agent
-- **模块化设计**：LLM 适配器、工具系统、会话管理解耦
-- **工具调用**：支持 function calling，自动执行工具并返回结果
-- **状态管理**：支持内存和数据库持久化检查点
-- **异常体系**：完整的异常类层次结构
-
-## 安装
-
-```bash
-pip install rootdriver
-```
-
-## 快速开始
-
-### 定义工具
-
-```python
-from rootdriver import tool
-
-@tool
-def get_weather(city: str) -> str:
-    """获取城市天气"""
-    return f"{city} 晴天"
-```
-
-### 创建 Agent
-
-```python
-from rootdriver import Agent, AgentLLM, OpenAIAdapter
-
-agent = Agent(
-    agent_llm=AgentLLM(
-        adapter=OpenAIAdapter(
-            api_key="YOUR_API_KEY",
-            base_url="BASE_URL"
-        ),
-        model="gpt-4",
-    ),
-    tools=[get_weather],
-    system_prompt="你是一个有用的助手",
-)
-
-# 单次对话
-response = agent.talk("北京天气怎么样？")
-print(response)
-```
-
-### 使用工具
-
-```python
-# 完整对话循环（包含工具调用）
-response = agent.react("帮我查下上海天气")
-print(response)
-```
-
-## 核心组件
-
-| 组件 | 说明 |
-|------|------|
-| `Agent` | 智能体入口，整合 LLM、工具、会话 |
-| `Engine` | 核心引擎，处理对话循环和工具调用 |
-| `Conversation` | 会话管理，维护消息历史 |
-| `LLM` | LLM 调用封装 |
-| `Tool` | 工具集合，管理所有可调用工具 |
-| `State` | 状态管理，支持检查点和持久化 |
-
-## 项目结构
-
-```
-rootdriver/
-├── agent.py           # Agent 智能体
-├── engine.py          # 引擎核心
-├── conversation.py    # 对话管理
-├── state.py           # 状态管理
-├── exception.py       # 异常定义
-├── llm/
-│   ├── llm.py         # LLM 封装
-│   ├── base_adapter.py    # 适配器基类
-│   └── adapter/
-│       └── openai_adapter.py  # OpenAI 适配器
-├── tool/
-│   ├── base_tool.py   # 工具基类
-│   └── tools.py       # 工具集
-├── types/             # 类型定义
-└── utils/             # 工具函数
-```
-
-## License
-
-MIT
+Metadata-Version: 2.4
+Name: rootdriver
+Version: 0.3.0
+Summary: Rooted in Origin, Driving All Things
+Author-email: zimvir <zimvir@qq.com>
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: openai>=1.0.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+
+# RootDriver
+
+根源出发，驱动万物
+
+一个轻量级的 Python AI Agent 开发框架，支持单智能体和多智能体应用。
+
+## 特性
+
+- **简洁易用**：装饰器方式定义工具，快速构建 Agent
+- **模块化设计**：LLM 适配器、工具系统、会话管理解耦
+- **工具调用**：支持 function calling，自动执行工具并返回结果
+- **状态管理**：支持内存和数据库持久化检查点
+- **异常体系**：完整的异常类层次结构
+- **异步支持**：全面异步支持，并发多 Agent / 工具调用
+
+## 安装
+
+```bash
+pip install rootdriver
+```
+
+## 快速开始
+
+### 定义工具
+
+```python
+from rootdriver import tool
+
+@tool
+def get_weather(city: str) -> str:
+    """获取城市天气"""
+    return f"{city} 晴天"
+```
+
+### 创建 Agent
+
+```python
+from rootdriver import Agent, AgentLLM, OpenAIAdapter
+
+agent = Agent(
+    agent_llm=AgentLLM(
+        adapter=OpenAIAdapter(
+            api_key="YOUR_API_KEY",
+            base_url="BASE_URL"
+        ),
+        model="gpt-4",
+    ),
+    tools=[get_weather],
+    system_prompt="你是一个有用的助手",
+)
+
+# 单次对话
+response = agent.talk("北京天气怎么样？")
+print(response)
+```
+
+### 使用工具
+
+```python
+# 完整对话循环（包含工具调用）
+response = agent.react("帮我查下上海天气")
+print(response)
+```
+
+### 异步用法
+
+```python
+import asyncio
+from rootdriver import Agent, AgentLLM, OpenAIAdapter
+
+async def main():
+    agent = Agent(agent_llm=AgentLLM(...))
+
+    # 单次异步对话
+    response = await agent.atalk("你好")
+    print(response)
+
+    # 并发多个 Agent
+    results = await asyncio.gather(
+        agent.areact("问题1"),
+        agent.areact("问题2"),
+        agent.areact("问题3"),
+    )
+
+asyncio.run(main())
+```
+
+## 核心组件
+
+| 组件 | 说明 |
+|------|------|
+| `Agent` | 智能体入口，整合 LLM、工具、会话 |
+| `Engine` | 核心引擎，处理对话循环和工具调用 |
+| `Conversation` | 会话管理，维护消息历史 |
+| `LLM` | LLM 调用封装 |
+| `Tool` | 工具集合，管理所有可调用工具 |
+| `State` | 状态管理，支持检查点和持久化 |
+
+## 项目结构
+
+```
+rootdriver/
+├── agent.py           # Agent 智能体
+├── engine.py          # 引擎核心
+├── conversation.py    # 对话管理
+├── state.py           # 状态管理
+├── exception.py       # 异常定义
+├── llm/
+│   ├── llm.py         # LLM 封装
+│   ├── base_adapter.py    # 适配器基类
+│   └── adapter/
+│       └── openai_adapter.py  # OpenAI 适配器
+├── tool/
+│   ├── base_tool.py   # 工具基类
+│   └── tools.py       # 工具集
+├── types/             # 类型定义
+└── utils/             # 工具函数
+```
+
+## License
+
+MIT

{rootdriver-0.2.0 → rootdriver-0.3.0}/rootdriver.egg-info/SOURCES.txt

@@ -14,4 +14,5 @@ rootdriver.egg-info/requires.txt
 rootdriver.egg-info/top_level.txt
 tests/test_base_tool.py
 tests/test_conversation.py
-tests/test_tool.py
+tests/test_tool.py
+tests/test_tool_async.py

rootdriver-0.3.0/tests/test_tool_async.py

@@ -0,0 +1,60 @@
+import asyncio
+import time
+import sys
+sys.path.insert(0, "..")
+
+import pytest
+from rootdriver.tool import BaseTool, tool
+
+@tool
+def sync_weather(city: str) -> str:
+    """同步查天气"""
+    time.sleep(0.5)
+    return f"{city}: 晴天"
+
+@tool
+async def async_weather(city: str) -> str:
+    """异步查天气"""
+    await asyncio.sleep(0.5)
+    return f"{city}: 多云"
+
+@pytest.mark.asyncio
+async def test_base_tool_ainvoke():
+    """测试 BaseTool.ainvoke"""
+    result = await sync_weather.ainvoke({"city": "北京"})
+    assert "北京" in result and "晴天" in result
+
+    result = await async_weather.ainvoke({"city": "北京"})
+    assert "北京" in result and "多云" in result
+
+@pytest.mark.asyncio
+async def test_concurrent():
+    """测试并发执行"""
+    start = time.time()
+    results = await asyncio.gather(
+        sync_weather.ainvoke({"city": "北京"}),
+        sync_weather.ainvoke({"city": "上海"}),
+        async_weather.ainvoke({"city": "广州"}),
+    )
+    elapsed = time.time() - start
+
+    assert elapsed < 0.8, f"应该并发执行，但耗时 {elapsed} 秒"
+    assert len(results) == 3
+
+@pytest.mark.asyncio
+async def test_ainvoke_many():
+    """测试批量异步调用"""
+    from rootdriver.types.tool import ToolCall
+    from rootdriver.tool import Tool
+
+    tool_calls = [
+        ToolCall(id="1", name="sync_weather", arguments={"city": "北京"}),
+        ToolCall(id="2", name="async_weather", arguments={"city": "上海"}),
+    ]
+
+    tool_set = Tool([sync_weather, async_weather])
+    results = await tool_set.ainvoke_many(tool_calls)
+
+    assert len(results) == 2
+    assert "北京" in results[0].content
+    assert "上海" in results[1].content