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

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/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/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/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