beswarm 0.2.34__tar.gz → 0.2.36__tar.gz

{beswarm-0.2.34 → beswarm-0.2.36}/PKG-INFO

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

{beswarm-0.2.34 → beswarm-0.2.36}/beswarm/aient/setup.py

@@ -4,7 +4,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="aient",
-    version="1.1.52",
+    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-0.2.34 → beswarm-0.2.36}/beswarm/aient/src/aient/core/request.py

@@ -74,9 +74,8 @@ async def get_gemini_payload(request, engine, provider, api_key=None):
                     content.append(image_message)
         elif msg.content:
             content = [{"text": msg.content}]
-            tool_calls = msg.tool_calls
         elif msg.content is None:
-            continue
+            tool_calls = msg.tool_calls
 
         if tool_calls:
             tool_call = tool_calls[0]
@@ -110,7 +109,7 @@ async def get_gemini_payload(request, engine, provider, api_key=None):
                     }]
                 }
             )
-        elif msg.role != "system":
+        elif msg.role != "system" and content:
             messages.append({"role": msg.role, "parts": content})
         elif msg.role == "system":
             content[0]["text"] = re.sub(r"_+", "_", content[0]["text"])
@@ -409,8 +408,9 @@ async def get_vertex_gemini_payload(request, engine, provider, api_key=None):
                 elif item.type == "image_url" and provider.get("image", True):
                     image_message = await get_image_message(item.image_url.url, engine)
                     content.append(image_message)
-        else:
+        elif msg.content:
             content = [{"text": msg.content}]
+        elif msg.content is None:
             tool_calls = msg.tool_calls
 
         if tool_calls:
@@ -445,7 +445,7 @@ async def get_vertex_gemini_payload(request, engine, provider, api_key=None):
                     }]
                 }
             )
-        elif msg.role != "system":
+        elif msg.role != "system" and content:
             messages.append({"role": msg.role, "parts": content})
         elif msg.role == "system":
             system_prompt = system_prompt + "\n\n" + content[0]["text"]
@@ -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-0.2.34 → beswarm-0.2.36}/beswarm/aient/src/aient/core/response.py

@@ -20,6 +20,35 @@ async def check_response(response, error_log):
         return {"error": f"{error_log} HTTP Error", "status_code": response.status_code, "details": error_json}
     return None
 
+def gemini_json_poccess(response_str):
+    promptTokenCount = 0
+    candidatesTokenCount = 0
+    totalTokenCount = 0
+    image_base64 = None
+
+    response_json = json.loads(response_str)
+    json_data = safe_get(response_json, "candidates", 0, "content", default=None)
+    finishReason = safe_get(response_json, "candidates", 0 , "finishReason", default=None)
+    if finishReason:
+        promptTokenCount = safe_get(response_json, "usageMetadata", "promptTokenCount", default=0)
+        candidatesTokenCount = safe_get(response_json, "usageMetadata", "candidatesTokenCount", default=0)
+        totalTokenCount = safe_get(response_json, "usageMetadata", "totalTokenCount", default=0)
+
+    content = safe_get(json_data, "parts", 0, "text", default="")
+    b64_json = safe_get(json_data, "parts", 0, "inlineData", "data", default="")
+    if b64_json:
+        image_base64 = b64_json
+
+    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 = 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, finishReason, blockReason, promptTokenCount, candidatesTokenCount, totalTokenCount
+
 async def fetch_gemini_response_stream(client, url, headers, payload, model):
     timestamp = int(datetime.timestamp(datetime.now()))
     async with client.stream('POST', url, headers=headers, json=payload) as response:
@@ -28,131 +57,54 @@ async def fetch_gemini_response_stream(client, url, headers, payload, model):
             yield error_message
             return
         buffer = ""
-        cache_buffer = ""
-        revicing_function_call = False
-        function_full_response = "{"
-        need_function_call = False
-        is_finish = False
         promptTokenCount = 0
         candidatesTokenCount = 0
         totalTokenCount = 0
         parts_json = ""
-        image_base64 = ""
-        # line_index = 0
-        # last_text_line = 0
-        # if "thinking" in model:
-        #     is_thinking = True
-        # else:
-        #     is_thinking = False
         async for chunk in response.aiter_text():
             buffer += chunk
-            cache_buffer += chunk
 
             while "\n" in buffer:
                 line, buffer = buffer.split("\n", 1)
-                # line_index += 1
                 if line.startswith("data: "):
-                    json_line = line.lstrip("data: ").strip()
-                    response_json = json.loads(json_line)
-                    json_data = safe_get(response_json, "candidates", 0, "content", default=None)
-                    finishReason = safe_get(response_json, "candidates", 0 , "finishReason", default=None)
-                    if finishReason:
-                        promptTokenCount = safe_get(response_json, "usageMetadata", "promptTokenCount", default=0)
-                        candidatesTokenCount = safe_get(response_json, "usageMetadata", "candidatesTokenCount", default=0)
-                        totalTokenCount = safe_get(response_json, "usageMetadata", "totalTokenCount", default=0)
-
-                    content = safe_get(json_data, "parts", 0, "text", default="")
-                    b64_json = safe_get(json_data, "parts", 0, "inlineData", "data", default="")
-                    if b64_json:
-                        image_base64 = b64_json
-
-                    is_thinking = safe_get(json_data, "parts", 0, "thought", default=False)
-                    if is_thinking:
-                        sse_string = await generate_sse_response(timestamp, model, reasoning_content=content)
-                        yield sse_string
-                    elif not image_base64 and content:
-                        sse_string = await generate_sse_response(timestamp, model, content=content)
-                        yield sse_string
-
-                    continue
-
-                # https://ai.google.dev/api/generate-content?hl=zh-cn#FinishReason
-                if line and '\"finishReason\": \"' in line:
-                    if "stop" not in line.lower():
-                        logger.error(f"finishReason: {line}")
-                    is_finish = True
-                if is_finish and '\"promptTokenCount\": ' in line:
-                    json_data = parse_json_safely( "{" + line + "}")
-                    promptTokenCount = json_data.get('promptTokenCount', 0)
-                if is_finish and '\"candidatesTokenCount\": ' in line:
-                    json_data = parse_json_safely( "{" + line + "}")
-                    candidatesTokenCount = json_data.get('candidatesTokenCount', 0)
-                if is_finish and '\"totalTokenCount\": ' in line:
-                    json_data = parse_json_safely( "{" + line + "}")
-                    totalTokenCount = json_data.get('totalTokenCount', 0)
-
-                if (line and '"parts": [' in line or parts_json != "") and is_finish == False:
+                    parts_json = line.lstrip("data: ").strip()
+                else:
                     parts_json += line
-                if parts_json != "" and line and '],' == line.strip():
-                    # tmp_parts_json =  "{" + parts_json.split("}        ]      },")[0].strip().rstrip("}], ").replace("\n", "\\n").lstrip("{") + "}]}"
-                    tmp_parts_json =  "{" + parts_json.split("}        ]      },")[0].strip().rstrip("}], ").replace("\n", "\\n").lstrip("{")
-                    if "inlineData" in tmp_parts_json:
-                        tmp_parts_json = tmp_parts_json + "}}]}"
-                    else:
-                        tmp_parts_json = tmp_parts_json + "}]}"
+                    parts_json = parts_json.lstrip("[,")
                     try:
-                        json_data = json.loads(tmp_parts_json)
-
-                        content = safe_get(json_data, "parts", 0, "text", default="")
-                        b64_json = safe_get(json_data, "parts", 0, "inlineData", "data", default="")
-                        if b64_json:
-                            image_base64 = b64_json
-
-                        is_thinking = safe_get(json_data, "parts", 0, "thought", default=False)
-                        if is_thinking:
-                            sse_string = await generate_sse_response(timestamp, model, reasoning_content=content)
-                            yield sse_string
-                        elif not image_base64 and content:
-                            sse_string = await generate_sse_response(timestamp, model, content=content)
-                            yield sse_string
+                        json.loads(parts_json)
                     except json.JSONDecodeError:
-                        logger.error(f"无法解析JSON: {parts_json}")
-                    parts_json = ""
-
-                if line and ('\"functionCall\": {' in line or revicing_function_call):
-                    revicing_function_call = True
-                    need_function_call = True
-                    if ']' in line:
-                        revicing_function_call = False
                         continue
 
-                    function_full_response += line
+                # https://ai.google.dev/api/generate-content?hl=zh-cn#FinishReason
+                is_thinking, content, image_base64, function_call_name, function_full_response, finishReason, blockReason, promptTokenCount, candidatesTokenCount, totalTokenCount = gemini_json_poccess(parts_json)
 
-        if image_base64:
-            yield await generate_no_stream_response(timestamp, model, content=content, tools_id=None, function_call_name=None, function_call_content=None, role=None, total_tokens=totalTokenCount, prompt_tokens=promptTokenCount, completion_tokens=candidatesTokenCount, image_base64=image_base64)
-            return
+                if is_thinking:
+                    sse_string = await generate_sse_response(timestamp, model, reasoning_content=content)
+                    yield sse_string
+                elif not image_base64 and content:
+                    sse_string = await generate_sse_response(timestamp, model, content=content)
+                    yield sse_string
 
-        if need_function_call:
-            function_call = json.loads(function_full_response)
-            function_call_name = function_call["functionCall"]["name"]
-            sse_string = await generate_sse_response(timestamp, model, content=None, tools_id="chatcmpl-9inWv0yEtgn873CxMBzHeCeiHctTV", function_call_name=function_call_name)
-            yield sse_string
-            function_full_response = json.dumps(function_call["functionCall"]["args"])
-            sse_string = await generate_sse_response(timestamp, model, content=None, tools_id="chatcmpl-9inWv0yEtgn873CxMBzHeCeiHctTV", function_call_name=None, function_call_content=function_full_response)
-            yield sse_string
+                if image_base64:
+                    yield await generate_no_stream_response(timestamp, model, content=content, tools_id=None, function_call_name=None, function_call_content=None, role=None, total_tokens=totalTokenCount, prompt_tokens=promptTokenCount, completion_tokens=candidatesTokenCount, image_base64=image_base64)
 
-        cache_buffer_json = {}
-        try:
-            cache_buffer_json = json.loads(cache_buffer)
-        except json.JSONDecodeError:
-            cache_buffer_json = {}
+                if function_call_name:
+                    sse_string = await generate_sse_response(timestamp, model, content=None, tools_id="chatcmpl-9inWv0yEtgn873CxMBzHeCeiHctTV", function_call_name=function_call_name)
+                    yield sse_string
+                if function_full_response:
+                    sse_string = await generate_sse_response(timestamp, model, content=None, tools_id="chatcmpl-9inWv0yEtgn873CxMBzHeCeiHctTV", function_call_name=None, function_call_content=function_full_response)
+                    yield sse_string
 
-        if cache_buffer == "[]" or safe_get(cache_buffer_json, 0, "promptFeedback", "blockReason") == "PROHIBITED_CONTENT":
-            sse_string = await generate_sse_response(timestamp, model, stop="PROHIBITED_CONTENT")
-            yield sse_string
-        else:
-            sse_string = await generate_sse_response(timestamp, model, stop="stop")
-            yield sse_string
+                if parts_json == "[]" or blockReason == "PROHIBITED_CONTENT":
+                    sse_string = await generate_sse_response(timestamp, model, stop="PROHIBITED_CONTENT")
+                    yield sse_string
+                elif finishReason:
+                    sse_string = await generate_sse_response(timestamp, model, stop="stop")
+                    yield sse_string
+                    break
+
+                parts_json = ""
 
         sse_string = await generate_sse_response(timestamp, model, None, None, None, None, None, totalTokenCount, promptTokenCount, candidatesTokenCount)
         yield sse_string

{beswarm-0.2.34 → beswarm-0.2.36}/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-0.2.36/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-0.2.34 → beswarm-0.2.36}/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-0.2.34 → beswarm-0.2.36}/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-0.2.34 → beswarm-0.2.36}/beswarm/tools/taskmanager.py

@@ -34,6 +34,7 @@ class TaskManager:
         self.task_cache_file.touch(exist_ok=True)
         self.read_tasks_cache()
         self.set_task_cache("root_path", str(self.root_path))
+        self.resume_all_running_task()
 
     def set_task_cache(self, *keys_and_value):
         """
@@ -86,6 +87,12 @@ class TaskManager:
             self.set_task_cache(task_id, "status", TaskStatus.RUNNING.value)
         return task_ids
 
+    def resume_all_running_task(self):
+        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)
+
     def resume_task(self, task_id, task_coro, args):
         """
         恢复一个任务。
@@ -95,7 +102,7 @@ class TaskManager:
             return TaskStatus.NOT_FOUND
 
         coro = task_coro(**args)
-        task_id = self.create_task(coro)
+        task_id = self.create_task(coro, task_id)
         self.set_task_cache(task_id, "args", args)
         self.set_task_cache(task_id, "status", TaskStatus.RUNNING.value)
         print(f"任务已恢复: ID={task_id}, Name={task_id}")
@@ -103,7 +110,7 @@ class TaskManager:
         print(f"self.tasks_cache: {json.dumps(self.tasks_cache, ensure_ascii=False, indent=4)}")
         return task_id
 
-    def create_task(self, coro):
+    def create_task(self, coro, task_id=None):
         """
         创建并注册一个新任务。
 
@@ -114,7 +121,8 @@ class TaskManager:
         Returns:
             str: 任务的唯一ID。
         """
-        task_id = str(uuid.uuid4())
+        if task_id == None:
+            task_id = str(uuid.uuid4())
         task_name = f"Task-{task_id[:8]}"
 
         # 使用 asyncio.create_task() 创建任务
@@ -233,7 +241,7 @@ def create_task(goal, tools, work_dir):
     Args:
         goal (str): 需要完成的具体任务目标描述。子任务将围绕此目标进行工作。必须清晰、具体。必须包含背景信息，完成指标等。写清楚什么时候算任务完成，同时交代清楚任务的背景信息，这个背景信息可以是需要读取的文件等一切有助于完成任务的信息。
         tools (list[str]): 一个包含可用工具函数对象的列表。子任务在执行任务时可能会调用这些工具来与环境交互（例如读写文件、执行命令等）。
-        work_dir (str): 工作目录的绝对路径。子任务将在此目录上下文中执行操作。子任务的工作目录位置在主任务的工作目录的子目录。
+        work_dir (str): 工作目录的绝对路径。子任务将在此目录上下文中执行操作。子任务的工作目录位置在主任务的工作目录的子目录。子任务工作目录**禁止**设置为主任务目录本身。
 
     Returns:
         str: 当任务成功完成时，返回字符串 "任务已完成"。