beswarm 0.2.50__py3-none-any.whl → 0.2.52__py3-none-any.whl

beswarm/agents/chatgroup.py

@@ -15,8 +15,8 @@ from typing import List, Dict, Union
 from ..broker import MessageBroker
 from ..bemcp.bemcp import MCPManager
 from ..utils import register_mcp_tools
-from ..aient.src.aient.models import chatgpt
-from ..aient.src.aient.plugins import get_function_call_list, registry
+from ..aient.aient.models import chatgpt
+from ..aient.aient.plugins import get_function_call_list, registry
 
 worker_system_prompt = """
 你是{name}。帮助用户头脑风暴。请分析不同用户的观点，并给出你的观点。

beswarm/agents/planact.py

@@ -10,8 +10,8 @@ from datetime import datetime
 from typing import List, Dict, Union
 
 from ..broker import MessageBroker
-from ..aient.src.aient.models import chatgpt
-from ..aient.src.aient.plugins import get_function_call_list, registry
+from ..aient.aient.models import chatgpt
+from ..aient.aient.plugins import get_function_call_list, registry
 from ..prompt import worker_system_prompt, instruction_system_prompt
 from ..utils import extract_xml_content, get_current_screen_image_message, replace_xml_content, register_mcp_tools, setup_logger
 

beswarm/aient/{src/aient → aient}/core/response.py

@@ -33,6 +33,8 @@ def gemini_json_poccess(response_str):
         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)
+        if finishReason != "STOP":
+            logger.error(f"finishReason: {finishReason}")
 
     content = reasoning_content = safe_get(json_data, "parts", 0, "text", default="")
     b64_json = safe_get(json_data, "parts", 0, "inlineData", "data", default="")
@@ -424,53 +426,41 @@ async def fetch_claude_response_stream(client, url, headers, payload, model):
                 line, buffer = buffer.split("\n", 1)
                 # logger.info(line)
 
-                if line.startswith("data:"):
-                    line = line.lstrip("data: ")
+                if line.startswith("data:") and (line := line.lstrip("data: ")):
                     resp: dict = json.loads(line)
-                    message = resp.get("message")
-                    if message:
-                        role = message.get("role")
-                        if role:
-                            sse_string = await generate_sse_response(timestamp, model, None, None, None, None, role)
-                            yield sse_string
-                        tokens_use = message.get("usage")
-                        if tokens_use:
-                            input_tokens = tokens_use.get("input_tokens", 0)
-                    usage = resp.get("usage")
-                    if usage:
-                        output_tokens = usage.get("output_tokens", 0)
+
+                    input_tokens = input_tokens or safe_get(resp, "message", "usage", "input_tokens", default=0)
+                    # cache_creation_input_tokens = safe_get(resp, "message", "usage", "cache_creation_input_tokens", default=0)
+                    # cache_read_input_tokens = safe_get(resp, "message", "usage", "cache_read_input_tokens", default=0)
+                    output_tokens = safe_get(resp, "usage", "output_tokens", default=0)
+                    if output_tokens:
                         total_tokens = input_tokens + output_tokens
                         sse_string = await generate_sse_response(timestamp, model, None, None, None, None, None, total_tokens, input_tokens, output_tokens)
                         yield sse_string
-                        # print("\n\rtotal_tokens", total_tokens)
-
-                    tool_use = resp.get("content_block")
-                    tools_id = None
-                    function_call_name = None
-                    if tool_use and "tool_use" == tool_use['type']:
-                        # print("tool_use", tool_use)
-                        tools_id = tool_use["id"]
-                        if "name" in tool_use:
-                            function_call_name = tool_use["name"]
-                            sse_string = await generate_sse_response(timestamp, model, None, tools_id, function_call_name, None)
-                            yield sse_string
-                    delta = resp.get("delta")
-                    # print("delta", delta)
-                    if not delta:
+                        break
+
+                    text = safe_get(resp, "delta", "text", default="")
+                    if text:
+                        sse_string = await generate_sse_response(timestamp, model, text)
+                        yield sse_string
                         continue
-                    if "text" in delta:
-                        content = delta["text"]
-                        sse_string = await generate_sse_response(timestamp, model, content, None, None)
+
+                    function_call_name = safe_get(resp, "content_block", "name", default=None)
+                    tools_id = safe_get(resp, "content_block", "id", default=None)
+                    if tools_id and function_call_name:
+                        sse_string = await generate_sse_response(timestamp, model, None, tools_id, function_call_name, None)
                         yield sse_string
-                    if "thinking" in delta and delta["thinking"]:
-                        content = delta["thinking"]
-                        sse_string = await generate_sse_response(timestamp, model, reasoning_content=content)
+
+                    thinking_content = safe_get(resp, "delta", "thinking", default="")
+                    if thinking_content:
+                        sse_string = await generate_sse_response(timestamp, model, reasoning_content=thinking_content)
                         yield sse_string
-                    if "partial_json" in delta:
-                        # {"type":"input_json_delta","partial_json":""}
-                        function_call_content = delta["partial_json"]
+
+                    function_call_content = safe_get(resp, "delta", "partial_json", default="")
+                    if function_call_content:
                         sse_string = await generate_sse_response(timestamp, model, None, None, None, function_call_content)
                         yield sse_string
+
     yield "data: [DONE]" + end_of_line
 
 async def fetch_aws_response_stream(client, url, headers, payload, model):

beswarm/aient/{src/aient → aient}/core/utils.py

@@ -46,7 +46,10 @@ class BaseAPI:
             before_v1 = ""
         self.base_url: str = urlunparse(parsed_url[:2] + ("",) + ("",) * 3)
         self.v1_url: str = urlunparse(parsed_url[:2]+ (before_v1,) + ("",) * 3)
-        self.v1_models: str = urlunparse(parsed_url[:2] + (before_v1 + "models",) + ("",) * 3)
+        if "v1/messages" in parsed_url.path:
+            self.v1_models: str = urlunparse(parsed_url[:2] + ("v1/models",) + ("",) * 3)
+        else:
+            self.v1_models: str = urlunparse(parsed_url[:2] + (before_v1 + "models",) + ("",) * 3)
         self.chat_url: str = urlunparse(parsed_url[:2] + (before_v1 + "chat/completions",) + ("",) * 3)
         self.image_url: str = urlunparse(parsed_url[:2] + (before_v1 + "images/generations",) + ("",) * 3)
         if parsed_url.hostname == "dashscope.aliyuncs.com":
@@ -192,7 +195,10 @@ def update_initial_model(provider):
             endpoint_models_url = endpoint.v1_models
             if isinstance(api, list):
                 api = api[0]
-            headers = {"Authorization": f"Bearer {api}"}
+            if "v1/messages" in api_url:
+                headers = {"x-api-key": api, "anthropic-version": "2023-06-01"}
+            else:
+                headers = {"Authorization": f"Bearer {api}"}
             response = httpx.get(
                 endpoint_models_url,
                 headers=headers,

beswarm/aient/aient/models/__init__.py

@@ -0,0 +1,2 @@
+from .chatgpt import *
+from .audio import *

beswarm/aient/{src/aient → aient}/models/base.py

@@ -53,20 +53,10 @@ class BaseLLM:
                 "https": proxy,
             },
         )
-        if proxy := (
-            proxy or os.environ.get("all_proxy") or os.environ.get("ALL_PROXY") or None
-        ):
-            if "socks5h" not in proxy:
-                self.aclient = httpx.AsyncClient(
-                    follow_redirects=True,
-                    proxies=proxy,
-                    timeout=timeout,
-                )
-        else:
-            self.aclient = httpx.AsyncClient(
-                follow_redirects=True,
-                timeout=timeout,
-            )
+        self._aclient = None
+        self._proxy = proxy
+        self._timeout = timeout
+        self._loop = None
 
         self.conversation: dict[str, list[dict]] = {
             "default": [
@@ -83,6 +73,33 @@ class BaseLLM:
         self.use_plugins = use_plugins
         self.print_log: bool = print_log
 
+    def _get_aclient(self):
+        """
+        Lazily initialize and return the httpx.AsyncClient.
+        This method ensures the client is always bound to a running event loop.
+        """
+        import asyncio
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+        if self._aclient is None or self._aclient.is_closed or self._loop is not loop:
+            self._loop = loop
+            proxy = self._proxy or os.environ.get("all_proxy") or os.environ.get("ALL_PROXY") or None
+            proxies = proxy if proxy and "socks5h" not in proxy else None
+            self._aclient = httpx.AsyncClient(
+                follow_redirects=True,
+                proxy=proxies,
+                timeout=self._timeout,
+            )
+        return self._aclient
+
+    @property
+    def aclient(self):
+        return self._get_aclient()
+
     def add_to_conversation(
         self,
         message: list,
@@ -196,7 +213,6 @@ class BaseLLM:
             **kwargs,
         ):
             response += chunk
-        # full_response: str = "".join([r async for r in response])
         full_response: str = "".join(response)
         return full_response
 

beswarm/aient/{src/aient → aient}/models/chatgpt.py

@@ -17,7 +17,7 @@ from ..plugins.registry import registry
 from ..plugins import PLUGINS, get_tools_result_async, function_call_list, update_tools_config
 from ..utils.scripts import safe_get, async_generator_to_sync, parse_function_xml, parse_continuous_json, convert_functions_to_xml, remove_xml_tags_and_content
 from ..core.request import prepare_request_payload
-from ..core.response import fetch_response_stream
+from ..core.response import fetch_response_stream, fetch_response
 
 def get_filtered_keys_from_object(obj: object, *keys: str) -> Set[str]:
     """
@@ -288,6 +288,7 @@ class chatgpt(BaseLLM):
         convo_id: str = "default",
         model: str = "",
         pass_history: int = 9999,
+        stream: bool = True,
         **kwargs,
     ):
         self.conversation[convo_id][0] = {"role": "system","content": self.system_prompt + "\n\n" + self.get_latest_file_content()}
@@ -309,12 +310,13 @@ class chatgpt(BaseLLM):
                 {"role": "system","content": self.system_prompt + "\n\n" + self.get_latest_file_content()},
                 {"role": role, "content": prompt}
             ],
-            "stream": True,
-            "stream_options": {
-                "include_usage": True
-            },
+            "stream": stream,
             "temperature": kwargs.get("temperature", self.temperature)
         }
+        if stream:
+            request_data["stream_options"] = {
+                "include_usage": True
+            }
 
         if kwargs.get("max_tokens", self.max_tokens):
             request_data["max_tokens"] = kwargs.get("max_tokens", self.max_tokens)
@@ -674,137 +676,7 @@ class chatgpt(BaseLLM):
                 self.conversation[convo_id].pop(-1)
                 self.conversation[convo_id].pop(-1)
 
-    def ask_stream(
-        self,
-        prompt: list,
-        role: str = "user",
-        convo_id: str = "default",
-        model: str = "",
-        pass_history: int = 9999,
-        function_name: str = "",
-        total_tokens: int = 0,
-        function_arguments: str = "",
-        function_call_id: str = "",
-        language: str = "English",
-        system_prompt: str = None,
-        **kwargs,
-    ):
-        """
-        Ask a question (同步流式响应)
-        """
-        # 准备会话
-        self.system_prompt = system_prompt or self.system_prompt
-        if convo_id not in self.conversation or pass_history <= 2:
-            self.reset(convo_id=convo_id, system_prompt=system_prompt)
-        self.add_to_conversation(prompt, role, convo_id=convo_id, function_name=function_name, total_tokens=total_tokens, function_arguments=function_arguments, function_call_id=function_call_id, pass_history=pass_history)
-
-        # 获取请求体
-        json_post = None
-        async def get_post_body_async():
-            nonlocal json_post
-            url, headers, json_post, engine_type = await self.get_post_body(prompt, role, convo_id, model, pass_history, **kwargs)
-            return url, headers, json_post, engine_type
-
-        # 替换原来的获取请求体的代码
-        # json_post = next(async_generator_to_sync(get_post_body_async()))
-        try:
-            url, headers, json_post, engine_type = asyncio.run(get_post_body_async())
-        except RuntimeError:
-            # 如果已经在事件循环中，则使用不同的方法
-            loop = asyncio.get_event_loop()
-            url, headers, json_post, engine_type = loop.run_until_complete(get_post_body_async())
-
-        self.truncate_conversation(convo_id=convo_id)
-
-        # 打印日志
-        if self.print_log:
-            self.logger.info(f"api_url: {kwargs.get('api_url', self.api_url.chat_url)}, {url}")
-            self.logger.info(f"api_key: {kwargs.get('api_key', self.api_key)}")
-
-        # 发送请求并处理响应
-        for _ in range(3):
-            if self.print_log:
-                replaced_text = json.loads(re.sub(r';base64,([A-Za-z0-9+/=]+)', ';base64,***', json.dumps(json_post)))
-                replaced_text_str = json.dumps(replaced_text, indent=4, ensure_ascii=False)
-                self.logger.info(f"Request Body:\n{replaced_text_str}")
-
-            try:
-                # 改进处理方式，创建一个内部异步函数来处理异步调用
-                async def process_async():
-                    # 异步调用 fetch_response_stream
-                    # self.logger.info("--------------------------------")
-                    # self.logger.info(prompt)
-                    # self.logger.info(parse_function_xml(prompt))
-                    # self.logger.info(convert_functions_to_xml(parse_function_xml(prompt)))
-                    # self.logger.info(convert_functions_to_xml(parse_function_xml(prompt)).strip() == prompt)
-                    # self.logger.info("--------------------------------")
-                    if prompt and "</" in prompt and "<instructions>" not in prompt and convert_functions_to_xml(parse_function_xml(prompt)).strip() == prompt:
-                        tmp_response = {
-                            "id": "chatcmpl-zXCi5TxWy953TCcxFocSienhvx0BB",
-                            "object": "chat.completion.chunk",
-                            "created": 1754588695,
-                            "model": "gemini-2.5-flash",
-                            "choices": [
-                                {
-                                "index": 0,
-                                "delta": {
-                                    "role": "assistant",
-                                    "content": prompt
-                                },
-                                "finish_reason": "stop"
-                                }
-                            ],
-                            "system_fingerprint": "fp_d576307f90"
-                        }
-                        async def _mock_response_generator():
-                            yield f"data: {json.dumps(tmp_response)}\n\n"
-                        async_generator = _mock_response_generator()
-                    else:
-                        async_generator = fetch_response_stream(
-                            self.aclient,
-                            url,
-                            headers,
-                            json_post,
-                            engine_type,
-                            model or self.engine,
-                        )
-                    # 异步处理响应流
-                    async for chunk in self._process_stream_response(
-                        async_generator,
-                        convo_id=convo_id,
-                        function_name=function_name,
-                        total_tokens=total_tokens,
-                        function_arguments=function_arguments,
-                        function_call_id=function_call_id,
-                        model=model,
-                        language=language,
-                        system_prompt=system_prompt,
-                        pass_history=pass_history,
-                        is_async=True,
-                        **kwargs
-                    ):
-                        yield chunk
-
-                # 将异步函数转换为同步生成器
-                return async_generator_to_sync(process_async())
-            except ConnectionError:
-                self.logger.error("连接错误，请检查服务器状态或网络连接。")
-                return
-            except requests.exceptions.ReadTimeout:
-                self.logger.error("请求超时，请检查网络连接或增加超时时间。")
-                return
-            except httpx.RemoteProtocolError:
-                continue
-            except Exception as e:
-                self.logger.error(f"发生了未预料的错误：{e}")
-                if "Invalid URL" in str(e):
-                    e = "您输入了无效的API URL，请使用正确的URL并使用`/start`命令重新设置API URL。具体错误如下：\n\n" + str(e)
-                    raise Exception(f"{e}")
-                # 最后一次重试失败，向上抛出异常
-                if _ == 2:
-                    raise Exception(f"{e}")
-
-    async def ask_stream_async(
+    async def _ask_stream_handler(
         self,
         prompt: list,
         role: str = "user",
@@ -817,10 +689,11 @@ class chatgpt(BaseLLM):
         function_call_id: str = "",
         language: str = "English",
         system_prompt: str = None,
+        stream: bool = True,
         **kwargs,
     ):
         """
-        Ask a question (异步流式响应)
+        Unified stream handler (async)
         """
         # 准备会话
         self.system_prompt = system_prompt or self.system_prompt
@@ -829,89 +702,64 @@ class chatgpt(BaseLLM):
         self.add_to_conversation(prompt, role, convo_id=convo_id, function_name=function_name, total_tokens=total_tokens, function_arguments=function_arguments, pass_history=pass_history, function_call_id=function_call_id)
 
         # 获取请求体
-        url, headers, json_post, engine_type = await self.get_post_body(prompt, role, convo_id, model, pass_history, **kwargs)
+        url, headers, json_post, engine_type = await self.get_post_body(prompt, role, convo_id, model, pass_history, stream=stream, **kwargs)
         self.truncate_conversation(convo_id=convo_id)
 
         # 打印日志
         if self.print_log:
-            self.logger.info(f"api_url: {url}")
+            self.logger.info(f"api_url: {kwargs.get('api_url', self.api_url.chat_url)}, {url}")
             self.logger.info(f"api_key: {kwargs.get('api_key', self.api_key)}")
 
         # 发送请求并处理响应
-        for _ in range(3):
+        for i in range(3):
             if self.print_log:
                 replaced_text = json.loads(re.sub(r';base64,([A-Za-z0-9+/=]+)', ';base64,***', json.dumps(json_post)))
                 replaced_text_str = json.dumps(replaced_text, indent=4, ensure_ascii=False)
                 self.logger.info(f"Request Body:\n{replaced_text_str}")
 
             try:
-                # 使用fetch_response_stream处理响应
-                # self.logger.info("--------------------------------")
-                # self.logger.info(prompt)
-                # self.logger.info(parse_function_xml(prompt))
-                # self.logger.info(convert_functions_to_xml(parse_function_xml(prompt)))
-                # self.logger.info(convert_functions_to_xml(parse_function_xml(prompt)).strip() == prompt)
-                # self.logger.info("--------------------------------")
                 if prompt and "</" in prompt and "<instructions>" not in prompt and convert_functions_to_xml(parse_function_xml(prompt)).strip() == prompt:
                     tmp_response = {
                         "id": "chatcmpl-zXCi5TxWy953TCcxFocSienhvx0BB",
                         "object": "chat.completion.chunk",
                         "created": 1754588695,
-                        "model": "gemini-2.5-flash",
+                        "model": model or self.engine,
                         "choices": [
                             {
-                            "index": 0,
-                            "delta": {
-                                "role": "assistant",
-                                "content": prompt
-                            },
-                            "finish_reason": "stop"
+                                "index": 0,
+                                "delta": {"role": "assistant", "content": prompt},
+                                "finish_reason": "stop",
                             }
                         ],
-                        "system_fingerprint": "fp_d576307f90"
+                        "system_fingerprint": "fp_d576307f90",
                     }
                     async def _mock_response_generator():
                         yield f"data: {json.dumps(tmp_response)}\n\n"
                     generator = _mock_response_generator()
                 else:
-                    generator = fetch_response_stream(
-                        self.aclient,
-                        url,
-                        headers,
-                        json_post,
-                        engine_type,
-                        model or self.engine,
-                    )
-                # if isinstance(chunk, dict) and "error" in chunk:
-                #     # 处理错误响应
-                #     if chunk["status_code"] in (400, 422, 503):
-                #         json_post, should_retry = await self._handle_response_error(
-                #             type('Response', (), {'status_code': chunk["status_code"], 'text': json.dumps(chunk["details"]), 'aread': lambda: asyncio.sleep(0)}),
-                #             json_post
-                #         )
-                #         if should_retry:
-                #             break  # 跳出内部循环，继续外部循环重试
-                #     raise Exception(f"{chunk['status_code']} {chunk['error']} {chunk['details']}")
+                    if stream:
+                        generator = fetch_response_stream(
+                            self.aclient, url, headers, json_post, engine_type, model or self.engine,
+                        )
+                    else:
+                        generator = fetch_response(
+                            self.aclient, url, headers, json_post, engine_type, model or self.engine,
+                        )
 
                 # 处理正常响应
                 async for processed_chunk in self._process_stream_response(
-                    generator,
-                    convo_id=convo_id,
-                    function_name=function_name,
-                    total_tokens=total_tokens,
-                    function_arguments=function_arguments,
-                    function_call_id=function_call_id,
-                    model=model,
-                    language=language,
-                    system_prompt=system_prompt,
-                    pass_history=pass_history,
-                    is_async=True,
-                    **kwargs
+                    generator, convo_id=convo_id, function_name=function_name,
+                    total_tokens=total_tokens, function_arguments=function_arguments,
+                    function_call_id=function_call_id, model=model, language=language,
+                    system_prompt=system_prompt, pass_history=pass_history, is_async=True, **kwargs
                 ):
                     yield processed_chunk
 
                 # 成功处理，跳出重试循环
                 break
+            except (httpx.ConnectError, httpx.ReadTimeout):
+                self.logger.error("连接或读取超时错误，请检查服务器状态或网络连接。")
+                return # Stop iteration
             except httpx.RemoteProtocolError:
                 continue
             except Exception as e:
@@ -922,9 +770,69 @@ class chatgpt(BaseLLM):
                     e = "您输入了无效的API URL，请使用正确的URL并使用`/start`命令重新设置API URL。具体错误如下：\n\n" + str(e)
                     raise Exception(f"{e}")
                 # 最后一次重试失败，向上抛出异常
-                if _ == 2:
+                if i == 2:
                     raise Exception(f"{e}")
 
+    def ask_stream(
+        self,
+        prompt: list,
+        role: str = "user",
+        convo_id: str = "default",
+        model: str = "",
+        pass_history: int = 9999,
+        function_name: str = "",
+        total_tokens: int = 0,
+        function_arguments: str = "",
+        function_call_id: str = "",
+        language: str = "English",
+        system_prompt: str = None,
+        stream: bool = True,
+        **kwargs,
+    ):
+        """
+        Ask a question (同步流式响应)
+        """
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_closed():
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+        async_gen = self._ask_stream_handler(
+            prompt, role, convo_id, model, pass_history, function_name, total_tokens,
+            function_arguments, function_call_id, language, system_prompt, stream, **kwargs
+        )
+        for chunk in async_generator_to_sync(async_gen):
+            yield chunk
+
+    async def ask_stream_async(
+        self,
+        prompt: list,
+        role: str = "user",
+        convo_id: str = "default",
+        model: str = "",
+        pass_history: int = 9999,
+        function_name: str = "",
+        total_tokens: int = 0,
+        function_arguments: str = "",
+        function_call_id: str = "",
+        language: str = "English",
+        system_prompt: str = None,
+        stream: bool = True,
+        **kwargs,
+    ):
+        """
+        Ask a question (异步流式响应)
+        """
+        async for chunk in self._ask_stream_handler(
+            prompt, role, convo_id, model, pass_history, function_name, total_tokens,
+            function_arguments, function_call_id, language, system_prompt, stream, **kwargs
+        ):
+            yield chunk
+
     async def ask_async(
         self,
         prompt: str,
@@ -943,11 +851,36 @@ class chatgpt(BaseLLM):
             convo_id=convo_id,
             pass_history=pass_history,
             model=model or self.engine,
+            stream=False,
             **kwargs,
         )
         full_response: str = "".join([r async for r in response])
         return full_response
 
+    def ask(
+        self,
+        prompt: str,
+        role: str = "user",
+        convo_id: str = "default",
+        model: str = "",
+        pass_history: int = 9999,
+        **kwargs,
+    ) -> str:
+        """
+        Non-streaming ask
+        """
+        response = self.ask_stream(
+            prompt=prompt,
+            role=role,
+            convo_id=convo_id,
+            pass_history=pass_history,
+            model=model or self.engine,
+            stream=False,
+            **kwargs,
+        )
+        full_response: str = "".join([r for r in response])
+        return full_response
+
     def rollback(self, n: int = 1, convo_id: str = "default") -> None:
         """
         Rollback the conversation

beswarm/aient/{src/aient → aient}/plugins/excute_command.py

@@ -276,4 +276,4 @@ for i in content.split("\\n"):
 #     print(excute_command(python_long_task_command))
 
     # print(get_python_executable("python -c 'print(123)'"))
-# python -m beswarm.aient.src.aient.plugins.excute_command
+# python -m beswarm.aient.aient.plugins.excute_command

beswarm/aient/{src/aient → aient}/plugins/read_file.py

@@ -181,7 +181,7 @@ Examples:
         return f"<tool_error>读取文件时发生错误: {e}</tool_error>"
 
 if __name__ == "__main__":
-    # python -m beswarm.aient.src.aient.plugins.read_file
+    # python -m beswarm.aient.aient.plugins.read_file
     result = read_file("./work/cax/Lenia Notebook.ipynb")
     print(result)
     print(len(result))

beswarm/aient/{src/aient → aient}/plugins/websearch.py

@@ -344,7 +344,7 @@ async def get_search_results(query):
 
 if __name__ == "__main__":
     os.system("clear")
-    # python -m beswarm.aient.src.aient.plugins.websearch
+    # python -m beswarm.aient.aient.plugins.websearch
     print(get_url_content(""))
     # from aient.models import chatgpt
     # print(get_search_results("今天的微博热搜有哪些？", chatgpt.chatgpt_api_url.v1_url))

beswarm/aient/{src/aient → aient}/plugins/write_file.py

@@ -87,4 +87,4 @@ if __name__ == "__main__":
     with open("test.txt", "r", encoding="utf-8") as file:
         content = file.read()
     print(write_to_file("test.txt", content))
-    # python -m beswarm.aient.src.aient.plugins.write_file
+    # python -m beswarm.aient.aient.plugins.write_file