beswarm 0.2.38__py3-none-any.whl → 0.2.40__py3-none-any.whl

beswarm/agents/planact.py

@@ -1,6 +1,5 @@
 import os
 import re
-import sys
 import copy
 import json
 import difflib
@@ -14,7 +13,7 @@ from ..broker import MessageBroker
 from ..aient.src.aient.models import chatgpt
 from ..aient.src.aient.plugins import get_function_call_list, registry
 from ..prompt import worker_system_prompt, instruction_system_prompt
-from ..utils import extract_xml_content, get_current_screen_image_message, replace_xml_content, register_mcp_tools
+from ..utils import extract_xml_content, get_current_screen_image_message, replace_xml_content, register_mcp_tools, setup_logger
 
 class BaseAgent:
     """Base class for agents, handling common initialization and disposal."""
@@ -24,6 +23,7 @@ class BaseAgent:
         self.work_dir = work_dir
         self.cache_file = Path(work_dir) / ".beswarm" / "work_agent_conversation_history.json"
         self.config = agent_config
+        self.logger = agent_config.get("logger", None)
         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"))
@@ -119,7 +119,7 @@ class InstructionAgent(BaseAgent):
             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)
+            self.broker.publish({"status": "error", "result": "The request body is too long, please try again."}, self.status_topic)
             return
 
         self.broker.publish({"status": "new_message", "result": "\n🤖 指令智能体:\n" + raw_response}, self.status_topic)
@@ -146,7 +146,7 @@ class InstructionAgent(BaseAgent):
                 )
             self.broker.publish({"instruction": instruction, "conversation": message["conversation"]}, self.publish_topic)
         else:
-            print("\n❌ 指令智能体生成的指令不符合要求，正在重新生成。")
+            self.logger.error("\n❌ 指令智能体生成的指令不符合要求，正在重新生成。")
             self.broker.publish(message, self.error_topic)
 
 
@@ -176,7 +176,7 @@ class WorkerAgent(BaseAgent):
         response = await self.agent.ask_async(instruction)
 
         if response.strip() == '':
-            print("\n❌ 工作智能体回复为空，请重新生成指令。")
+            self.logger.error("\n❌ 工作智能体回复为空，请重新生成指令。")
             self.broker.publish(message, self.error_topic)
         else:
             self.broker.publish({"status": "new_message", "result": "\n✅ 工作智能体:\n" + response}, self.status_topic)
@@ -184,19 +184,6 @@ class WorkerAgent(BaseAgent):
                 "conversation": self.agent.conversation["default"]
             }, self.publish_topic)
 
-class Tee:
-    def __init__(self, *files):
-        self.files = files
-
-    def write(self, obj):
-        for f in self.files:
-            f.write(obj)
-            f.flush()
-
-    def flush(self):
-        for f in self.files:
-            f.flush()
-
 class BrokerWorker:
     """The 'glue' class that orchestrates agents via a MessageBroker."""
     def __init__(self, goal: str, tools: List[Union[str, Dict]], work_dir: str, cache_messages: Union[bool, List[Dict]] = None, broker = None, mcp_manager = None, task_manager = None):
@@ -226,14 +213,10 @@ class BrokerWorker:
         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)
+        # 创建一个文件处理器，将日志写入任务自己的目录
+        log_file_path = cache_dir / "agent.log"
+        self.logger = setup_logger(f"task_{self.work_dir.name}", log_file_path)
+        self.logger.info(f"Logger for task '{self.goal}' initialized. Log file: {log_file_path}")
 
     async def _configure_tools(self):
         mcp_list = [item for item in self.tools if isinstance(item, dict)]
@@ -256,10 +239,12 @@ class BrokerWorker:
             self.task_completion_event.set()
 
         if message.get("status") == "error":
-            raise Exception(message.get("result"))
+            self.logger.error(message.get("result"))
+            self.final_result = message.get("result")
+            self.task_completion_event.set()
 
         if message.get("status") == "new_message":
-            print(message.get("result"))
+            self.logger.info(message.get("result"))
 
     def _setup_agents(self):
         instruction_agent_config = {
@@ -270,7 +255,7 @@ class BrokerWorker:
                 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
+            "temperature": 0.7, "use_plugins": False, "logger": self.logger
         }
 
         worker_agent_config = {
@@ -281,7 +266,7 @@ class BrokerWorker:
                 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
+            "print_log": True, "temperature": 0.5, "function_call_max_loop": 100, "logger": self.logger
         }
 
         instruction_agent = InstructionAgent(
@@ -332,7 +317,9 @@ class BrokerWorker:
                     yield message.get("result")
                     break
                 elif message.get("status") == "error":
-                    raise Exception(message.get("result"))
+                    self.logger.error(message.get("result"))
+                    self.final_result = message.get("result")
+                    self.task_completion_event.set()
         finally:
             instruction_agent.dispose()
             worker_agent.dispose()

beswarm/aient/setup.py

@@ -4,7 +4,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="aient",
-    version="1.1.54",
+    version="1.1.56",
     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

@@ -1051,7 +1051,7 @@ async def get_gpt_payload(request, engine, provider, api_key=None):
 
     for field, value in request.model_dump(exclude_unset=True).items():
         if field not in miss_fields and value is not None:
-            if field == "max_tokens" and ("o1" in original_model or "o3" in original_model or "o4" in original_model):
+            if field == "max_tokens" and ("o1" in original_model or "o3" in original_model or "o4" in original_model or "gpt-5" in original_model):
                 payload["max_completion_tokens"] = value
             else:
                 payload[field] = value
@@ -1071,7 +1071,9 @@ async def get_gpt_payload(request, engine, provider, api_key=None):
         elif request.model.endswith("low"):
             payload["reasoning_effort"] = "low"
 
-    if "o1" in original_model or "o3" in original_model or "o4" in original_model:
+    if "o1" in original_model or \
+    "o3" in original_model or "o4" in original_model or \
+    "gpt-oss" in original_model or "gpt-5" in original_model:
         if request.model.endswith("high"):
             payload["reasoning_effort"] = "high"
         elif request.model.endswith("low"):

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

@@ -34,12 +34,14 @@ def gemini_json_poccess(response_str):
         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="")
+    content = reasoning_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:
+        content = safe_get(json_data, "parts", 1, "text", default="")
 
     function_call_name = safe_get(json_data, "functionCall", "name", default=None)
     function_full_response = safe_get(json_data, "functionCall", "args", default="")
@@ -47,7 +49,7 @@ def gemini_json_poccess(response_str):
 
     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
+    return is_thinking, reasoning_content, 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()))
@@ -63,11 +65,18 @@ async def fetch_gemini_response_stream(client, url, headers, payload, model):
         parts_json = ""
         async for chunk in response.aiter_text():
             buffer += chunk
+            if buffer and "\n" not in buffer:
+                buffer += "\n"
 
             while "\n" in buffer:
                 line, buffer = buffer.split("\n", 1)
                 if line.startswith("data: "):
                     parts_json = line.lstrip("data: ").strip()
+                    try:
+                        json.loads(parts_json)
+                    except json.JSONDecodeError:
+                        logger.error(f"JSON decode error: {parts_json}")
+                        continue
                 else:
                     parts_json += line
                     parts_json = parts_json.lstrip("[,")
@@ -77,12 +86,12 @@ 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, finishReason, blockReason, promptTokenCount, candidatesTokenCount, totalTokenCount = gemini_json_poccess(parts_json)
+                is_thinking, reasoning_content, 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)
+                    sse_string = await generate_sse_response(timestamp, model, reasoning_content=reasoning_content)
                     yield sse_string
-                elif not image_base64 and content:
+                if not image_base64 and content:
                     sse_string = await generate_sse_response(timestamp, model, content=content)
                     yield sse_string
 

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

@@ -4,6 +4,8 @@ import json
 import copy
 import httpx
 import asyncio
+import logging
+import inspect
 import requests
 from typing import Set
 from typing import Union, Optional, Callable, List, Dict, Any
@@ -11,6 +13,7 @@ from pathlib import Path
 
 
 from .base import BaseLLM
+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
@@ -63,6 +66,7 @@ class chatgpt(BaseLLM):
         function_call_max_loop: int = 3,
         cut_history_by_function_name: str = "",
         cache_messages: list = None,
+        logger: logging.Logger = None,
     ) -> None:
         """
         Initialize Chatbot with API key (from https://platform.openai.com/account/api-keys)
@@ -83,6 +87,14 @@ class chatgpt(BaseLLM):
         self.cut_history_by_function_name = cut_history_by_function_name
         self.latest_file_content = {}
 
+        if logger:
+            self.logger = logger
+        else:
+            # 如果没有提供 logger，创建一个默认的，它只会打印到控制台
+            self.logger = logging.getLogger("chatgpt_default")
+            if not self.logger.handlers: # 防止重复添加 handler
+                self.logger.addHandler(logging.StreamHandler())
+                self.logger.setLevel(logging.INFO if print_log else logging.WARNING)
 
         # 注册和处理传入的工具
         self._register_tools(tools)
@@ -122,7 +134,7 @@ class chatgpt(BaseLLM):
         """
         Add a message to the conversation
         """
-        # print("role", role, "function_name", function_name, "message", message)
+        # self.logger.info(f"role: {role}, function_name: {function_name}, message: {message}")
         if convo_id not in self.conversation:
             self.reset(convo_id=convo_id)
         if function_name == "" and message:
@@ -175,16 +187,13 @@ class chatgpt(BaseLLM):
                     self.conversation[convo_id].append({"role": "assistant", "content": "我已经执行过这个工具了，接下来我需要做什么？"})
 
         else:
-            print('\033[31m')
-            print("error: add_to_conversation message is None or empty")
-            print("role", role, "function_name", function_name, "message", message)
-            print('\033[0m')
+            self.logger.error(f"error: add_to_conversation message is None or empty, role: {role}, function_name: {function_name}, message: {message}")
 
         conversation_len = len(self.conversation[convo_id]) - 1
         message_index = 0
         # if self.print_log:
         #     replaced_text = json.loads(re.sub(r';base64,([A-Za-z0-9+/=]+)', ';base64,***', json.dumps(self.conversation[convo_id])))
-        #     print(json.dumps(replaced_text, indent=4, ensure_ascii=False))
+        #     self.logger.info(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") \
@@ -247,7 +256,7 @@ class chatgpt(BaseLLM):
                 mess = self.conversation[convo_id].pop(1)
                 string_mess = json.dumps(mess, ensure_ascii=False)
                 self.current_tokens[convo_id] -= len(string_mess) / 4
-                print("Truncate message:", mess)
+                self.logger.info(f"Truncate message: {mess}")
             else:
                 break
 
@@ -327,7 +336,7 @@ class chatgpt(BaseLLM):
                 request_data["tools"] = tools_request_body
                 request_data["tool_choice"] = "auto"
 
-        # print("request_data", json.dumps(request_data, indent=4, ensure_ascii=False))
+        # self.logger.info(f"request_data: {json.dumps(request_data, indent=4, ensure_ascii=False)}")
 
         # 调用核心模块的 prepare_request_payload 函数
         url, headers, json_post_body, engine_type = await prepare_request_payload(provider, request_data)
@@ -388,7 +397,7 @@ class chatgpt(BaseLLM):
                         else:
                             return str(line)
                 except:
-                    print("json.loads error:", repr(line))
+                    self.logger.error(f"json.loads error: {repr(line)}")
                     return None
 
             resp = json.loads(line) if isinstance(line, str) else line
@@ -446,21 +455,56 @@ class chatgpt(BaseLLM):
                 yield chunk
 
         if self.print_log:
-            print("\n\rtotal_tokens", total_tokens)
+            self.logger.info(f"total_tokens: {total_tokens}")
 
         if response_role is None:
             response_role = "assistant"
 
+        missing_required_params = []
+
         if self.use_plugins == True:
             full_response = full_response.replace("<tool_code>", "").replace("</tool_code>", "")
             function_parameter = parse_function_xml(full_response)
             if function_parameter:
                 invalid_tools = [tool_dict for tool_dict in function_parameter if tool_dict.get("function_name", "") not in self.plugins.keys()]
                 function_parameter = [tool_dict for tool_dict in function_parameter if tool_dict.get("function_name", "") in self.plugins.keys()]
+
+                # Check for missing required parameters
+                valid_function_parameters = []
+                for tool_dict in function_parameter:
+                    tool_name = tool_dict.get("function_name")
+                    # tool_name must be in registry.tools, because it is in self.plugins which is from registry.tools
+                    func = registry.tools.get(tool_name)
+                    if not func:
+                        continue
+
+                    sig = inspect.signature(func)
+                    provided_params = tool_dict.get("parameter", {})
+                    # Ensure provided_params is a dictionary
+                    if not isinstance(provided_params, dict):
+                        self.logger.warning(f"Parameters for {tool_name} are not a dict: {provided_params}. Skipping.")
+                        continue
+
+                    missing_required_params = []
+                    for param in sig.parameters.values():
+                        # Check if the parameter has no default value and is not in the provided parameters
+                        if param.default is inspect.Parameter.empty and param.name not in provided_params:
+                            missing_required_params.append(param.name)
+
+                    if not missing_required_params:
+                        valid_function_parameters.append(tool_dict)
+                    else:
+                        if self.print_log:
+                            self.logger.warning(
+                                f"Skipping tool call for '{tool_name}' due to missing required parameters: {missing_required_params}"
+                            )
+                            missing_required_params.append(f"Error: {tool_name} missing required parameters: {missing_required_params}")
+                function_parameter = valid_function_parameters
+
                 if self.print_log and invalid_tools:
-                    print("invalid_tools", invalid_tools)
-                    print("function_parameter", function_parameter)
-                    print("full_response", full_response)
+                    self.logger.error(f"invalid_tools: {invalid_tools}")
+                    self.logger.error(f"function_parameter: {function_parameter}")
+                    self.logger.error(f"full_response: {full_response}")
                 if function_parameter:
                     need_function_call = True
                     if isinstance(self.conversation[convo_id][-1]["content"], str) and \
@@ -470,14 +514,14 @@ class chatgpt(BaseLLM):
                 else:
                     need_function_call = False
                     if self.print_log:
-                        print("Failed to parse function_parameter full_response", full_response)
+                        self.logger.error(f"Failed to parse function_parameter full_response: {full_response}")
                     full_response = ""
 
         # 处理函数调用
         if need_function_call and self.use_plugins == True:
             if self.print_log:
-                print("function_parameter", function_parameter)
-                print("function_full_response", function_full_response)
+                self.logger.info(f"function_parameter: {function_parameter}")
+                self.logger.info(f"function_full_response: {function_full_response}")
 
             function_response = ""
             # 定义处理单个工具调用的辅助函数
@@ -496,7 +540,7 @@ class chatgpt(BaseLLM):
                     if function_call_max_tokens <= 0:
                         function_call_max_tokens = int(self.truncate_limit / 2)
                     if self.print_log:
-                        print(f"\033[32m function_call {tool_name}, max token: {function_call_max_tokens} \033[0m")
+                        self.logger.info(f"function_call {tool_name}, max token: {function_call_max_tokens}")
 
                     # 处理函数调用结果
                     if is_async:
@@ -529,7 +573,7 @@ class chatgpt(BaseLLM):
                 if function_full_response:
                     function_parameter = parse_continuous_json(function_full_response, function_call_name)
             except Exception as e:
-                print(f"解析JSON失败: {e}")
+                self.logger.error(f"解析JSON失败: {e}")
                 # 保持原始工具调用
                 tool_calls = [{
                     'function_name': function_call_name,
@@ -579,6 +623,8 @@ class chatgpt(BaseLLM):
 
             # 合并所有工具响应
             function_response = "\n\n".join(all_responses).strip()
+            if missing_required_params:
+                function_response += "\n\n" + "\n\n".join(missing_required_params)
 
             # 使用第一个工具的名称和参数作为历史记录
             function_call_name = tool_calls[0]['function_name']
@@ -668,27 +714,56 @@ class chatgpt(BaseLLM):
 
         # 打印日志
         if self.print_log:
-            print("api_url", kwargs.get('api_url', self.api_url.chat_url), url)
-            print("api_key", kwargs.get('api_key', self.api_key))
+            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)))
-                print(json.dumps(replaced_text, indent=4, ensure_ascii=False))
+                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
-                    async_generator = fetch_response_stream(
-                        self.aclient,
-                        url,
-                        headers,
-                        json_post,
-                        engine_type,
-                        model or self.engine,
-                    )
+                    # 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,
@@ -709,15 +784,15 @@ class chatgpt(BaseLLM):
                 # 将异步函数转换为同步生成器
                 return async_generator_to_sync(process_async())
             except ConnectionError:
-                print("连接错误，请检查服务器状态或网络连接。")
+                self.logger.error("连接错误，请检查服务器状态或网络连接。")
                 return
             except requests.exceptions.ReadTimeout:
-                print("请求超时，请检查网络连接或增加超时时间。")
+                self.logger.error("请求超时，请检查网络连接或增加超时时间。")
                 return
             except httpx.RemoteProtocolError:
                 continue
             except Exception as e:
-                print(f"发生了未预料的错误：{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}")
@@ -755,28 +830,54 @@ 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", url)
-            # print("headers", headers)
-            print("api_key", kwargs.get('api_key', self.api_key))
+            self.logger.info(f"api_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)))
-                print(json.dumps(replaced_text, indent=4, ensure_ascii=False))
+                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处理响应
-                generator = fetch_response_stream(
-                    self.aclient,
-                    url,
-                    headers,
-                    json_post,
-                    engine_type,
-                    model or self.engine,
-                )
+                # 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"
+                    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):
@@ -810,9 +911,9 @@ class chatgpt(BaseLLM):
             except httpx.RemoteProtocolError:
                 continue
             except Exception as e:
-                print(f"发生了未预料的错误：{e}")
+                self.logger.error(f"发生了未预料的错误：{e}")
                 import traceback
-                traceback.print_exc()
+                self.logger.error(traceback.format_exc())
                 if "Invalid URL" in str(e):
                     e = "您输入了无效的API URL，请使用正确的URL并使用`/start`命令重新设置API URL。具体错误如下：\n\n" + str(e)
                     raise Exception(f"{e}")
@@ -979,7 +1080,7 @@ class chatgpt(BaseLLM):
                 return json_post, True, None
 
         except Exception as e:
-            print(f"处理响应错误时出现异常: {e}")
+            self.logger.error(f"处理响应错误时出现异常: {e}")
             return json_post, False, str(e)
 
     def _handle_response_error_sync(self, response, json_post):

beswarm/aient/src/aient/plugins/write_file.py

@@ -4,7 +4,7 @@ from ..utils.scripts import unescape_html
 import os
 
 @register_tool()
-def write_to_file(path, content, mode='w'):
+def write_to_file(path, content, mode='w', newline=False):
     """
 ## write_to_file
 Description: Request to write full content to a file at the specified path. If the file exists, it will be overwritten with the provided content. If the file doesn't exist, it will be created. This tool will automatically create any directories needed to write the file.
@@ -12,6 +12,7 @@ Parameters:
 - path: (required) The path of the file to write to (relative to the current working directory ${args.cwd})
 - content: (required) The content to write to the file. ALWAYS provide the COMPLETE intended content of the file, without any truncation or omissions. You MUST include ALL parts of the file, even if they haven't been modified. Do NOT include the line numbers in the content though, just the actual content of the file.
 - mode: (optional) The mode to write to the file. Default is 'w'. 'w' for write, 'a' for append.
+- newline: (optional) Whether to add a newline before the content. Default is False.
 Usage:
 <write_to_file>
 <path>File path here</path>
@@ -19,6 +20,7 @@ Usage:
 Your file content here
 </content>
 <mode>w</mode>
+<newline>False</newline>
 </write_to_file>
 
 Example: Requesting to write to frontend-config.json
@@ -51,6 +53,9 @@ Example: Requesting to write to frontend-config.json
     if content.startswith("---\n") and (path.endswith(".md") or path.endswith(".txt")):
         content = "\n" + content
 
+    if newline:
+        content = '\n' + content
+
     # 写入文件
     try:
         with open(path, mode, encoding='utf-8') as file:

beswarm/aient/test/test_API.py

@@ -1,6 +1,6 @@
 def replace_with_asterisk(string, start=15, end=40):
     return string[:start] + '*' * (end - start) + string[end:]
 
-original_string = "sk-zIuWeeuWY8vNCVhhHCXLroNmA6QhBxnv0ARMFcODVQwwqGRg"
+original_string = "sk-bvgiugvigycycyrfctdyxdxrts"
 result = replace_with_asterisk(original_string)
 print(result)