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

beswarm/aient/setup.py

@@ -4,7 +4,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="aient",
-    version="1.1.53",
+    version="1.1.54",
     description="Aient: The Awakening of Agent.",
     long_description=Path.open(Path("README.md"), encoding="utf-8").read(),
     long_description_content_type="text/markdown",

beswarm/aient/src/aient/core/request.py

@@ -1354,7 +1354,8 @@ async def get_openrouter_payload(request, engine, provider, api_key=None):
 
     messages = []
     for msg in request.messages:
-        name = None
+        tool_calls = None
+        tool_call_id = None
         if isinstance(msg.content, list):
             content = []
             for item in msg.content:
@@ -1366,9 +1367,25 @@ async def get_openrouter_payload(request, engine, provider, api_key=None):
                     content.append(image_message)
         else:
             content = msg.content
-            name = msg.name
-        if name:
-            messages.append({"role": msg.role, "name": name, "content": content})
+            tool_calls = msg.tool_calls
+            tool_call_id = msg.tool_call_id
+
+        if tool_calls:
+            tool_calls_list = []
+            for tool_call in tool_calls:
+                tool_calls_list.append({
+                    "id": tool_call.id,
+                    "type": tool_call.type,
+                    "function": {
+                        "name": tool_call.function.name,
+                        "arguments": tool_call.function.arguments
+                    }
+                })
+                if provider.get("tools"):
+                    messages.append({"role": msg.role, "tool_calls": tool_calls_list})
+        elif tool_call_id:
+            if provider.get("tools"):
+                messages.append({"role": msg.role, "tool_call_id": tool_call_id, "content": content})
         else:
             # print("content", content)
             if isinstance(content, list):

beswarm/aient/src/aient/core/response.py

@@ -42,11 +42,12 @@ def gemini_json_poccess(response_str):
     is_thinking = safe_get(json_data, "parts", 0, "thought", default=False)
 
     function_call_name = safe_get(json_data, "functionCall", "name", default=None)
-    function_full_response = json.dumps(safe_get(json_data, "functionCall", "args", default=""))
+    function_full_response = safe_get(json_data, "functionCall", "args", default="")
+    function_full_response = json.dumps(function_full_response) if function_full_response else None
 
     blockReason = safe_get(json_data, 0, "promptFeedback", "blockReason", default=None)
 
-    return is_thinking, content, image_base64, function_call_name, function_full_response, blockReason, promptTokenCount, candidatesTokenCount, totalTokenCount
+    return is_thinking, content, image_base64, function_call_name, function_full_response, finishReason, blockReason, promptTokenCount, candidatesTokenCount, totalTokenCount
 
 async def fetch_gemini_response_stream(client, url, headers, payload, model):
     timestamp = int(datetime.timestamp(datetime.now()))
@@ -62,7 +63,6 @@ async def fetch_gemini_response_stream(client, url, headers, payload, model):
         parts_json = ""
         async for chunk in response.aiter_text():
             buffer += chunk
-            cache_buffer += chunk
 
             while "\n" in buffer:
                 line, buffer = buffer.split("\n", 1)
@@ -77,7 +77,7 @@ async def fetch_gemini_response_stream(client, url, headers, payload, model):
                         continue
 
                 # https://ai.google.dev/api/generate-content?hl=zh-cn#FinishReason
-                is_thinking, content, image_base64, function_call_name, function_full_response, blockReason, promptTokenCount, candidatesTokenCount, totalTokenCount = gemini_json_poccess(parts_json)
+                is_thinking, content, image_base64, function_call_name, function_full_response, finishReason, blockReason, promptTokenCount, candidatesTokenCount, totalTokenCount = gemini_json_poccess(parts_json)
 
                 if is_thinking:
                     sse_string = await generate_sse_response(timestamp, model, reasoning_content=content)
@@ -99,9 +99,10 @@ async def fetch_gemini_response_stream(client, url, headers, payload, model):
                 if parts_json == "[]" or blockReason == "PROHIBITED_CONTENT":
                     sse_string = await generate_sse_response(timestamp, model, stop="PROHIBITED_CONTENT")
                     yield sse_string
-                else:
+                elif finishReason:
                     sse_string = await generate_sse_response(timestamp, model, stop="stop")
                     yield sse_string
+                    break
 
                 parts_json = ""
 

beswarm/aient/src/aient/models/chatgpt.py

@@ -187,7 +187,8 @@ class chatgpt(BaseLLM):
         #     print(json.dumps(replaced_text, indent=4, ensure_ascii=False))
         while message_index < conversation_len:
             if self.conversation[convo_id][message_index]["role"] == self.conversation[convo_id][message_index + 1]["role"]:
-                if self.conversation[convo_id][message_index].get("content") and self.conversation[convo_id][message_index + 1].get("content"):
+                if self.conversation[convo_id][message_index].get("content") and self.conversation[convo_id][message_index + 1].get("content") \
+                and self.conversation[convo_id][message_index].get("content") != self.conversation[convo_id][message_index + 1].get("content"):
                     if type(self.conversation[convo_id][message_index + 1]["content"]) == str \
                     and type(self.conversation[convo_id][message_index]["content"]) == list:
                         self.conversation[convo_id][message_index + 1]["content"] = [{"type": "text", "text": self.conversation[convo_id][message_index + 1]["content"]}]
@@ -754,8 +755,8 @@ class chatgpt(BaseLLM):
 
         # 打印日志
         if self.print_log:
-            print("api_url", kwargs.get('api_url', self.api_url.chat_url) == url)
-            print("api_url", kwargs.get('api_url', self.api_url.chat_url))
+            # print("api_url", kwargs.get('api_url', self.api_url.chat_url) == url)
+            # print("api_url", kwargs.get('api_url', self.api_url.chat_url))
             print("api_url", url)
             # print("headers", headers)
             print("api_key", kwargs.get('api_key', self.api_key))

beswarm/broker.py

@@ -0,0 +1,235 @@
+"""
+使用 Reaktiv 模拟消息队列 (发布/订阅)
+
+本模块提供了一个 MessageBroker 类，它利用 Reaktiv 的核心原语（Signal, Computed, Effect）
+来构建一个功能类似消息队列的、内存中的发布/订阅系统。
+"""
+import asyncio
+from typing import Callable, Any, List, Union, Tuple
+
+from reaktiv import Signal, Effect, Computed, untracked, to_async_iter
+
+class Subscription:
+    """封装一个或多个 Effect，提供统一的暂停、恢复和取消订阅的接口。"""
+
+    def __init__(
+        self,
+        broker: "MessageBroker",
+        callback: Callable[[Any], None],
+        effects_with_topics: List[Tuple[Effect, str]],
+    ):
+        self._broker = broker
+        self._callback = callback
+        self._effects_with_topics = effects_with_topics
+        self._effects = [e for e, t in effects_with_topics]
+        self.is_paused = Signal(False)
+
+    def pause(self):
+        """暂停订阅，将不再处理新消息。"""
+        self.is_paused.set(True)
+        if self._broker.debug:
+            print(f"Subscription paused.")
+
+    def resume(self):
+        """恢复订阅，将继续处理新消息。"""
+        self.is_paused.set(False)
+        if self._broker.debug:
+            print(f"Subscription resumed.")
+
+    def dispose(self):
+        """永久取消订阅并清理资源。"""
+        for effect, topic in self._effects_with_topics:
+            effect.dispose()
+            # 从代理的注册表中移除
+            if (
+                topic in self._broker._effects_registry
+                and self._callback in self._broker._effects_registry[topic]
+            ):
+                del self._broker._effects_registry[topic][self._callback]
+                if not self._broker._effects_registry[topic]:
+                    del self._broker._effects_registry[topic]
+        if self._broker.debug:
+            print(f"Subscription disposed.")
+
+
+class MessageBroker:
+    """一个简单的消息代理，使用 Reaktiv Signal 和 Computed 模拟消息队列和派生主题。"""
+
+    def __init__(self, debug: bool = False):
+        # 现在 _topics 可以存储 Signal (原始主题) 或 Computed (派生主题)。
+        self._topics: dict[str, Union[Signal[List[Any]], Computed[List[Any]]]] = {}
+        # 新增: 注册表来跟踪 (主题, 回调) -> Effect 的映射
+        self._effects_registry: dict[str, dict[Callable, Effect]] = {}
+        self.debug = debug
+        self._channel_counters: dict[str, int] = {}
+        # print("消息代理已启动。")
+
+    def request_channel(self, prefix: str = "channel") -> str:
+        """
+        申请一个新的、唯一的频道名称。
+
+        此方法为每个前缀维护一个独立的计数器。
+        返回一个基于前缀和该前缀当前计数值的唯一字符串，例如 'channel0', 'worker_0', 'channel1'。
+        它不直接创建主题或任何关联的 Signal；这将在首次发布或订阅到返回的主题名称时发生。
+
+        Args:
+            prefix: 频道名称的前缀。默认为 'channel'。
+
+        Returns:
+            一个基于前缀的唯一主题/频道名称字符串。
+        """
+        if prefix not in self._channel_counters:
+            self._channel_counters[prefix] = 0
+
+        channel_name = f"{prefix}{self._channel_counters[prefix]}"
+        self._channel_counters[prefix] += 1
+        return channel_name
+
+    def publish(self, message: Any, topic: Union[str, List[str]] = "default"):
+        """
+        向一个或多个主题发布一条新消息。
+        """
+        topics_to_publish = [topic] if isinstance(topic, str) else topic
+
+        for t in topics_to_publish:
+            # 只能向原始主题发布
+            topic_signal = self._topics.get(t)
+            if not isinstance(topic_signal, Signal):
+                print(f"警告：主题 '{t}' 不存在或不是一个可发布的原始主题。正在创建...")
+                topic_signal = Signal([])
+                self._topics[t] = topic_signal
+
+            # 通过 update 方法追加新消息来触发更新。
+            # 必须创建一个新列表才能让 Reaktiv 检测到变化。
+            topic_signal.update(lambda messages: messages + [message])
+            if self.debug:
+                print(f"新消息发布到 '{t}': \"{message}\"")
+
+    def subscribe(self, callback: Callable[[Any], None], topic: Union[str, List[str]] = "default") -> Subscription:
+        """
+        订阅一个或多个主题。每当有新消息发布时，回调函数将被调用。
+        此方法是幂等的：重复订阅同一个回调到同一个主题不会产生副作用。
+
+        Args:
+            callback: 处理消息的回调函数。
+            topic: 要订阅的主题，可以是单个字符串或字符串列表。
+
+        Returns:
+            一个 Subscription 实例，用于管理订阅的生命周期（暂停、恢复、取消）。
+        """
+        topics_to_subscribe = [topic] if isinstance(topic, str) else topic
+        created_effects_with_topics = []
+
+        # 创建一个 Subscription 实例来管理所有相关的 effects
+        # 它需要提前创建，以便 effect_factory 可以访问它的 is_paused 信号
+        subscription = Subscription(self, callback, created_effects_with_topics)
+
+        for t in topics_to_subscribe:
+            # 检查此回调是否已订阅该主题
+            if t in self._effects_registry and callback in self._effects_registry.get(t, {}):
+                print(f"警告：订阅者 '{callback.__name__}' 已经订阅了 '{t}' 主题。跳过。")
+                continue
+
+            if t not in self._topics:
+                # 如果订阅一个不存在的主题，也为它创建一个 Signal
+                self._topics[t] = Signal([])
+
+            # 使用一个工厂函数来为每个主题创建独立的闭包，
+            # 确保每个订阅都有自己的 'last_processed_index'。
+            def effect_factory(current_topic: str):
+                last_processed_index = 0
+
+                def process_new_messages():
+                    nonlocal last_processed_index
+                    all_messages = self._topics[current_topic]()
+
+                    # 如果暂停了，只更新索引以跳过消息，不进行处理
+                    if untracked(subscription.is_paused):
+                        last_processed_index = len(all_messages)
+                        return
+
+                    new_messages = all_messages[last_processed_index:]
+
+                    if new_messages:
+                        if self.debug:
+                            print(f"    -> 订阅者 '{callback.__name__}' 在 '{current_topic}' 主题上收到 {len(new_messages)} 条新消息。")
+                        for msg in new_messages:
+                            try:
+                                if asyncio.iscoroutinefunction(callback):
+                                    asyncio.create_task(callback(msg))
+                                else:
+                                    callback(msg)
+                            except Exception as e:
+                                print(f"    !! 在订阅者 '{callback.__name__}' 中发生错误: {e}")
+
+                    last_processed_index = len(all_messages)
+                return process_new_messages
+
+            if self.debug:
+                print(f"订阅者 '{callback.__name__}' 已订阅 '{t}' 主题。")
+            effect = Effect(effect_factory(t))
+
+            # 注册新的 effect
+            if t not in self._effects_registry:
+                self._effects_registry[t] = {}
+            self._effects_registry[t][callback] = effect
+
+            created_effects_with_topics.append((effect, t))
+
+        return subscription
+
+    def create_derived_topic(self, new_topic_name: str, source_topic: str, transform_fn: Callable[[List[Any]], List[Any]]):
+        """
+        创建一个派生主题。
+
+        这个新主题的内容是一个 Computed 信号，它会根据源主题的内容和转换函数自动更新。
+
+        Args:
+            new_topic_name: 派生主题的名称。
+            source_topic: 源主题的名称。
+            transform_fn: 一个函数，接收源主题的消息列表并返回新的消息列表。
+        """
+        if new_topic_name in self._topics:
+            print(f"警告：主题 '{new_topic_name}' 已存在。")
+            return
+
+        source_signal = self._topics.get(source_topic)
+        if not isinstance(source_signal, (Signal, Computed)):
+            print(f"错误：源主题 '{source_topic}' 不存在。")
+            return
+
+        # 创建一个 Computed 信号作为派生主题
+        derived_signal = Computed(
+            lambda: transform_fn(source_signal())
+        )
+
+        self._topics[new_topic_name] = derived_signal
+        if self.debug:
+            print(f"已从 '{source_topic}' 创建派生主题 '{new_topic_name}'。")
+
+    async def iter_topic(self, topic: str):
+        """
+        返回一个异步迭代器，用于通过 async for 循环消费主题消息。
+
+        Args:
+            topic: 要订阅的主题名称。
+
+        Yields:
+            主题中的新消息。
+        """
+        if topic not in self._topics:
+            # 如果主题不存在，创建一个，以防万一
+            self._topics[topic] = Signal([])
+
+        topic_signal = self._topics[topic]
+        last_yielded_index = 0
+
+        # to_async_iter 会在每次 topic_signal 更新时产生一个新的消息列表
+        async for all_messages in to_async_iter(topic_signal):
+            new_messages = all_messages[last_yielded_index:]
+            for msg in new_messages:
+                # 过滤掉内部的 'init' 消息
+                if msg != "init":
+                    yield msg
+
+            last_yielded_index = len(all_messages)

beswarm/tools/click.py

@@ -223,6 +223,7 @@ Returns:
 
     # 工作agent初始化
     click_agent = chatgpt(**click_agent_config)
+    # https://developers.googleblog.com/en/conversational-image-segmentation-gemini-2-5/
     prompt = f"Give the segmentation masks for the {target_element}. Output a JSON list of segmentation masks where each entry contains the 2D bounding box in \"box_2d\" (format: ymin, xmin, ymax, xmax) and the mask in \"mask\". Only output the one that meets the criteria the most."
 
     print("正在截取当前屏幕...")

beswarm/tools/search_web.py

@@ -2,9 +2,7 @@ import re
 import os
 import json
 import httpx
-from urllib.parse import quote_plus
 import threading
-import time
 
 from ..aient.src.aient.plugins import register_tool, get_url_content # Assuming a similar plugin structure
 
@@ -364,7 +362,7 @@ if __name__ == '__main__':
         # search_query = "美国"
         # search_query = "machine learning models for higher heating value prediction using proximate vs ultimate analysis"
         # search_query = "patent driver cognitive load monitoring micro-expression thermal imaging fusion"
-        search_query = "Self-supervised learning for seismology"
+        search_query = "deep learning models for siRNA activity"
         print(f"Performing web search for: '{search_query}'")
         results = await search_web(search_query)  # results is a list of URLs
 

beswarm/tools/worker.py

@@ -4,9 +4,186 @@ 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):
@@ -21,435 +198,170 @@ class Tee:
         for f in self.files:
             f.flush()
 
-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 MCPClient, convert_tool_format, MCPManager
+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()
 
-manager = MCPManager()
 
 @register_tool()
-async def worker(goal, tools, work_dir, cache_messages=None):
-    cache_dir = Path(work_dir) / ".beswarm"
-    cache_dir.mkdir(parents=True, exist_ok=True)
-    task_manager.set_root_path(work_dir)
-    cache_file = cache_dir / "work_agent_conversation_history.json"
-    if not cache_file.exists():
-        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 worker(goal: str, tools: List[Union[str, Dict]], work_dir: str, cache_messages: Union[bool, List[Dict]] = None):
     start_time = datetime.now()
-    os.chdir(Path(work_dir).absolute())
-    finish_flag = 0
-    goal_diff = None
-
-    mcp_list = [item for item in tools if isinstance(item, dict)]
-    if mcp_list:
-        for mcp_item in mcp_list:
-            mcp_name, mcp_config = list(mcp_item.items())[0]
-            await manager.add_server(mcp_name, mcp_config)
-            client = manager.clients.get(mcp_name)
-            await register_mcp_tools(client, registry)
-        all_tools = await manager.get_all_tools()
-        mcp_tools_name = [tool.name for tool in sum(all_tools.values(), [])]
-        tools += mcp_tools_name
-
-    tools = [item for item in tools if not isinstance(item, dict)]
-    if "task_complete" not in tools:
-        tools.append("task_complete")
-
-    tools_json = [value for _, value in get_function_call_list(tools).items()]
-    work_agent_system_prompt = worker_system_prompt.format(
-        os_version=platform.platform(),
-        workspace_path=work_dir,
-        shell=os.getenv('SHELL', 'Unknown'),
-        current_time=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-        tools_list=tools_json
-    )
-
-    work_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": work_agent_system_prompt,
-        "print_log": True,
-        # "max_tokens": 8000,
-        "temperature": 0.5,
-        "function_call_max_loop": 100,
-    }
-    if cache_messages:
-        if isinstance(cache_messages, bool) and cache_messages == True:
-            cache_messages = json.loads(cache_file.read_text(encoding="utf-8"))
-        if cache_messages and isinstance(cache_messages, list) and len(cache_messages) > 1:
-            old_goal = extract_xml_content(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)
-                goal_diff = '\n'.join(changed_lines).strip()
-            first_user_message = replace_xml_content(cache_messages[1]["content"], "goal", goal)
-            work_agent_config["cache_messages"] = cache_messages[0:1] + [{"role": "user", "content": first_user_message}] + cache_messages[2:]
-
-    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=tools_json, workspace_path=work_dir, current_time=datetime.now().strftime("%Y-%m-%d %H:%M:%S")),
-        "print_log": DEBUG,
-        # "max_tokens": 4000,
-        "temperature": 0.7,
-        "use_plugins": False,
-    }
-
-    # 工作agent初始化
-    work_agent = chatgpt(**work_agent_config)
-    async def instruction_agent_task():
-        last_instruction = None
-        while True:
-            instruction_prompt = "".join([
-                    "</work_agent_conversation_end>\n\n",
-                    f"任务目标: {goal}\n\n",
-                    f"任务目标新变化：\n{goal_diff}\n\n" if goal_diff else "",
-                    "在 tag <work_agent_conversation_start>...</work_agent_conversation_end> 之前的对话历史都是工作智能体的对话历史。\n\n",
-                    "根据以上对话历史和目标，请生成下一步指令。如果任务已完成，指示工作智能体调用task_complete工具。\n\n",
-                ])
-            if last_instruction and 'fetch_gpt_response_stream HTTP Error' not in last_instruction:
-                instruction_prompt = (
-                    f"{instruction_prompt}\n\n"
-                    "你生成的指令格式错误，必须把给assistant的指令放在<instructions>...</instructions>标签内。请重新生成格式正确的指令。"
-                    f"这是你上次给assistant的错误格式的指令：\n{last_instruction}"
-                )
-            # 让指令agent分析对话历史并生成新指令
-            instruction_agent = chatgpt(**instruction_agent_config)
-            conversation_history = copy.deepcopy(work_agent.conversation["default"])
-            if len(conversation_history) > 1 and conversation_history[-2]["role"] == "user" \
-            and "<task_complete_message>" in conversation_history[-2]["content"]:
-                task_complete_message = extract_xml_content(conversation_history[-2]["content"], "task_complete_message")
-                # del work_agent.conversation["default"][-4:]
-                return "<task_complete_message>" + task_complete_message + "</task_complete_message>"
-
-            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})
-
-            instruction_agent.conversation["default"][1:] = conversation_history
-            if "find_and_click_element" in str(tools_json):
-                instruction_prompt = await get_current_screen_image_message(instruction_prompt)
-            next_instruction = await instruction_agent.ask_async(instruction_prompt)
-            print("\n🤖 指令智能体生成的下一步指令:", next_instruction)
-            if "fetch_gpt_response_stream HTTP Error', 'status_code': 404" in next_instruction:
-                raise Exception(f"Model: {instruction_agent_config['engine']} not found!")
-            if "'status_code': 413" in next_instruction or \
-            "'status_code': 400" in next_instruction:
-                end_time = datetime.now()
-                total_time = end_time - start_time
-                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"总用时: {total_time}")
-                raise Exception(f"The request body is too long, please try again.")
-
-            last_instruction = next_instruction
-            next_instruction = extract_xml_content(next_instruction, "instructions")
-            if not next_instruction:
-                print("\n❌ 指令智能体生成的指令不符合要求，请重新生成。")
-                continue
-            else:
-                if conversation_history == []:
-                    next_instruction = (
-                        "任务描述：\n"
-                        f"<goal>{goal}</goal>\n\n"
-                        "你作为指令的**执行者**，而非任务的**规划师**，你必须严格遵循以下单步工作流程：\n"
-                        "**执行指令**\n"
-                        "   - **严格遵从：** 只执行我当前下达的明确指令。在我明确给出下一步指令前，绝不擅自行动或推测、执行任何未明确要求的后续步骤。\n"
-                        "   - **严禁越权：** 禁止执行任何我未指定的步骤。`<goal>` 标签中的内容仅为背景信息，不得据此进行任务规划或推测。\n"
-                        "**汇报结果**\n"
-                        "   - **聚焦单步：** 指令完成后，仅汇报该步骤的执行结果与产出。\n"
-                        "**暂停等待**\n"
-                        "   - **原地待命：** 汇报后，任务暂停。在收到我新的指令前，严禁发起任何新的工具调用或操作。\n"
-                        "   - **请求指令：** 回复的最后必须明确请求我提供下一步指令。\n"
-                        "**注意：** 禁止完成超出下面我未规定的步骤，`<goal>` 标签中的内容仅为背景信息。"
-                        "现在开始执行第一步：\n"
-                        f"{next_instruction}"
-                    )
-                break
-        return next_instruction
-
-    need_instruction = True
-    result = None
-    while True:
-        next_instruction = ''
-        if need_instruction:
-            next_instruction = await instruction_agent_task()
-
-            # 检查任务是否完成
-            if "<task_complete_message>" in next_instruction:
-                if finish_flag == 0:
-                    finish_flag = 1
-                    continue
-                elif finish_flag == 1:
-                    result = extract_xml_content(next_instruction, "task_complete_message")
-                    break
-            else:
-                finish_flag = 0
-        if "find_and_click_element" in str(tools_json):
-            next_instruction = await get_current_screen_image_message(next_instruction)
-        result = await work_agent.ask_async(next_instruction)
-        if result.strip() == '' or result.strip() == '</content>\n</write_to_file>':
-            print("\n❌ 工作智能体回复为空，请重新生成指令。")
-            need_instruction = False
-            continue
-        print("✅ 工作智能体回复:", result)
-        need_instruction = True
-
+    worker_instance = BrokerWorker(goal, tools, work_dir, cache_messages, broker, mcp_manager)
+    result = await worker_instance.run()
     end_time = datetime.now()
-    total_time = end_time - start_time
-    print("\n✅ 任务已完成：", result)
     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"总用时: {total_time}")
-    await manager.cleanup()
+    print(f"总用时: {end_time - start_time}")
     return result
 
-async def worker_gen(goal, tools, work_dir, cache_messages=None):
-    cache_dir = Path(work_dir) / ".beswarm"
-    cache_dir.mkdir(parents=True, exist_ok=True)
-    task_manager.set_root_path(work_dir)
-    cache_file = cache_dir / "work_agent_conversation_history.json"
-    if not cache_file.exists():
-        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)
-
+@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()
-    os.chdir(Path(work_dir).absolute())
-    finish_flag = 0
-    goal_diff = None
-
-    mcp_list = [item for item in tools if isinstance(item, dict)]
-    if mcp_list:
-        for mcp_item in mcp_list:
-            mcp_name, mcp_config = list(mcp_item.items())[0]
-            await manager.add_server(mcp_name, mcp_config)
-            client = manager.clients.get(mcp_name)
-            await register_mcp_tools(client, registry)
-        all_tools = await manager.get_all_tools()
-        mcp_tools_name = [tool.name for tool in sum(all_tools.values(), [])]
-        tools += mcp_tools_name
-
-    tools = [item for item in tools if not isinstance(item, dict)]
-    if "task_complete" not in tools:
-        tools.append("task_complete")
-
-    tools_json = [value for _, value in get_function_call_list(tools).items()]
-    work_agent_system_prompt = worker_system_prompt.format(
-        os_version=platform.platform(),
-        workspace_path=work_dir,
-        shell=os.getenv('SHELL', 'Unknown'),
-        current_time=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-        tools_list=tools_json
-    )
-
-    work_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": work_agent_system_prompt,
-        "print_log": True,
-        # "max_tokens": 8000,
-        "temperature": 0.5,
-        "function_call_max_loop": 100,
-    }
-    if cache_messages:
-        if isinstance(cache_messages, bool) and cache_messages == True:
-            cache_messages = json.loads(cache_file.read_text(encoding="utf-8"))
-        if cache_messages and isinstance(cache_messages, list) and len(cache_messages) > 1:
-            old_goal = extract_xml_content(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)
-                goal_diff = '\n'.join(changed_lines).strip()
-            first_user_message = replace_xml_content(cache_messages[1]["content"], "goal", goal)
-            work_agent_config["cache_messages"] = cache_messages[0:1] + [{"role": "user", "content": first_user_message}] + cache_messages[2:]
-
-    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=tools_json, workspace_path=work_dir, current_time=datetime.now().strftime("%Y-%m-%d %H:%M:%S")),
-        "print_log": DEBUG,
-        # "max_tokens": 4000,
-        "temperature": 0.7,
-        "use_plugins": False,
-    }
-
-    # 工作agent初始化
-    work_agent = chatgpt(**work_agent_config)
-    async def instruction_agent_task():
-        last_instruction = None
-        while True:
-            instruction_prompt = "".join([
-                    "</work_agent_conversation_end>\n\n",
-                    f"任务目标: {goal}\n\n",
-                    f"任务目标新变化：\n{goal_diff}\n\n" if goal_diff else "",
-                    "在 tag <work_agent_conversation_start>...</work_agent_conversation_end> 之前的对话历史都是工作智能体的对话历史。\n\n",
-                    "根据以上对话历史和目标，请生成下一步指令。如果任务已完成，指示工作智能体调用task_complete工具。\n\n",
-                ])
-            if last_instruction and 'fetch_gpt_response_stream HTTP Error' not in last_instruction:
-                instruction_prompt = (
-                    f"{instruction_prompt}\n\n"
-                    "你生成的指令格式错误，必须把给assistant的指令放在<instructions>...</instructions>标签内。请重新生成格式正确的指令。"
-                    f"这是你上次给assistant的错误格式的指令：\n{last_instruction}"
-                )
-            # 让指令agent分析对话历史并生成新指令
-            instruction_agent = chatgpt(**instruction_agent_config)
-            conversation_history = copy.deepcopy(work_agent.conversation["default"])
-            if len(conversation_history) > 1 and conversation_history[-2]["role"] == "user" \
-            and "<task_complete_message>" in conversation_history[-2]["content"]:
-                task_complete_message = extract_xml_content(conversation_history[-2]["content"], "task_complete_message")
-                # del work_agent.conversation["default"][-4:]
-                return "<task_complete_message>" + task_complete_message + "</task_complete_message>"
-
-            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})
-
-            instruction_agent.conversation["default"][1:] = conversation_history
-            if "find_and_click_element" in str(tools_json):
-                instruction_prompt = await get_current_screen_image_message(instruction_prompt)
-            next_instruction = await instruction_agent.ask_async(instruction_prompt)
-            print("\n🤖 指令智能体生成的下一步指令:", next_instruction)
-            if "fetch_gpt_response_stream HTTP Error', 'status_code': 404" in next_instruction:
-                raise Exception(f"Model: {instruction_agent_config['engine']} not found!")
-            if "'status_code': 413" in next_instruction or \
-            "'status_code': 400" in next_instruction:
-                end_time = datetime.now()
-                total_time = end_time - start_time
-                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"总用时: {total_time}")
-                raise Exception(f"The request body is too long, please try again.")
-
-            last_instruction = next_instruction
-            next_instruction = extract_xml_content(next_instruction, "instructions")
-            if not next_instruction:
-                print("\n❌ 指令智能体生成的指令不符合要求，请重新生成。")
-                continue
-            else:
-                if conversation_history == []:
-                    next_instruction = (
-                        "任务描述：\n"
-                        f"<goal>{goal}</goal>\n\n"
-                        "你作为指令的**执行者**，而非任务的**规划师**，你必须严格遵循以下单步工作流程：\n"
-                        "**执行指令**\n"
-                        "   - **严格遵从：** 只执行我当前下达的明确指令。在我明确给出下一步指令前，绝不擅自行动或推测、执行任何未明确要求的后续步骤。\n"
-                        "   - **严禁越权：** 禁止执行任何我未指定的步骤。`<goal>` 标签中的内容仅为背景信息，不得据此进行任务规划或推测。\n"
-                        "**汇报结果**\n"
-                        "   - **聚焦单步：** 指令完成后，仅汇报该步骤的执行结果与产出。\n"
-                        "**暂停等待**\n"
-                        "   - **原地待命：** 汇报后，任务暂停。在收到我新的指令前，严禁发起任何新的工具调用或操作。\n"
-                        "   - **请求指令：** 回复的最后必须明确请求我提供下一步指令。\n"
-                        "**注意：** 禁止完成超出下面我未规定的步骤，`<goal>` 标签中的内容仅为背景信息。"
-                        "现在开始执行第一步：\n"
-                        f"{next_instruction}"
-                    )
-                break
-        return next_instruction
-
-    need_instruction = True
-    result = None
-    while True:
-        next_instruction = ''
-        if need_instruction:
-            next_instruction = await instruction_agent_task()
-
-            yield {"user": next_instruction}
-
-            # 检查任务是否完成
-            if "<task_complete_message>" in next_instruction:
-                if finish_flag == 0:
-                    finish_flag = 1
-                    continue
-                elif finish_flag == 1:
-                    result = extract_xml_content(next_instruction, "task_complete_message")
-                    break
-            else:
-                finish_flag = 0
-        if "find_and_click_element" in str(tools_json):
-            next_instruction = await get_current_screen_image_message(next_instruction)
-        result = await work_agent.ask_async(next_instruction)
-        if result.strip() == '' or result.strip() == '</content>\n</write_to_file>':
-            print("\n❌ 工作智能体回复为空，请重新生成指令。")
-            need_instruction = False
-            continue
-        yield {"assistant": result}
-        print("✅ 工作智能体回复:", result)
-        need_instruction = True
-
+    worker_instance = BrokerWorker(goal, tools, work_dir, cache_messages, broker, mcp_manager)
+    async for result in worker_instance.stream_run():
+        yield result
     end_time = datetime.now()
-    total_time = end_time - start_time
-    print("\n✅ 任务已完成：", result)
     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"总用时: {total_time}")
-    await manager.cleanup()
+    print(f"总用时: {end_time - start_time}")
 
-from .taskmanager import task_manager
+from .taskmanager import task_manager

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

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

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

@@ -1,14 +1,15 @@
 beswarm/__init__.py,sha256=HZjUOJtZR5QhMuDbq-wukQQn1VrBusNWai_ysGo-VVI,20
+beswarm/broker.py,sha256=RtnQZVbhf25acUHahNBiaS5FGxcrj0rhBhkon9gFY_M,9873
 beswarm/prompt.py,sha256=5JMfOuXWHscsaeDzwBn223mj9N85eAQdOHXQZk7zeWE,32238
 beswarm/utils.py,sha256=xxbNifOPlfcVkKmF_qFzuEnZgF3MQg3mnOfz1EF0Qss,6697
 beswarm/aient/main.py,sha256=SiYAIgQlLJqYusnTVEJOx1WNkSJKMImhgn5aWjfroxg,3814
-beswarm/aient/setup.py,sha256=LqjY1x8CQrcvFrHKFSyZpm5h6iBuosHIpZqXdCPnPes,487
+beswarm/aient/setup.py,sha256=lSEY6pYNdIdUB8F3gkj0XsEos1FMkd_c6PfIt-hscII,487
 beswarm/aient/src/aient/__init__.py,sha256=SRfF7oDVlOOAi6nGKiJIUK6B_arqYLO9iSMp-2IZZps,21
 beswarm/aient/src/aient/core/__init__.py,sha256=NxjebTlku35S4Dzr16rdSqSTWUvvwEeACe8KvHJnjPg,34
 beswarm/aient/src/aient/core/log_config.py,sha256=kz2_yJv1p-o3lUQOwA3qh-LSc3wMHv13iCQclw44W9c,274
 beswarm/aient/src/aient/core/models.py,sha256=d4MISNezTSe0ls0-fjuToI2SoT-sk5fWqAJuKVinIlo,7502
-beswarm/aient/src/aient/core/request.py,sha256=1tedDQf8GRv5Y7rYNE_596vQb4o7e1icaKAA7lIl4YY,76114
-beswarm/aient/src/aient/core/response.py,sha256=Ba0BwsIN2ozZC_UInkGS07qKlpo3dIei6rw0INQ66BE,33086
+beswarm/aient/src/aient/core/request.py,sha256=GrB8hQY1K8AF1O9f5g-hoY8fwZR4SUNNhvCDpuhHVl0,76822
+beswarm/aient/src/aient/core/response.py,sha256=LwaDyCuuT0RPxBwE08k8_Dmh0df_q7q4BUix7NcCJV8,33207
 beswarm/aient/src/aient/core/utils.py,sha256=8TR442o3VV7Kl9l6f6LlmOUQ1UDZ-aXMzQqm-qIrqE4,28166
 beswarm/aient/src/aient/core/test/test_base_api.py,sha256=pWnycRJbuPSXKKU9AQjWrMAX1wiLC_014Qc9hh5C2Pw,524
 beswarm/aient/src/aient/core/test/test_geminimask.py,sha256=HFX8jDbNg_FjjgPNxfYaR-0-roUrOO-ND-FVsuxSoiw,13254
@@ -17,7 +18,7 @@ beswarm/aient/src/aient/core/test/test_payload.py,sha256=8jBiJY1uidm1jzL-EiK0s6U
 beswarm/aient/src/aient/models/__init__.py,sha256=ouNDNvoBBpIFrLsk09Q_sq23HR0GbLAKfGLIFmfEuXE,219
 beswarm/aient/src/aient/models/audio.py,sha256=kRd-8-WXzv4vwvsTGwnstK-WR8--vr9CdfCZzu8y9LA,1934
 beswarm/aient/src/aient/models/base.py,sha256=z-Z0pJfTN2x0cuwfvu0BdMRY9O-RmLwHEnBIJN1x4Fg,6719
-beswarm/aient/src/aient/models/chatgpt.py,sha256=Yum3_-LgHmFUII0AljfNNfSc8gBhJzyPYAWZJyr4yFo,46969
+beswarm/aient/src/aient/models/chatgpt.py,sha256=UP7cn6Vo0bXzj6FpqTHIOjg1UygYQDXMSlUbXbH1uU4,47118
 beswarm/aient/src/aient/models/claude.py,sha256=JezghW7y0brl4Y5qiSHvnYR5prQCFywX4RViHt39pGI,26037
 beswarm/aient/src/aient/models/duckduckgo.py,sha256=1l7vYCs9SG5SWPCbcl7q6pCcB5AUF_r-a4l9frz3Ogo,8115
 beswarm/aient/src/aient/models/gemini.py,sha256=chGLc-8G_DAOxr10HPoOhvVFW1RvMgHd6mt--VyAW98,14730
@@ -126,7 +127,7 @@ beswarm/queries/tree-sitter-languages/rust-tags.scm,sha256=9ljM1nzhfPs_ZTRw7cr2P
 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/click.py,sha256=I62GF-bzcoNzhfu3DeWdiA88Sd_6gMFihrQSwFj4nks,20795
+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
 beswarm/tools/planner.py,sha256=lguBCS6kpwNPoXQvqH-WySabVubT82iyWOkJnjt6dXw,1265
@@ -134,10 +135,10 @@ beswarm/tools/repomap.py,sha256=YsTPq5MXfn_Ds5begcvHDnY_Xp2d4jH-xmWqNMHnNHY,4523
 beswarm/tools/request_input.py,sha256=gXNAJPOJektMqxJVyzNTFOeMQ7xUkO-wWMYH-r2Rdwk,942
 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=ybbdbJq80plooXLMiyjAMOSCEyZJ0hquGUpabBhfFx0,16195
+beswarm/tools/search_web.py,sha256=LhgXOSHL9fwxg5T2AAOV4TTJkcJVLogsfRJW2faPvDE,16147
 beswarm/tools/taskmanager.py,sha256=n7G6cH96Tcz57MfiOffISMMAfUtr49_uikkeoCDCeRg,12940
-beswarm/tools/worker.py,sha256=s6tN4JhA07qzTlP7xWiB0MjnBIJ6XSrtlJTA_RqG1_A,23539
-beswarm-0.2.35.dist-info/METADATA,sha256=cfwB-Cq_qEDmpCNZyzrFNjDtnikxw8IqmrKf0MZd_Yk,3878
-beswarm-0.2.35.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-beswarm-0.2.35.dist-info/top_level.txt,sha256=pJw4O87wvt5882smuSO6DfByJz7FJ8SxxT8h9fHCmpo,8
-beswarm-0.2.35.dist-info/RECORD,,
+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,,