beswarm 0.2.87__tar.gz → 0.2.89__tar.gz

{beswarm-0.2.87 → beswarm-0.2.89}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: beswarm
-Version: 0.2.87
+Version: 0.2.89
 Summary: MAS
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{beswarm-0.2.87 → beswarm-0.2.89}/beswarm/agents/planact.py

@@ -226,12 +226,10 @@ class BrokerWorker:
         self.WORKER_RESPONSE_TOPIC = self.channel + ".worker_responses"
         self.TASK_STATUS_TOPIC =self.channel +  ".task_status"
 
-        self.setup()
-
-    def setup(self):
+    async def setup(self):
         cache_dir = self.work_dir / ".beswarm"
         cache_dir.mkdir(parents=True, exist_ok=True)
-        self.task_manager.set_root_path(self.work_dir)
+        await self.task_manager.set_root_path(self.work_dir)
         self.kgm.set_root_path(self.work_dir)
         self.cache_file = cache_dir / "work_agent_conversation_history.json"
         if not self.cache_file.exists():
@@ -308,6 +306,7 @@ class BrokerWorker:
 
     async def run(self):
         """Sets up subscriptions and starts the workflow."""
+        await self.setup()
         os.chdir(self.work_dir.absolute())
         await self._configure_tools()
 
@@ -326,6 +325,7 @@ class BrokerWorker:
 
     async def stream_run(self):
         """Runs the workflow and yields status messages."""
+        await self.setup()
         os.chdir(self.work_dir.absolute())
         await self._configure_tools()
 

{beswarm-0.2.87 → beswarm-0.2.89}/beswarm/taskmanager.py

@@ -30,6 +30,7 @@ class TaskManager:
             raise ValueError("并发限制必须大于0")
 
         self.tasks_cache = {}          # 存储所有任务的状态和元数据, key: task_id
+        self.task_events = {}          # 为每个任务存储一个asyncio.Event，用于等待特定任务完成
 
         self._pending_queue = asyncio.Queue() # 内部待办任务队列
         self._results_queue = asyncio.Queue() # 内部已完成任务结果队列
@@ -39,7 +40,7 @@ class TaskManager:
         self.cache_dir = None
         self.task_cache_file = None
 
-    def set_root_path(self, root_path):
+    async def set_root_path(self, root_path):
         """设置工作根目录并加载持久化的任务状态。"""
         if self.root_path is not None:
             return
@@ -57,7 +58,7 @@ class TaskManager:
         # 启动工作者池
         self.start()
         # 恢复中断的任务
-        self.resume_interrupted_tasks()
+        await self.resume_interrupted_tasks()
 
     def start(self):
         """启动并发工作者池。"""
@@ -118,6 +119,8 @@ class TaskManager:
 
         self._update_task_status(task_id, status, result=str(result))
         self._results_queue.put_nowait((task_id, status, result))
+        if task_id in self.task_events:
+            self.task_events[task_id].set()
 
     def set_task_cache(self, *keys_and_value):
         """设置可嵌套的任务缓存。"""
@@ -167,6 +170,7 @@ class TaskManager:
         task_ids = []
         for params in tasks_params_list:
             task_id = str(uuid.uuid4())
+            self.task_events[task_id] = asyncio.Event()
             coro = task_coro_func(**params)
 
             # 初始化任务状态为 PENDING
@@ -187,6 +191,7 @@ class TaskManager:
         task_ids = []
         for params in tasks_params_list:
             task_id = str(uuid.uuid4())
+            self.task_events[task_id] = asyncio.Event()
             coro = task_coro_func(**params)
 
             self._update_task_status(task_id, TaskStatus.PENDING, args=params)
@@ -196,7 +201,7 @@ class TaskManager:
         print(f"已将 {len(task_ids)} 个新任务加入待处理队列。队列当前大小: {self._pending_queue.qsize()}")
         return task_ids
 
-    def resume_interrupted_tasks(self):
+    async def resume_interrupted_tasks(self):
         """在启动时，恢复所有处于 PENDING 或 RUNNING 状态的旧任务。"""
         interrupted_tasks = [
             (tid, info) for tid, info in self.tasks_cache.items()
@@ -210,6 +215,7 @@ class TaskManager:
         worker_fun = registry.tools["worker"]
 
         for task_id, task_info in interrupted_tasks:
+            self.task_events[task_id] = asyncio.Event()
             args = task_info.get("args")
             if not args:
                 print(f"警告：任务 <{task_id[:8]}> 缺少参数，无法恢复。")
@@ -218,7 +224,7 @@ class TaskManager:
 
             coro = worker_fun(**args)
             self._update_task_status(task_id, TaskStatus.PENDING)
-            self._pending_queue.put_nowait((task_id, coro))
+            await self._pending_queue.put((task_id, coro))
 
         print(f"{len(interrupted_tasks)} 个中断的任务已重新加入队列。")
 
@@ -238,6 +244,7 @@ class TaskManager:
         worker_fun = registry.tools["worker"]
         coro = worker_fun(**tasks_params)
 
+        self.task_events[task_id] = asyncio.Event()
         self._update_task_status(task_id, TaskStatus.PENDING, args=tasks_params)
         self._pending_queue.put_nowait((task_id, coro))
 

{beswarm-0.2.87 → beswarm-0.2.89}/beswarm/tools/subtasks.py

@@ -30,7 +30,7 @@ def create_task(goal, tools, work_dir):
         if task_id == "root_path":
             continue
         if task_info.get("args", {}).get("work_dir") == work_dir:
-            return f"<tool_error>工作目录 '{work_dir}' 已被任务 {task_id} 使用。请为子任务选择一个唯一的工作目录。</tool_error>"
+            return f"<tool_error>工作目录 '{work_dir}' 已被任务 {task_id} 使用。请为子任务重新选择一个唯一的工作目录。</tool_error>"
 
     # 获取 worker 函数，这是正确的
     worker_fun = registry.tools["worker"]
@@ -71,74 +71,102 @@ def resume_task(task_id, goal):
 @register_tool()
 def get_all_tasks_status():
     """
-    获取所有任务的状态。
-    子任务状态会持久化到磁盘，因此即使历史记录为空，之前的子任务仍然存在。
+    立即获取并返回所有任务的当前状态快照。
+    此函数不会等待，它会立刻返回一个包含所有已知任务（包括已完成、正在运行和待处理的）信息的字典。
+    **警告：** 此工具会返回所有任务的完整信息，可能导致大量的token消耗。
+    如果需要等待任务完成，请使用 `get_task_result()`。仅在需要对所有任务进行全面概览或调试时才应使用此工具。
 
     Returns:
-        str: 所有任务的状态。每个任务的id，状态，结果。
+        dict: 包含所有任务当前状态的字典。
     """
     task_manager = current_task_manager.get()
     return task_manager.tasks_cache
 
 @register_tool()
-async def get_task_result(reduce: bool = False):
+async def get_task_result(task_id: str = None, reduce: bool = False):
     """
-    等待并获取子任务的执行结果。
+    等待并获取一个或多个子任务的执行结果。
 
-    如果 `reduce` 为 `False`（默认），此工具会等待并返回任何一个子任务完成的结果。
-    一旦有任务完成，它会立即获取并返回该任务的结果。如果调用时没有任务完成，它会阻塞并等待。
+    此工具有多种操作模式，**推荐使用默认模式**。
 
-    如果 `reduce` 为 `True`，此工具会进入“规约”模式，等待 **所有** 正在运行或待处理的子任务都执行完毕后，
-    才将所有任务的结果汇总并返回。这在子任务之间无依赖、可以完全并行执行的场景下非常有用，
-    可以避免为了获取每个任务的结果而进行多次轮询，从而节省token。
+    1.  **等待并获取下一个完成的任务（推荐的标准方法）**:
+        在不提供 `task_id` 且 `reduce=False` 的情况下，此工具会异步等待，直到队列中有任何一个子任务完成，然后返回该任务的结果。
+        这是处理子任务最常用的模式，它允许你以事件驱动的方式、按完成顺序处理结果。
 
-    警告：当子任务之间存在依赖关系，或者需要根据一个任务的结果来决定下一步操作时，**禁止** 使用 `reduce=True`。
+    2.  **获取特定任务的结果（特殊需求）**:
+        仅当你需要等待一个 *特定* 子任务时，才提供 `task_id` 参数。工具将专门等待该ID的任务完成并返回其结果。
+        如果任务已经完成，结果会立即返回。
+
+    3.  **规约模式（等待所有任务）**:
+        设置 `reduce=True` 会使工具等待 **所有** 正在运行或待处理的任务都完成后，才一次性返回所有结果的摘要。
+        **警告：** 仅在子任务间完全独立、可以并行执行时使用此模式。当使用此模式时，不应提供 `task_id`。
 
     Args:
-        reduce (bool, optional): 是否启用规约模式。默认为 `False`。
+        task_id (str, optional): 要获取结果的特定任务的ID。仅在需要等待特定任务时使用。
+        reduce (bool, optional): 是否等待所有任务完成后再汇总返回。默认为 `False`。
 
     Returns:
-        str:
-        - 当 `reduce=False` 时，返回单个子任务的执行结果。
-        - 当 `reduce=True` 时，返回一个包含所有任务最终状态和结果的汇总字符串。
+        str: 任务的执行结果或结果摘要。
     """
     task_manager = current_task_manager.get()
+
+    if task_id and reduce:
+        return "<tool_error>无效的参数组合：不能同时提供 `task_id` 和设置 `reduce=True`。</tool_error>"
+
     def get_running_tasks_count():
         return len([
-            task_id for task_id, task in task_manager.tasks_cache.items()
-            if task_id != "root_path" and task.get("status") in ["PENDING", "RUNNING"]
+            tid for tid, task in task_manager.tasks_cache.items()
+            if tid != "root_path" and task.get("status") in ["PENDING", "RUNNING"]
         ])
 
+    if task_id:
+        # 模式1：等待并获取指定任务的结果
+        if task_id not in task_manager.tasks_cache:
+            return f"<tool_error>任务ID '{task_id}' 不存在。</tool_error>"
+
+        # 如果任务已经完成，直接返回结果
+        task_info = task_manager.tasks_cache[task_id]
+        if task_info.get("status") in ["DONE", "ERROR"]:
+            return f"Task ID: {task_id}\nStatus: {task_info['status']}\nResult: {task_info.get('result', 'N/A')}"
+
+        # 如果任务未完成，等待事件
+        event = task_manager.task_events.get(task_id)
+        if event:
+            await event.wait()
+            # 事件触发后，再次获取最新状态
+            task_info = task_manager.tasks_cache[task_id]
+            return f"Task ID: {task_id}\nStatus: {task_info['status']}\nResult: {task_info.get('result', 'N/A')}"
+        else:
+            return f"<tool_error>任务 '{task_id}' 的事件不存在，可能是一个旧任务或状态已损坏。</tool_error>"
+
+    # 检查是否还有正在运行的任务
     if get_running_tasks_count() == 0:
         return "All tasks are finished."
 
     if not reduce:
-        # 默认行为：获取下一个完成的任务结果
-        task_id, status, result = await task_manager.get_next_result()
-
+        # 模式2：获取下一个完成的任务结果
+        next_task_id, status, result = await task_manager.get_next_result()
         unfinished_tasks = [tid for tid, task in task_manager.tasks_cache.items() if tid != "root_path" and task.get("status") not in ["DONE", "ERROR"]]
         text = "".join([
-            f"Task ID: {task_id}\n",
+            f"Task ID: {next_task_id}\n",
             f"Status: {status.value}\n",
             f"Result: {result}\n\n",
-            f"There are {len(unfinished_tasks)} unfinished tasks, unfinished task ids: {unfinished_tasks[:5]} ..." if unfinished_tasks else "All tasks are finished.",
+            f"There are {len(unfinished_tasks)} unfinished tasks, unfinished task ids: {unfinished_tasks[0]}" if unfinished_tasks else "All tasks are finished.",
         ])
         return text
     else:
-        # 规约模式：等待所有任务完成
+        # 模式3：规约模式 - 等待所有任务完成
         while get_running_tasks_count() > 0:
             await task_manager.get_next_result()
 
-        # 收集所有任务的结果
         all_results = []
-        for task_id, task in task_manager.tasks_cache.items():
-            if task_id == "root_path":
+        for tid, task in task_manager.tasks_cache.items():
+            if tid == "root_path":
                 continue
-
             status = task.get('status', 'UNKNOWN')
             result = task.get('result', 'No result available')
             all_results.append(
-                f"Task ID: {task_id}\nStatus: {status}\nResult: {result}"
+                f"Task ID: {tid}\nStatus: {status}\nResult: {result}"
             )
 
         summary = f"All {len(all_results)} subtasks have been completed.\n\n"

{beswarm-0.2.87 → beswarm-0.2.89}/beswarm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: beswarm
-Version: 0.2.87
+Version: 0.2.89
 Summary: MAS
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{beswarm-0.2.87 → beswarm-0.2.89}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "beswarm"
-version = "0.2.87"
+version = "0.2.89"
 description = "MAS"
 readme = "README.md"
 requires-python = ">=3.11"