beswarm 0.2.36__py3-none-any.whl → 0.2.37__py3-none-any.whl

beswarm/agents/planact.py

@@ -0,0 +1,339 @@
+import os
+import re
+import sys
+import copy
+import json
+import difflib
+import asyncio
+import platform
+from pathlib import Path
+from datetime import datetime
+from typing import List, Dict, Union
+
+from ..broker import MessageBroker
+from ..aient.src.aient.models import chatgpt
+from ..aient.src.aient.plugins import get_function_call_list, registry
+from ..prompt import worker_system_prompt, instruction_system_prompt
+from ..utils import extract_xml_content, get_current_screen_image_message, replace_xml_content, register_mcp_tools
+
+class BaseAgent:
+    """Base class for agents, handling common initialization and disposal."""
+    def __init__(self, goal: str, tools_json: List, agent_config: Dict, work_dir: str, cache_messages: Union[bool, List[Dict]], broker: MessageBroker, listen_topic: str, publish_topic: str, status_topic: str):
+        self.goal = goal
+        self.tools_json = tools_json
+        self.work_dir = work_dir
+        self.cache_file = Path(work_dir) / ".beswarm" / "work_agent_conversation_history.json"
+        self.config = agent_config
+        self.cache_messages = cache_messages
+        if cache_messages and isinstance(cache_messages, bool) and cache_messages == True:
+            self.cache_messages = json.loads(self.cache_file.read_text(encoding="utf-8"))
+        self.broker = broker
+        self.listen_topic = listen_topic
+        self.error_topic = listen_topic + ".error"
+        self.publish_topic = publish_topic
+        self.status_topic = status_topic
+        self._subscription = self.broker.subscribe(self.handle_message, [self.listen_topic, self.error_topic])
+
+    async def handle_message(self, message: Dict):
+        """Process incoming messages. Must be implemented by subclasses."""
+        raise NotImplementedError
+
+    def dispose(self):
+        """Cancels the subscription and cleans up resources."""
+        if self._subscription:
+            self._subscription.dispose()
+
+
+class InstructionAgent(BaseAgent):
+    """Generates instructions and publishes them to a message broker."""
+    def __init__(self, goal: str, tools_json: List, agent_config: Dict, work_dir: str, cache_messages: Union[bool, List[Dict]], broker: MessageBroker, listen_topic: str, publish_topic: str, status_topic: str):
+        super().__init__(goal, tools_json, agent_config, work_dir, cache_messages, broker, listen_topic, publish_topic, status_topic)
+
+        self.last_instruction = None
+        self.agent = chatgpt(**self.config)
+
+        self.goal_diff = None
+
+        if self.cache_messages and isinstance(self.cache_messages, list) and len(self.cache_messages) > 1:
+            old_goal = extract_xml_content(self.cache_messages[1]["content"], "goal")
+            if old_goal.strip() != goal.strip():
+                diff_generator = difflib.ndiff(old_goal.splitlines(), goal.splitlines())
+                changed_lines = []
+                for line in diff_generator:
+                    if (line.startswith('+ ') or line.startswith('- ')) and line[2:].strip():
+                        changed_lines.append(line)
+                self.goal_diff = '\n'.join(changed_lines).strip()
+
+    def get_conversation_history(self, conversation_history: List[Dict]):
+        conversation_history = copy.deepcopy(conversation_history)
+
+        self.cache_file.write_text(json.dumps(conversation_history, ensure_ascii=False, indent=4), encoding="utf-8")
+
+        work_agent_system_prompt = conversation_history.pop(0)
+        if conversation_history:
+            original_content = work_agent_system_prompt["content"]
+            regex = r"<latest_file_content>(.*?)</latest_file_content>"
+            match = re.search(regex, original_content, re.DOTALL)
+            if match:
+                extracted_content = f"<latest_file_content>{match.group(1)}</latest_file_content>\n\n"
+            else:
+                extracted_content = ""
+            if isinstance(conversation_history[0]["content"], str):
+                conversation_history[0]["content"] = extracted_content + conversation_history[0]["content"]
+            elif isinstance(conversation_history[0]["content"], list) and extracted_content:
+                conversation_history[0]["content"].append({"type": "text", "text": extracted_content})
+
+        return conversation_history
+
+    async def handle_message(self, message: Dict):
+        """Receives a worker response, generates the next instruction, and publishes it."""
+
+        if len(message["conversation"]) > 1 and message["conversation"][-2]["role"] == "user" \
+        and "<task_complete_message>" in message["conversation"][-2]["content"]:
+            task_complete_message = extract_xml_content(message["conversation"][-2]["content"], "task_complete_message")
+            self.broker.publish({"status": "finished", "result": task_complete_message}, self.status_topic)
+            return
+
+        instruction_prompt = "".join([
+                "</work_agent_conversation_end>\n\n",
+                f"任务目标: {self.goal}\n\n",
+                f"任务目标新变化：\n{self.goal_diff}\n\n" if self.goal_diff else "",
+                "在 tag <work_agent_conversation_start>...</work_agent_conversation_end> 之前的对话历史都是工作智能体的对话历史。\n\n",
+                "根据以上对话历史和目标，请生成下一步指令。如果任务已完成，指示工作智能体调用task_complete工具。\n\n",
+            ])
+        if self.last_instruction and 'fetch_gpt_response_stream HTTP Error' not in self.last_instruction:
+            instruction_prompt = (
+                f"{instruction_prompt}\n\n"
+                "你生成的指令格式错误，必须把给assistant的指令放在<instructions>...</instructions>标签内。请重新生成格式正确的指令。"
+                f"这是你上次给assistant的错误格式的指令：\n{self.last_instruction}"
+            )
+
+        self.agent.conversation["default"][1:] = self.get_conversation_history(message["conversation"])
+
+        if "find_and_click_element" in json.dumps(self.tools_json):
+            instruction_prompt = await get_current_screen_image_message(instruction_prompt)
+
+        raw_response = await self.agent.ask_async(instruction_prompt)
+
+        if "fetch_gpt_response_stream HTTP Error', 'status_code': 404" in raw_response:
+            raise Exception(f"Model: {self.config['engine']} not found!")
+        if "'status_code': 413" in raw_response or \
+        "'status_code': 400" in raw_response:
+            self.broker.publish({"status": "error", "result": raw_response}, self.status_topic)
+            return
+
+        self.broker.publish({"status": "new_message", "result": "\n🤖 指令智能体:\n" + raw_response}, self.status_topic)
+
+        self.last_instruction = raw_response
+        instruction = extract_xml_content(raw_response, "instructions")
+        if instruction:
+            if len(message["conversation"]) == 1:
+                instruction = (
+                    "任务描述：\n"
+                    f"<goal>{self.goal}</goal>\n\n"
+                    "你作为指令的**执行者**，而非任务的**规划师**，你必须严格遵循以下单步工作流程：\n"
+                    "**执行指令**\n"
+                    "   - **严格遵从：** 只执行我当前下达的明确指令。在我明确给出下一步指令前，绝不擅自行动或推测、执行任何未明确要求的后续步骤。\n"
+                    "   - **严禁越权：** 禁止执行任何我未指定的步骤。`<goal>` 标签中的内容仅为背景信息，不得据此进行任务规划或推测。\n"
+                    "**汇报结果**\n"
+                    "   - **聚焦单步：** 指令完成后，仅汇报该步骤的执行结果与产出。\n"
+                    "**暂停等待**\n"
+                    "   - **原地待命：** 汇报后，任务暂停。在收到我新的指令前，严禁发起任何新的工具调用或操作。\n"
+                    "   - **请求指令：** 回复的最后必须明确请求我提供下一步指令。\n"
+                    "**注意：** 禁止完成超出下面我未规定的步骤，`<goal>` 标签中的内容仅为背景信息。"
+                    "现在开始执行第一步：\n"
+                    f"{instruction}"
+                )
+            self.broker.publish({"instruction": instruction, "conversation": message["conversation"]}, self.publish_topic)
+        else:
+            print("\n❌ 指令智能体生成的指令不符合要求，正在重新生成。")
+            self.broker.publish(message, self.error_topic)
+
+
+class WorkerAgent(BaseAgent):
+    """Executes instructions and publishes results to a message broker."""
+    def __init__(self, goal: str, tools_json: List, agent_config: Dict, work_dir: str, cache_messages: Union[bool, List[Dict]], broker: MessageBroker, listen_topic: str, publish_topic: str, status_topic: str):
+        super().__init__(goal, tools_json, agent_config, work_dir, cache_messages, broker, listen_topic, publish_topic, status_topic)
+
+        if self.cache_messages and isinstance(self.cache_messages, list) and len(self.cache_messages) > 1:
+            first_user_message = replace_xml_content(self.cache_messages[1]["content"], "goal", goal)
+            self.config["cache_messages"] = self.cache_messages[0:1] + [{"role": "user", "content": first_user_message}] + self.cache_messages[2:]
+
+        self.agent = chatgpt(**self.config)
+
+    async def handle_message(self, message: Dict):
+        """Receives an instruction, executes it, and publishes the response."""
+
+        if message.get("instruction") == "Initial kickoff":
+            self.broker.publish({
+                "conversation": self.agent.conversation["default"]
+            }, self.publish_topic)
+            return
+
+        instruction = message["instruction"]
+        if "find_and_click_element" in json.dumps(self.tools_json):
+            instruction = await get_current_screen_image_message(instruction)
+        response = await self.agent.ask_async(instruction)
+
+        if response.strip() == '':
+            print("\n❌ 工作智能体回复为空，请重新生成指令。")
+            self.broker.publish(message, self.error_topic)
+        else:
+            self.broker.publish({"status": "new_message", "result": "\n✅ 工作智能体:\n" + response}, self.status_topic)
+            self.broker.publish({
+                "conversation": self.agent.conversation["default"]
+            }, self.publish_topic)
+
+class Tee:
+    def __init__(self, *files):
+        self.files = files
+
+    def write(self, obj):
+        for f in self.files:
+            f.write(obj)
+            f.flush()
+
+    def flush(self):
+        for f in self.files:
+            f.flush()
+
+class BrokerWorker:
+    """The 'glue' class that orchestrates agents via a MessageBroker."""
+    def __init__(self, goal: str, tools: List[Union[str, Dict]], work_dir: str, cache_messages: Union[bool, List[Dict]] = None, broker = None, mcp_manager = None, task_manager = None):
+        self.goal = goal
+        self.tools = tools
+        self.work_dir = Path(work_dir)
+        self.cache_messages = cache_messages
+
+        self.broker = broker
+        self.mcp_manager = mcp_manager
+        self.task_manager = task_manager
+        self.task_completion_event = asyncio.Event()
+        self.final_result = None
+        self._status_subscription = None
+        self.setup()
+
+        self.channel = self.broker.request_channel()
+        self.INSTRUCTION_TOPIC = self.channel + ".instructions"
+        self.WORKER_RESPONSE_TOPIC = self.channel + ".worker_responses"
+        self.TASK_STATUS_TOPIC =self.channel +  ".task_status"
+
+    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)
+        self.cache_file = cache_dir / "work_agent_conversation_history.json"
+        if not self.cache_file.exists():
+            self.cache_file.write_text("[]", encoding="utf-8")
+
+        DEBUG = os.getenv("DEBUG", "false").lower() in ("true", "1", "t", "yes")
+        if DEBUG:
+            log_file = open(cache_dir / "history.log", "a", encoding="utf-8")
+            log_file.write(f"========== {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} ==========\n")
+            original_stdout = sys.stdout
+            original_stderr = sys.stderr
+            sys.stdout = Tee(original_stdout, log_file)
+            sys.stderr = Tee(original_stderr, log_file)
+
+    async def _configure_tools(self):
+        mcp_list = [item for item in self.tools if isinstance(item, dict)]
+        if mcp_list:
+            for mcp_item in mcp_list:
+                mcp_name, mcp_config = list(mcp_item.items())[0]
+                await self.mcp_manager.add_server(mcp_name, mcp_config)
+                client = self.mcp_manager.clients.get(mcp_name)
+                await register_mcp_tools(client, registry)
+            all_mcp_tools = await self.mcp_manager.get_all_tools()
+            self.tools.extend([tool.name for tool in sum(all_mcp_tools.values(), [])])
+        self.tools = [item for item in self.tools if not isinstance(item, dict)]
+        if "task_complete" not in self.tools: self.tools.append("task_complete")
+        self.tools_json = [value for _, value in get_function_call_list(self.tools).items()]
+
+    def _task_status_subscriber(self, message: Dict):
+        """Subscriber for task status changes."""
+        if message.get("status") == "finished":
+            self.final_result = message.get("result")
+            self.task_completion_event.set()
+
+        if message.get("status") == "error":
+            raise Exception(message.get("result"))
+
+        if message.get("status") == "new_message":
+            print(message.get("result"))
+
+    def _setup_agents(self):
+        instruction_agent_config = {
+            "api_key": os.getenv("API_KEY"), "api_url": os.getenv("BASE_URL"),
+            "engine": os.getenv("MODEL"),
+            "system_prompt": instruction_system_prompt.format(
+                os_version=platform.platform(), tools_list=self.tools_json,
+                workspace_path=self.work_dir, current_time=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            ),
+            "print_log": os.getenv("DEBUG", "false").lower() in ("true", "1", "t", "yes"),
+            "temperature": 0.7, "use_plugins": False
+        }
+
+        worker_agent_config = {
+            "api_key": os.getenv("API_KEY"), "api_url": os.getenv("BASE_URL"),
+            "engine": os.getenv("FAST_MODEL") or os.getenv("MODEL"),
+            "system_prompt": worker_system_prompt.format(
+                os_version=platform.platform(), workspace_path=self.work_dir,
+                shell=os.getenv('SHELL', 'Unknown'), current_time=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                tools_list=self.tools_json
+            ),
+            "print_log": True, "temperature": 0.5, "function_call_max_loop": 100
+        }
+
+        instruction_agent = InstructionAgent(
+            goal=self.goal, tools_json=self.tools_json, agent_config=instruction_agent_config, work_dir=self.work_dir, cache_messages=self.cache_messages,
+            broker=self.broker, listen_topic=self.WORKER_RESPONSE_TOPIC,
+            publish_topic=self.INSTRUCTION_TOPIC, status_topic=self.TASK_STATUS_TOPIC
+        )
+
+        worker_agent = WorkerAgent(
+            goal=self.goal, tools_json=self.tools_json, agent_config=worker_agent_config, work_dir=self.work_dir, cache_messages=self.cache_messages,
+            broker=self.broker, listen_topic=self.INSTRUCTION_TOPIC,
+            publish_topic=self.WORKER_RESPONSE_TOPIC, status_topic=self.TASK_STATUS_TOPIC
+        )
+        return instruction_agent, worker_agent
+
+    async def run(self):
+        """Sets up subscriptions and starts the workflow."""
+        os.chdir(self.work_dir.absolute())
+        await self._configure_tools()
+
+        instruction_agent, worker_agent = self._setup_agents()
+
+        self.broker.publish({"instruction": "Initial kickoff"}, self.INSTRUCTION_TOPIC)
+
+        self._status_subscription = self.broker.subscribe(self._task_status_subscriber, self.TASK_STATUS_TOPIC)
+        await self.task_completion_event.wait()
+
+        instruction_agent.dispose()
+        worker_agent.dispose()
+        self._status_subscription.dispose()
+        await self.mcp_manager.cleanup()
+        return self.final_result
+
+    async def stream_run(self):
+        """Runs the workflow and yields status messages."""
+        os.chdir(self.work_dir.absolute())
+        await self._configure_tools()
+
+        instruction_agent, worker_agent = self._setup_agents()
+
+        self.broker.publish({"instruction": "Initial kickoff"}, self.INSTRUCTION_TOPIC)
+
+        try:
+            async for message in self.broker.iter_topic(self.TASK_STATUS_TOPIC):
+                if message.get("status") == "new_message":
+                    yield message.get("result")
+                elif message.get("status") == "finished":
+                    yield message.get("result")
+                    break
+                elif message.get("status") == "error":
+                    raise Exception(message.get("result"))
+        finally:
+            instruction_agent.dispose()
+            worker_agent.dispose()
+            await self.mcp_manager.cleanup()

beswarm/core.py

@@ -0,0 +1,11 @@
+from .taskmanager import TaskManager
+from .broker import MessageBroker
+from .bemcp.bemcp import MCPManager
+
+"""
+全局共享实例
+"""
+
+task_manager = TaskManager()
+broker = MessageBroker()
+mcp_manager = MCPManager()

beswarm/{tools/taskmanager.py → taskmanager.py}

@@ -1,11 +1,10 @@
-import ast
 import json
 import uuid
 import asyncio
 from enum import Enum
 from pathlib import Path
 
-from ..aient.src.aient.plugins import register_tool, registry
+from .aient.src.aient.plugins import registry
 
 class TaskStatus(Enum):
     """任务状态枚举"""
@@ -91,7 +90,7 @@ class TaskManager:
         running_task_id_list = [task_id for task_id, task in self.tasks_cache.items() if task_id != "root_path" and task.get("status") == "RUNNING"]
         for task_id in running_task_id_list:
             tasks_params = self.tasks_cache[task_id]["args"]
-            task_id = task_manager.resume_task(task_id, worker_fun, tasks_params)
+            task_id = self.resume_task(task_id, registry.tools["worker"], tasks_params)
 
     def resume_task(self, task_id, task_coro, args):
         """
@@ -223,85 +222,8 @@ class TaskManager:
             # 如果任务ID不存在，则返回-1
             return -1
 
-
-task_manager = TaskManager()
-
-worker_fun = registry.tools["worker"]
-
-@register_tool()
-def create_task(goal, tools, work_dir):
-    """
-    启动一个子任务来自动完成指定的任务目标 (`goal`)。
-
-    这个子任务接收一个清晰的任务描述、一组可供调用的工具 (`tools`)，以及一个工作目录 (`work_dir`)。
-    它会结合可用的工具，自主规划并逐步执行必要的操作，直到最终完成指定的任务目标。
-    核心功能是根据输入的目标，驱动整个任务执行流程。
-    子任务下上文为空，因此需要细致的背景信息。
-
-    Args:
-        goal (str): 需要完成的具体任务目标描述。子任务将围绕此目标进行工作。必须清晰、具体。必须包含背景信息，完成指标等。写清楚什么时候算任务完成，同时交代清楚任务的背景信息，这个背景信息可以是需要读取的文件等一切有助于完成任务的信息。
-        tools (list[str]): 一个包含可用工具函数对象的列表。子任务在执行任务时可能会调用这些工具来与环境交互（例如读写文件、执行命令等）。
-        work_dir (str): 工作目录的绝对路径。子任务将在此目录上下文中执行操作。子任务的工作目录位置在主任务的工作目录的子目录。子任务工作目录**禁止**设置为主任务目录本身。
-
-    Returns:
-        str: 当任务成功完成时，返回字符串 "任务已完成"。
-    """
-    tasks_params = [
-        {"goal": goal, "tools": ast.literal_eval(tools), "work_dir": work_dir, "cache_messages": True}
-    ]
-    task_ids = task_manager.create_tasks(worker_fun, tasks_params)
-    return task_ids
-
-@register_tool()
-def resume_task(task_id, goal):
-    """
-    恢复一个子任务。
-    """
-    if task_id not in task_manager.tasks_cache:
-        return f"任务 {task_id} 不存在"
-    tasks_params = task_manager.tasks_cache[task_id]["args"]
-    tasks_params["goal"] = goal
-    tasks_params["cache_messages"] = True
-    task_id = task_manager.resume_task(task_id, worker_fun, tasks_params)
-    return f"任务 {task_id} 已恢复"
-
-@register_tool()
-def get_all_tasks_status():
-    """
-    获取所有任务的状态。
-    子任务状态会持久化到磁盘，因此即使历史记录为空，之前的子任务仍然存在。
-
-    Returns:
-        str: 所有任务的状态。每个任务的id，状态，结果。
-    """
-    return task_manager.tasks_cache
-
-@register_tool()
-async def get_task_result():
-    """
-    等待并获取子任务的执行结果。如果需要等待子任务完成，请使用这个工具。一旦有任务完成，会自动获取结果。如果调用时没有任务完成，会等待直到有任务完成。
-
-    Returns:
-        str: 子任务的执行结果。
-    """
-    running_tasks_num = len([task_id for task_id, task in task_manager.tasks_cache.items() if task_id != "root_path" and task.get("status") == "RUNNING"])
-    if running_tasks_num == 0:
-        return "All tasks are finished."
-    task_id, status, result = await task_manager.get_next_result()
-
-    unfinished_tasks = [task_id for task_id, task in task_manager.tasks_cache.items() if task_id != "root_path" and task.get("status") != "DONE"]
-    text = "".join([
-        f"Task ID: {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}" if unfinished_tasks else "All tasks are finished.",
-    ])
-
-    return text
-
 async def main():
     manager = TaskManager()
-    from worker import worker
 
     # --- 任务提交阶段 ---
     print("--- 任务提交 ---")
@@ -313,7 +235,7 @@ async def main():
         {"goal": 2},
         {"goal": 4},
     ]
-    task_ids = manager.create_tasks(worker, tasks_to_run)
+    task_ids = manager.create_tasks(registry.tools["worker"], tasks_to_run)
     print(f"\n主程序: {len(task_ids)} 个任务已提交，现在开始等待结果...\n")
 
     # --- 结果处理阶段 ---

beswarm/tools/__init__.py

@@ -1,60 +1,58 @@
 from .edit_file import edit_file
-from .worker import worker, worker_gen
-from .screenshot import save_screenshot_to_file
-from .request_input import request_admin_input
-
+from .search_web import search_web
+from .completion import task_complete
 from .search_arxiv import search_arxiv
 from .repomap import get_code_repo_map
+from .worker import worker, worker_gen
+from .request_input import request_admin_input
+from .screenshot import save_screenshot_to_file
 from .click import find_and_click_element, scroll_screen
-from .search_web import search_web
-from .taskmanager import create_task, resume_task, get_all_tasks_status, get_task_result
-from .completion import task_complete
+from .subtasks import create_task, resume_task, get_all_tasks_status, get_task_result
 
 #显式导入 aient.plugins 中的所需内容
 from ..aient.src.aient.plugins import (
-    excute_command,
     get_time,
+    read_file,
+    read_image,
+    register_tool,
+    write_to_file,
+    excute_command,
     generate_image,
     list_directory,
-    read_file,
+    get_url_content,
     run_python_script,
+    set_readonly_path,
     get_search_results,
-    write_to_file,
     download_read_arxiv_pdf,
-    get_url_content,
-    read_image,
-    set_readonly_path,
-    register_tool,
 )
 
 __all__ = [
-    "edit_file",
     "worker",
+    "get_time",
+    "edit_file",
+    "read_file",
     "worker_gen",
+    "read_image",
+    "search_web",
+    "create_task",
+    "resume_task",
     "search_arxiv",
-    "get_code_repo_map",
-    # aient.plugins
+    "write_to_file",
+    "scroll_screen",
+    "register_tool",
+    "task_complete",
     "excute_command",
-    "read_image",
-    "get_time",
     "generate_image",
     "list_directory",
-    "read_file",
-    "run_python_script",
-    "get_search_results",
-    "write_to_file",
-    "download_read_arxiv_pdf",
+    "get_task_result",
     "get_url_content",
-    "find_and_click_element",
-    "scroll_screen",
-    "register_tool",
-    "search_web",
-    "save_screenshot_to_file",
     "set_readonly_path",
+    "get_code_repo_map",
+    "run_python_script",
+    "get_search_results",
     "request_admin_input",
-    "create_task",
-    "resume_task",
     "get_all_tasks_status",
-    "get_task_result",
-    "task_complete",
+    "find_and_click_element",
+    "download_read_arxiv_pdf",
+    "save_screenshot_to_file",
 ]

beswarm/tools/subtasks.py

@@ -0,0 +1,77 @@
+import ast
+
+from ..core import task_manager
+from ..aient.src.aient.plugins import register_tool, registry
+
+worker_fun = registry.tools["worker"]
+
+@register_tool()
+def create_task(goal, tools, work_dir):
+    """
+    启动一个子任务来自动完成指定的任务目标 (`goal`)。
+
+    这个子任务接收一个清晰的任务描述、一组可供调用的工具 (`tools`)，以及一个工作目录 (`work_dir`)。
+    它会结合可用的工具，自主规划并逐步执行必要的操作，直到最终完成指定的任务目标。
+    核心功能是根据输入的目标，驱动整个任务执行流程。
+    子任务下上文为空，因此需要细致的背景信息。
+
+    Args:
+        goal (str): 需要完成的具体任务目标描述。子任务将围绕此目标进行工作。必须清晰、具体。必须包含背景信息，完成指标等。写清楚什么时候算任务完成，同时交代清楚任务的背景信息，这个背景信息可以是需要读取的文件等一切有助于完成任务的信息。
+        tools (list[str]): 一个包含可用工具函数对象的列表。子任务在执行任务时可能会调用这些工具来与环境交互（例如读写文件、执行命令等）。
+        work_dir (str): 工作目录的绝对路径。子任务将在此目录上下文中执行操作。子任务的工作目录位置在主任务的工作目录的子目录。子任务工作目录**禁止**设置为主任务目录本身。
+
+    Returns:
+        str: 当任务成功完成时，返回字符串 "任务已完成"。
+    """
+    tasks_params = [
+        {"goal": goal, "tools": ast.literal_eval(tools), "work_dir": work_dir, "cache_messages": True}
+    ]
+    task_ids = task_manager.create_tasks(worker_fun, tasks_params)
+    return task_ids
+
+@register_tool()
+def resume_task(task_id, goal):
+    """
+    恢复一个子任务。
+    """
+    if task_id not in task_manager.tasks_cache:
+        return f"任务 {task_id} 不存在"
+    tasks_params = task_manager.tasks_cache[task_id]["args"]
+    tasks_params["goal"] = goal
+    tasks_params["cache_messages"] = True
+    task_id = task_manager.resume_task(task_id, worker_fun, tasks_params)
+    return f"任务 {task_id} 已恢复"
+
+@register_tool()
+def get_all_tasks_status():
+    """
+    获取所有任务的状态。
+    子任务状态会持久化到磁盘，因此即使历史记录为空，之前的子任务仍然存在。
+
+    Returns:
+        str: 所有任务的状态。每个任务的id，状态，结果。
+    """
+    return task_manager.tasks_cache
+
+@register_tool()
+async def get_task_result():
+    """
+    等待并获取子任务的执行结果。如果需要等待子任务完成，请使用这个工具。一旦有任务完成，会自动获取结果。如果调用时没有任务完成，会等待直到有任务完成。
+
+    Returns:
+        str: 子任务的执行结果。
+    """
+    running_tasks_num = len([task_id for task_id, task in task_manager.tasks_cache.items() if task_id != "root_path" and task.get("status") == "RUNNING"])
+    if running_tasks_num == 0:
+        return "All tasks are finished."
+    task_id, status, result = await task_manager.get_next_result()
+
+    unfinished_tasks = [task_id for task_id, task in task_manager.tasks_cache.items() if task_id != "root_path" and task.get("status") != "DONE"]
+    text = "".join([
+        f"Task ID: {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}" if unfinished_tasks else "All tasks are finished.",
+    ])
+
+    return text

beswarm/tools/worker.py

@@ -1,351 +1,15 @@
-import os
-import re
-import sys
-import copy
-import json
-import difflib
-import asyncio
-import platform
-from pathlib import Path
 from datetime import datetime
 from typing import List, Dict, Union
 
-from ..broker import MessageBroker
-from ..aient.src.aient.models import chatgpt
-from ..aient.src.aient.plugins import register_tool, get_function_call_list, registry
-from ..prompt import worker_system_prompt, instruction_system_prompt
-from ..utils import extract_xml_content, get_current_screen_image_message, replace_xml_content, register_mcp_tools
-from ..bemcp.bemcp import MCPManager
-
-class BaseAgent:
-    """Base class for agents, handling common initialization and disposal."""
-    def __init__(self, goal: str, tools_json: List, agent_config: Dict, work_dir: str, cache_messages: Union[bool, List[Dict]], broker: MessageBroker, listen_topic: str, publish_topic: str, status_topic: str):
-        self.goal = goal
-        self.tools_json = tools_json
-        self.work_dir = work_dir
-        self.cache_file = Path(work_dir) / ".beswarm" / "work_agent_conversation_history.json"
-        self.config = agent_config
-        self.cache_messages = cache_messages
-        if cache_messages and isinstance(cache_messages, bool) and cache_messages == True:
-            self.cache_messages = json.loads(self.cache_file.read_text(encoding="utf-8"))
-        self.broker = broker
-        self.listen_topic = listen_topic
-        self.error_topic = listen_topic + ".error"
-        self.publish_topic = publish_topic
-        self.status_topic = status_topic
-        self._subscription = self.broker.subscribe(self.handle_message, [self.listen_topic, self.error_topic])
-
-    async def handle_message(self, message: Dict):
-        """Process incoming messages. Must be implemented by subclasses."""
-        raise NotImplementedError
-
-    def dispose(self):
-        """Cancels the subscription and cleans up resources."""
-        if self._subscription:
-            self._subscription.dispose()
-
-
-class InstructionAgent(BaseAgent):
-    """Generates instructions and publishes them to a message broker."""
-    def __init__(self, goal: str, tools_json: List, agent_config: Dict, work_dir: str, cache_messages: Union[bool, List[Dict]], broker: MessageBroker, listen_topic: str, publish_topic: str, status_topic: str):
-        super().__init__(goal, tools_json, agent_config, work_dir, cache_messages, broker, listen_topic, publish_topic, status_topic)
-
-        self.last_instruction = None
-        self.agent = chatgpt(**self.config)
-
-        self.goal_diff = None
-
-        if self.cache_messages and isinstance(self.cache_messages, list) and len(self.cache_messages) > 1:
-            old_goal = extract_xml_content(self.cache_messages[1]["content"], "goal")
-            if old_goal.strip() != goal.strip():
-                diff_generator = difflib.ndiff(old_goal.splitlines(), goal.splitlines())
-                changed_lines = []
-                for line in diff_generator:
-                    if (line.startswith('+ ') or line.startswith('- ')) and line[2:].strip():
-                        changed_lines.append(line)
-                self.goal_diff = '\n'.join(changed_lines).strip()
-
-    def get_conversation_history(self, conversation_history: List[Dict]):
-        conversation_history = copy.deepcopy(conversation_history)
-
-        self.cache_file.write_text(json.dumps(conversation_history, ensure_ascii=False, indent=4), encoding="utf-8")
-
-        work_agent_system_prompt = conversation_history.pop(0)
-        if conversation_history:
-            original_content = work_agent_system_prompt["content"]
-            regex = r"<latest_file_content>(.*?)</latest_file_content>"
-            match = re.search(regex, original_content, re.DOTALL)
-            if match:
-                extracted_content = f"<latest_file_content>{match.group(1)}</latest_file_content>\n\n"
-            else:
-                extracted_content = ""
-            if isinstance(conversation_history[0]["content"], str):
-                conversation_history[0]["content"] = extracted_content + conversation_history[0]["content"]
-            elif isinstance(conversation_history[0]["content"], list) and extracted_content:
-                conversation_history[0]["content"].append({"type": "text", "text": extracted_content})
-
-        return conversation_history
-
-    async def handle_message(self, message: Dict):
-        """Receives a worker response, generates the next instruction, and publishes it."""
-
-        if len(message["conversation"]) > 1 and message["conversation"][-2]["role"] == "user" \
-        and "<task_complete_message>" in message["conversation"][-2]["content"]:
-            task_complete_message = extract_xml_content(message["conversation"][-2]["content"], "task_complete_message")
-            self.broker.publish({"status": "finished", "result": task_complete_message}, self.status_topic)
-            return
-
-        instruction_prompt = "".join([
-                "</work_agent_conversation_end>\n\n",
-                f"任务目标: {self.goal}\n\n",
-                f"任务目标新变化：\n{self.goal_diff}\n\n" if self.goal_diff else "",
-                "在 tag <work_agent_conversation_start>...</work_agent_conversation_end> 之前的对话历史都是工作智能体的对话历史。\n\n",
-                "根据以上对话历史和目标，请生成下一步指令。如果任务已完成，指示工作智能体调用task_complete工具。\n\n",
-            ])
-        if self.last_instruction and 'fetch_gpt_response_stream HTTP Error' not in self.last_instruction:
-            instruction_prompt = (
-                f"{instruction_prompt}\n\n"
-                "你生成的指令格式错误，必须把给assistant的指令放在<instructions>...</instructions>标签内。请重新生成格式正确的指令。"
-                f"这是你上次给assistant的错误格式的指令：\n{self.last_instruction}"
-            )
-
-        self.agent.conversation["default"][1:] = self.get_conversation_history(message["conversation"])
-
-        if "find_and_click_element" in json.dumps(self.tools_json):
-            instruction_prompt = await get_current_screen_image_message(instruction_prompt)
-
-        raw_response = await self.agent.ask_async(instruction_prompt)
-
-        if "fetch_gpt_response_stream HTTP Error', 'status_code': 404" in raw_response:
-            raise Exception(f"Model: {self.config['engine']} not found!")
-        if "'status_code': 413" in raw_response or \
-        "'status_code': 400" in raw_response:
-            self.broker.publish({"status": "error", "result": raw_response}, self.status_topic)
-            return
-
-        self.broker.publish({"status": "new_message", "result": "\n🤖 指令智能体:\n" + raw_response}, self.status_topic)
-
-        self.last_instruction = raw_response
-        instruction = extract_xml_content(raw_response, "instructions")
-        if instruction:
-            if len(message["conversation"]) == 1:
-                instruction = (
-                    "任务描述：\n"
-                    f"<goal>{self.goal}</goal>\n\n"
-                    "你作为指令的**执行者**，而非任务的**规划师**，你必须严格遵循以下单步工作流程：\n"
-                    "**执行指令**\n"
-                    "   - **严格遵从：** 只执行我当前下达的明确指令。在我明确给出下一步指令前，绝不擅自行动或推测、执行任何未明确要求的后续步骤。\n"
-                    "   - **严禁越权：** 禁止执行任何我未指定的步骤。`<goal>` 标签中的内容仅为背景信息，不得据此进行任务规划或推测。\n"
-                    "**汇报结果**\n"
-                    "   - **聚焦单步：** 指令完成后，仅汇报该步骤的执行结果与产出。\n"
-                    "**暂停等待**\n"
-                    "   - **原地待命：** 汇报后，任务暂停。在收到我新的指令前，严禁发起任何新的工具调用或操作。\n"
-                    "   - **请求指令：** 回复的最后必须明确请求我提供下一步指令。\n"
-                    "**注意：** 禁止完成超出下面我未规定的步骤，`<goal>` 标签中的内容仅为背景信息。"
-                    "现在开始执行第一步：\n"
-                    f"{instruction}"
-                )
-            self.broker.publish({"instruction": instruction, "conversation": message["conversation"]}, self.publish_topic)
-        else:
-            print("\n❌ 指令智能体生成的指令不符合要求，正在重新生成。")
-            self.broker.publish(message, self.error_topic)
-
-
-class WorkerAgent(BaseAgent):
-    """Executes instructions and publishes results to a message broker."""
-    def __init__(self, goal: str, tools_json: List, agent_config: Dict, work_dir: str, cache_messages: Union[bool, List[Dict]], broker: MessageBroker, listen_topic: str, publish_topic: str, status_topic: str):
-        super().__init__(goal, tools_json, agent_config, work_dir, cache_messages, broker, listen_topic, publish_topic, status_topic)
-
-        if self.cache_messages and isinstance(self.cache_messages, list) and len(self.cache_messages) > 1:
-            first_user_message = replace_xml_content(self.cache_messages[1]["content"], "goal", goal)
-            self.config["cache_messages"] = self.cache_messages[0:1] + [{"role": "user", "content": first_user_message}] + self.cache_messages[2:]
-
-        self.agent = chatgpt(**self.config)
-
-    async def handle_message(self, message: Dict):
-        """Receives an instruction, executes it, and publishes the response."""
-
-        if message.get("instruction") == "Initial kickoff":
-            self.broker.publish({
-                "conversation": self.agent.conversation["default"]
-            }, self.publish_topic)
-            return
-
-        instruction = message["instruction"]
-        if "find_and_click_element" in json.dumps(self.tools_json):
-            instruction = await get_current_screen_image_message(instruction)
-        response = await self.agent.ask_async(instruction)
-
-        if response.strip() == '':
-            print("\n❌ 工作智能体回复为空，请重新生成指令。")
-            self.broker.publish(message, self.error_topic)
-        else:
-            self.broker.publish({"status": "new_message", "result": "\n✅ 工作智能体:\n" + response}, self.status_topic)
-            self.broker.publish({
-                "conversation": self.agent.conversation["default"]
-            }, self.publish_topic)
-
-class Tee:
-    def __init__(self, *files):
-        self.files = files
-
-    def write(self, obj):
-        for f in self.files:
-            f.write(obj)
-            f.flush()
-
-    def flush(self):
-        for f in self.files:
-            f.flush()
-
-broker = MessageBroker()
-mcp_manager = MCPManager()
-
-class BrokerWorker:
-    """The 'glue' class that orchestrates agents via a MessageBroker."""
-    def __init__(self, goal: str, tools: List[Union[str, Dict]], work_dir: str, cache_messages: Union[bool, List[Dict]] = None, broker: MessageBroker = None, mcp_manager: MCPManager = None):
-        self.goal = goal
-        self.tools = tools
-        self.work_dir = Path(work_dir)
-        self.cache_messages = cache_messages
-
-        self.broker = broker
-        self.mcp_manager = mcp_manager
-        self.task_completion_event = asyncio.Event()
-        self.final_result = None
-        self._status_subscription = None
-        self.setup()
-
-        self.channel = self.broker.request_channel()
-        self.INSTRUCTION_TOPIC = self.channel + ".instructions"
-        self.WORKER_RESPONSE_TOPIC = self.channel + ".worker_responses"
-        self.TASK_STATUS_TOPIC =self.channel +  ".task_status"
-
-    def setup(self):
-        cache_dir = self.work_dir / ".beswarm"
-        cache_dir.mkdir(parents=True, exist_ok=True)
-        task_manager.set_root_path(self.work_dir)
-        self.cache_file = cache_dir / "work_agent_conversation_history.json"
-        if not self.cache_file.exists():
-            self.cache_file.write_text("[]", encoding="utf-8")
-
-        DEBUG = os.getenv("DEBUG", "false").lower() in ("true", "1", "t", "yes")
-        if DEBUG:
-            log_file = open(cache_dir / "history.log", "a", encoding="utf-8")
-            log_file.write(f"========== {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} ==========\n")
-            original_stdout = sys.stdout
-            original_stderr = sys.stderr
-            sys.stdout = Tee(original_stdout, log_file)
-            sys.stderr = Tee(original_stderr, log_file)
-
-    async def _configure_tools(self):
-        mcp_list = [item for item in self.tools if isinstance(item, dict)]
-        if mcp_list:
-            for mcp_item in mcp_list:
-                mcp_name, mcp_config = list(mcp_item.items())[0]
-                await self.mcp_manager.add_server(mcp_name, mcp_config)
-                client = self.mcp_manager.clients.get(mcp_name)
-                await register_mcp_tools(client, registry)
-            all_mcp_tools = await self.mcp_manager.get_all_tools()
-            self.tools.extend([tool.name for tool in sum(all_mcp_tools.values(), [])])
-        self.tools = [item for item in self.tools if not isinstance(item, dict)]
-        if "task_complete" not in self.tools: self.tools.append("task_complete")
-        self.tools_json = [value for _, value in get_function_call_list(self.tools).items()]
-
-    def _task_status_subscriber(self, message: Dict):
-        """Subscriber for task status changes."""
-        if message.get("status") == "finished":
-            self.final_result = message.get("result")
-            self.task_completion_event.set()
-
-        if message.get("status") == "error":
-            raise Exception(message.get("result"))
-
-        if message.get("status") == "new_message":
-            print(message.get("result"))
-
-    def _setup_agents(self):
-        instruction_agent_config = {
-            "api_key": os.getenv("API_KEY"), "api_url": os.getenv("BASE_URL"),
-            "engine": os.getenv("MODEL"),
-            "system_prompt": instruction_system_prompt.format(
-                os_version=platform.platform(), tools_list=self.tools_json,
-                workspace_path=self.work_dir, current_time=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            ),
-            "print_log": os.getenv("DEBUG", "false").lower() in ("true", "1", "t", "yes"),
-            "temperature": 0.7, "use_plugins": False
-        }
-
-        worker_agent_config = {
-            "api_key": os.getenv("API_KEY"), "api_url": os.getenv("BASE_URL"),
-            "engine": os.getenv("FAST_MODEL") or os.getenv("MODEL"),
-            "system_prompt": worker_system_prompt.format(
-                os_version=platform.platform(), workspace_path=self.work_dir,
-                shell=os.getenv('SHELL', 'Unknown'), current_time=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                tools_list=self.tools_json
-            ),
-            "print_log": True, "temperature": 0.5, "function_call_max_loop": 100
-        }
-
-        instruction_agent = InstructionAgent(
-            goal=self.goal, tools_json=self.tools_json, agent_config=instruction_agent_config, work_dir=self.work_dir, cache_messages=self.cache_messages,
-            broker=self.broker, listen_topic=self.WORKER_RESPONSE_TOPIC,
-            publish_topic=self.INSTRUCTION_TOPIC, status_topic=self.TASK_STATUS_TOPIC
-        )
-
-        worker_agent = WorkerAgent(
-            goal=self.goal, tools_json=self.tools_json, agent_config=worker_agent_config, work_dir=self.work_dir, cache_messages=self.cache_messages,
-            broker=self.broker, listen_topic=self.INSTRUCTION_TOPIC,
-            publish_topic=self.WORKER_RESPONSE_TOPIC, status_topic=self.TASK_STATUS_TOPIC
-        )
-        return instruction_agent, worker_agent
-
-    async def run(self):
-        """Sets up subscriptions and starts the workflow."""
-        os.chdir(self.work_dir.absolute())
-        await self._configure_tools()
-
-        instruction_agent, worker_agent = self._setup_agents()
-
-        self.broker.publish({"instruction": "Initial kickoff"}, self.INSTRUCTION_TOPIC)
-
-        self._status_subscription = self.broker.subscribe(self._task_status_subscriber, self.TASK_STATUS_TOPIC)
-        await self.task_completion_event.wait()
-
-        instruction_agent.dispose()
-        worker_agent.dispose()
-        self._status_subscription.dispose()
-        await self.mcp_manager.cleanup()
-        return self.final_result
-
-    async def stream_run(self):
-        """Runs the workflow and yields status messages."""
-        os.chdir(self.work_dir.absolute())
-        await self._configure_tools()
-
-        instruction_agent, worker_agent = self._setup_agents()
-
-        self.broker.publish({"instruction": "Initial kickoff"}, self.INSTRUCTION_TOPIC)
-
-        try:
-            async for message in self.broker.iter_topic(self.TASK_STATUS_TOPIC):
-                if message.get("status") == "new_message":
-                    yield message.get("result")
-                elif message.get("status") == "finished":
-                    yield message.get("result")
-                    break
-                elif message.get("status") == "error":
-                    raise Exception(message.get("result"))
-        finally:
-            instruction_agent.dispose()
-            worker_agent.dispose()
-            await self.mcp_manager.cleanup()
+from ..core import mcp_manager, broker, task_manager
+from ..agents.planact import BrokerWorker
+from ..aient.src.aient.plugins import register_tool
 
 
 @register_tool()
 async def worker(goal: str, tools: List[Union[str, Dict]], work_dir: str, cache_messages: Union[bool, List[Dict]] = None):
     start_time = datetime.now()
-    worker_instance = BrokerWorker(goal, tools, work_dir, cache_messages, broker, mcp_manager)
+    worker_instance = BrokerWorker(goal, tools, work_dir, cache_messages, broker, mcp_manager, task_manager)
     result = await worker_instance.run()
     end_time = datetime.now()
     print(f"\n任务开始时间: {start_time.strftime('%Y-%m-%d %H:%M:%S')}")
@@ -356,12 +20,10 @@ async def worker(goal: str, tools: List[Union[str, Dict]], work_dir: str, cache_
 @register_tool()
 async def worker_gen(goal: str, tools: List[Union[str, Dict]], work_dir: str, cache_messages: Union[bool, List[Dict]] = None):
     start_time = datetime.now()
-    worker_instance = BrokerWorker(goal, tools, work_dir, cache_messages, broker, mcp_manager)
+    worker_instance = BrokerWorker(goal, tools, work_dir, cache_messages, broker, mcp_manager, task_manager)
     async for result in worker_instance.stream_run():
         yield result
     end_time = datetime.now()
     print(f"\n任务开始时间: {start_time.strftime('%Y-%m-%d %H:%M:%S')}")
     print(f"任务结束时间: {end_time.strftime('%Y-%m-%d %H:%M:%S')}")
-    print(f"总用时: {end_time - start_time}")
-
-from .taskmanager import task_manager
+    print(f"总用时: {end_time - start_time}")

{beswarm-0.2.36.dist-info → beswarm-0.2.37.dist-info}/METADATA

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

{beswarm-0.2.36.dist-info → beswarm-0.2.37.dist-info}/RECORD

@@ -1,7 +1,10 @@
 beswarm/__init__.py,sha256=HZjUOJtZR5QhMuDbq-wukQQn1VrBusNWai_ysGo-VVI,20
 beswarm/broker.py,sha256=RtnQZVbhf25acUHahNBiaS5FGxcrj0rhBhkon9gFY_M,9873
+beswarm/core.py,sha256=_J_LPc0HZFQTLGHy021OMEh2WbsjL_hc6jxd2engpyY,216
 beswarm/prompt.py,sha256=5JMfOuXWHscsaeDzwBn223mj9N85eAQdOHXQZk7zeWE,32238
+beswarm/taskmanager.py,sha256=oyvmxZmiguUXx1vYDQIuHS_GKDHEoDBhQ2Bjo4s128Q,9329
 beswarm/utils.py,sha256=xxbNifOPlfcVkKmF_qFzuEnZgF3MQg3mnOfz1EF0Qss,6697
+beswarm/agents/planact.py,sha256=-wS9bVUJRWfUePBh_F6crCSeFIq6rl4RewlLls4d4oE,17322
 beswarm/aient/main.py,sha256=SiYAIgQlLJqYusnTVEJOx1WNkSJKMImhgn5aWjfroxg,3814
 beswarm/aient/setup.py,sha256=lSEY6pYNdIdUB8F3gkj0XsEos1FMkd_c6PfIt-hscII,487
 beswarm/aient/src/aient/__init__.py,sha256=SRfF7oDVlOOAi6nGKiJIUK6B_arqYLO9iSMp-2IZZps,21
@@ -126,7 +129,7 @@ beswarm/queries/tree-sitter-languages/ruby-tags.scm,sha256=vIidsCeE2A0vdFN18yXKq
 beswarm/queries/tree-sitter-languages/rust-tags.scm,sha256=9ljM1nzhfPs_ZTRw7cr2P9ToOyhGcKkCoN4_HPXSWi4,1451
 beswarm/queries/tree-sitter-languages/scala-tags.scm,sha256=UxQjz80JIrrJ7Pm56uUnQyThfmQNvwk7aQzPNypB-Ao,1761
 beswarm/queries/tree-sitter-languages/typescript-tags.scm,sha256=OMdCeedPiA24ky82DpgTMKXK_l2ySTuF2zrQ2fJAi9E,1253
-beswarm/tools/__init__.py,sha256=Q24EPaPvYzuwxmshvvCQR0-bXRllzxmMFiya8ZL5YEI,1472
+beswarm/tools/__init__.py,sha256=WUPfDbg7m6GIDL-vmWtSPtA_VNRATHNZETVh6y4y4tk,1448
 beswarm/tools/click.py,sha256=7g6x1X7ffTInGWp7112KS-MAQ5-8wa1Ze2sIipUIbjc,20884
 beswarm/tools/completion.py,sha256=BHMMZeDCNEnaoOuwOoJjkuU_idwDB43mD1bT63p_waU,590
 beswarm/tools/edit_file.py,sha256=iwWl7a8sTVq4vj0e1ny3H6UGcHfYnxALRGcLuk5hZS8,9155
@@ -136,9 +139,9 @@ beswarm/tools/request_input.py,sha256=gXNAJPOJektMqxJVyzNTFOeMQ7xUkO-wWMYH-r2Rdw
 beswarm/tools/screenshot.py,sha256=u6t8FCgW5YHJ_Oc4coo8e0F3wTusWE_-H8dFh1rBq9Q,1011
 beswarm/tools/search_arxiv.py,sha256=caVIUOzMhFu-r_gVgJZrH2EO9xI5iV_qLAg0b3Ie9Xg,8095
 beswarm/tools/search_web.py,sha256=LhgXOSHL9fwxg5T2AAOV4TTJkcJVLogsfRJW2faPvDE,16147
-beswarm/tools/taskmanager.py,sha256=n7G6cH96Tcz57MfiOffISMMAfUtr49_uikkeoCDCeRg,12940
-beswarm/tools/worker.py,sha256=4zQfVzUmXXnTTvyBPcnyVNM7TV6jzqw6P377ZmORIq0,18567
-beswarm-0.2.36.dist-info/METADATA,sha256=NoyWwKf45i-ic0OI2YnCCdGi-q-07Uh3QfUkMLszfYQ,3878
-beswarm-0.2.36.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-beswarm-0.2.36.dist-info/top_level.txt,sha256=pJw4O87wvt5882smuSO6DfByJz7FJ8SxxT8h9fHCmpo,8
-beswarm-0.2.36.dist-info/RECORD,,
+beswarm/tools/subtasks.py,sha256=isc0bo24vVe3jCWW1wdP7hD5OQymilyka-QR7VSxx78,3652
+beswarm/tools/worker.py,sha256=OVQeY3_I2Ornrv40BzIbd-kWfPd91GWLOziVNLl0NsQ,1383
+beswarm-0.2.37.dist-info/METADATA,sha256=Ts-1AWrJJkDa6_BfwhILt3prvZjrkfmIBGdBid7lY7U,3878
+beswarm-0.2.37.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+beswarm-0.2.37.dist-info/top_level.txt,sha256=pJw4O87wvt5882smuSO6DfByJz7FJ8SxxT8h9fHCmpo,8
+beswarm-0.2.37.dist-info/RECORD,,