aient 1.0.45__py3-none-any.whl → 1.0.47__py3-none-any.whl

aient/core/request.py

@@ -96,7 +96,8 @@ async def get_gemini_payload(request, engine, provider, api_key=None):
             content[0]["text"] = re.sub(r"_+", "_", content[0]["text"])
             systemInstruction = {"parts": content}
 
-    if "gemini-2.0-flash-exp" in original_model or "gemini-1.5" in original_model:
+    off_models = ["gemini-2.0-flash-exp", "gemini-1.5", "gemini-2.5-pro"]
+    if any(off_model in original_model for off_model in off_models):
         safety_settings = "OFF"
     else:
         safety_settings = "BLOCK_NONE"
@@ -119,7 +120,11 @@ async def get_gemini_payload(request, engine, provider, api_key=None):
             {
                 "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
                 "threshold": safety_settings
-            }
+            },
+            {
+                "category": "HARM_CATEGORY_CIVIC_INTEGRITY",
+                "threshold": "BLOCK_NONE"
+            },
         ]
     }
 

aient/core/utils.py

@@ -155,7 +155,8 @@ def update_initial_model(provider):
         proxy = safe_get(provider, "preferences", "proxy", default=None)
         client_config = get_proxy(proxy)
         if engine == "gemini":
-            url = "https://generativelanguage.googleapis.com/v1beta/models"
+            before_v1 = api_url.split("/v1beta")[0]
+            url = before_v1 + "/v1beta/models"
             params = {"key": api}
             with httpx.Client(**client_config) as client:
                 response = client.get(url, params=params)
@@ -288,7 +289,7 @@ class ThreadSafeCircularList:
             # self.requests[item] = []
             logger.warning(f"API key {item} 已进入冷却状态，冷却时间 {cooling_time} 秒")
 
-    async def is_rate_limited(self, item, model: str = None) -> bool:
+    async def is_rate_limited(self, item, model: str = None, is_check: bool = False) -> bool:
         now = time()
         # 检查是否在冷却中
         if now < self.cooling_until[item]:
@@ -321,7 +322,8 @@ class ThreadSafeCircularList:
             # 使用特定模型的请求记录进行计算
             recent_requests = sum(1 for req in self.requests[item][model_key] if req > now - limit_period)
             if recent_requests >= limit_count:
-                logger.warning(f"API key {item} 对模型 {model_key} 已达到速率限制 ({limit_count}/{limit_period}秒)")
+                if not is_check:
+                    logger.warning(f"API key {item}: model: {model_key} has been rate limited ({limit_count}/{limit_period} seconds)")
                 return True
 
         # 清理太旧的请求记录
@@ -329,7 +331,9 @@ class ThreadSafeCircularList:
         self.requests[item][model_key] = [req for req in self.requests[item][model_key] if req > now - max_period]
 
         # 记录新的请求
-        self.requests[item][model_key].append(now)
+        if not is_check:
+            self.requests[item][model_key].append(now)
+
         return False
 
     async def next(self, model: str = None):
@@ -349,6 +353,30 @@ class ThreadSafeCircularList:
                     logger.warning(f"All API keys are rate limited!")
                     raise HTTPException(status_code=429, detail="Too many requests")
 
+    async def is_all_rate_limited(self, model: str = None) -> bool:
+        """检查是否所有的items都被速率限制
+
+        与next方法不同，此方法不会改变任何内部状态（如self.index），
+        仅返回一个布尔值表示是否所有的key都被限制。
+
+        Args:
+            model: 要检查的模型名称，默认为None
+
+        Returns:
+            bool: 如果所有items都被速率限制返回True，否则返回False
+        """
+        if len(self.items) == 0:
+            return False
+
+        async with self.lock:
+            for item in self.items:
+                if not await self.is_rate_limited(item, model, is_check=True):
+                    return False
+
+            # 如果遍历完所有items都被限制，返回True
+            # logger.debug(f"Check result: all items are rate limited!")
+            return True
+
     async def after_next_current(self):
         # 返回当前取出的 API，因为已经调用了 next，所以当前API应该是上一个
         if len(self.items) == 0:

aient/models/chatgpt.py

@@ -12,7 +12,7 @@ from pathlib import Path
 
 from .base import BaseLLM
 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
+from ..utils.scripts import safe_get, async_generator_to_sync, parse_function_xml, parse_continuous_json, convert_functions_to_xml
 from ..core.request import prepare_request_payload
 from ..core.response import fetch_response_stream
 
@@ -148,7 +148,7 @@ class chatgpt(BaseLLM):
                     })
                 self.conversation[convo_id].append({"role": role, "tool_call_id": function_call_id, "content": message})
             else:
-                self.conversation[convo_id].append({"role": "assistant", "content": "I will use tool: " + function_arguments + ". I will get the tool call result in the next user response."})
+                self.conversation[convo_id].append({"role": "assistant", "content": convert_functions_to_xml(function_arguments)})
                 self.conversation[convo_id].append({"role": "user", "content": message})
 
         else:
@@ -159,7 +159,9 @@ class chatgpt(BaseLLM):
 
         conversation_len = len(self.conversation[convo_id]) - 1
         message_index = 0
-        # print(json.dumps(self.conversation[convo_id], indent=4, ensure_ascii=False))
+        # 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))
         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"):
@@ -180,6 +182,9 @@ class chatgpt(BaseLLM):
                     and type(self.conversation[convo_id][message_index + 1]["content"]) == dict:
                         self.conversation[convo_id][message_index]["content"] = [self.conversation[convo_id][message_index]["content"]]
                         self.conversation[convo_id][message_index + 1]["content"] = [self.conversation[convo_id][message_index + 1]["content"]]
+                    if type(self.conversation[convo_id][message_index]["content"]) == list \
+                    and type(self.conversation[convo_id][message_index + 1]["content"]) == dict:
+                        self.conversation[convo_id][message_index + 1]["content"] = [self.conversation[convo_id][message_index + 1]["content"]]
                     self.conversation[convo_id][message_index]["content"] += self.conversation[convo_id][message_index + 1]["content"]
                 self.conversation[convo_id].pop(message_index + 1)
                 conversation_len = conversation_len - 1
@@ -413,6 +418,7 @@ class chatgpt(BaseLLM):
         # 处理函数调用
         if need_function_call:
             if self.print_log:
+                print("function_parameter", function_parameter)
                 print("function_full_response", function_full_response)
 
             function_response = ""

aient/utils/scripts.py

@@ -460,6 +460,7 @@ class XmlMatcher(Generic[R]):
 def parse_function_xml(xml_content: str) -> List[Dict[str, Any]]:
     """
     解析XML格式的函数调用信息，转换为字典数组格式
+    只解析倒数两层XML标签，忽略更高层级的XML标签
 
     参数:
         xml_content: 包含一个或多个函数调用的XML字符串
@@ -469,6 +470,7 @@ def parse_function_xml(xml_content: str) -> List[Dict[str, Any]]:
     """
     result_functions = []
 
+    # 第一步：识别XML中的顶层标签（可能是函数调用）
     position = 0
     while position < len(xml_content):
         # 寻找下一个开始标签
@@ -482,22 +484,23 @@ def parse_function_xml(xml_content: str) -> List[Dict[str, Any]]:
             position = tag_start + 1
             continue
 
+        # 找到标签的结束位置
         tag_end = xml_content.find(">", tag_start)
         if tag_end == -1:
             break  # 标签未正确关闭
 
-        # 提取标签名（函数名）
+        # 提取标签名
         tag_content = xml_content[tag_start+1:tag_end].strip()
         # 处理可能有属性的情况
-        function_name = tag_content.split()[0] if " " in tag_content else tag_content
+        tag_name = tag_content.split()[0] if " " in tag_content else tag_content
 
-        if not function_name:
+        if not tag_name:
             position = tag_end + 1
             continue  # 空标签名，跳过
 
-        # 查找整个函数调用的起止范围
-        full_start_tag = f"<{function_name}"
-        full_end_tag = f"</{function_name}>"
+        # 查找整个标签的起止范围
+        full_start_tag = f"<{tag_name}"
+        full_end_tag = f"</{tag_name}>"
 
         # 从当前位置找到开始标签
         start_pos = xml_content.find(full_start_tag, position)
@@ -512,78 +515,67 @@ def parse_function_xml(xml_content: str) -> List[Dict[str, Any]]:
             position = tag_end + 1
             continue
 
-        # 计算整个函数标签内容，包括开始和结束标签
-        end_pos_complete = end_pos + len(full_end_tag)
-        full_tag_content = xml_content[start_pos:end_pos_complete]
-
-        # 使用XmlMatcher提取该函数标签内的内容
-        content_matcher = XmlMatcher[XmlMatcherResult](function_name)
-        match_results = content_matcher.final(full_tag_content)
-
-        function_content = ""
-        for result in match_results:
-            if result.matched:
-                function_content = result.data
-                break
-
-        # 解析参数
-        parameters = {}
-        if function_content:
-            lines = function_content.strip().split('\n')
-            current_param = None
-            current_value = []
-
-            for line in lines:
-                line = line.strip()
-                if line.startswith('<') and '>' in line and not line.startswith('</'):
-                    # 新参数开始
-                    if current_param and current_value:
-                        # 保存之前的参数
-                        parameters[current_param] = '\n'.join(current_value).strip()
-                        current_value = []
-
-                    # 提取参数名
-                    param_start = line.find('<') + 1
-                    param_end = line.find('>', param_start)
-                    if param_end != -1:
-                        param = line[param_start:param_end]
-                        # 检查是否是闭合标签
-                        if not param.startswith('/'):
-                            current_param = param
-                            # 检查是否在同一行有值
-                            rest = line[param_end+1:]
-                            if rest and not rest.startswith('</'):
-                                current_value.append(rest)
-                elif line.startswith('</') and '>' in line:
-                    # 参数结束
-                    if current_param and current_value:
-                        param_end_tag = f"</{current_param}>"
-                        if line.strip() == param_end_tag:
-                            parameters[current_param] = '\n'.join(current_value).strip()
-                            current_param = None
-                            current_value = []
-                elif current_param:
-                    # 继续收集当前参数的值
-                    current_value.append(line)
-
-            # 处理最后一个参数
-            if current_param and current_value:
-                parameters[current_param] = '\n'.join(current_value).strip()
-
-            # 清理参数值中可能的结束标签
-            for param, value in parameters.items():
-                end_tag = f'</{param}>'
-                if value.endswith(end_tag):
-                    parameters[param] = value[:-len(end_tag)].strip()
-
-        # 将解析的函数添加到结果数组
-        result_functions.append({
-            'function_name': function_name,
-            'parameter': parameters
-        })
-
-        # 更新位置到当前标签之后，继续查找下一个函数
-        position = end_pos_complete
+        # 标签的内容（不包括开始和结束标签）
+        tag_inner_content = xml_content[tag_end+1:end_pos]
+
+        # 如果是普通辅助标签（如tool_call），则在其内部寻找函数调用
+        if tag_name in ["tool_call", "function_call", "tool", "function"]:
+            # 递归处理内部内容
+            nested_functions = parse_function_xml(tag_inner_content)
+            result_functions.extend(nested_functions)
+        else:
+            # 将当前标签作为函数名，解析其内部标签作为参数
+            parameters = {}
+
+            # 解析内部标签作为参数
+            param_position = 0
+            while param_position < len(tag_inner_content):
+                param_tag_start = tag_inner_content.find("<", param_position)
+                if param_tag_start == -1:
+                    break
+
+                # 跳过闭合标签
+                if param_tag_start + 1 < len(tag_inner_content) and tag_inner_content[param_tag_start + 1] == '/':
+                    param_position = param_tag_start + 1
+                    continue
+
+                param_tag_end = tag_inner_content.find(">", param_tag_start)
+                if param_tag_end == -1:
+                    break
+
+                # 提取参数名
+                param_name = tag_inner_content[param_tag_start+1:param_tag_end].strip()
+                if " " in param_name:  # 处理有属性的情况
+                    param_name = param_name.split()[0]
+
+                if not param_name:
+                    param_position = param_tag_end + 1
+                    continue
+
+                # 查找参数标签的结束位置
+                param_end_tag = f"</{param_name}>"
+                param_end_pos = tag_inner_content.find(param_end_tag, param_tag_end)
+
+                if param_end_pos == -1:
+                    # 参数标签未闭合
+                    param_position = param_tag_end + 1
+                    continue
+
+                # 提取参数值
+                param_value = tag_inner_content[param_tag_end+1:param_end_pos].strip()
+                parameters[param_name] = param_value
+
+                # 更新位置到当前参数标签之后
+                param_position = param_end_pos + len(param_end_tag)
+
+            # 添加解析结果
+            result_functions.append({
+                'function_name': tag_name,
+                'parameter': parameters
+            })
+
+        # 更新位置到当前标签之后
+        position = end_pos + len(full_end_tag)
 
     return result_functions
 
@@ -657,5 +649,71 @@ def parse_continuous_json(json_str: str, function_name: str = "") -> List[Dict[s
 
     return result
 
+def convert_functions_to_xml(functions_list):
+    """
+    将函数调用列表转换为XML格式的字符串
+
+    参数:
+        functions_list: 函数调用列表，每个元素是包含function_name和parameter的字典
+
+    返回:
+        XML格式的字符串
+    """
+    xml_result = ""
+
+    if isinstance(functions_list, str):
+        try:
+            # 提取并解析JSON字符串
+            functions_list = json.loads(functions_list)
+            # 确保解析结果是列表
+            if not isinstance(functions_list, list):
+                print(f"提取的工具调用不是列表格式: {functions_list}")
+        except json.JSONDecodeError as e:
+            print(f"从文本中提取的工具调用JSON解析失败: {e}")
+
+    for func in functions_list:
+        # 获取函数名和参数
+        function_name = func.get('function_name', '')
+        parameters = func.get('parameter', {})
+
+        # 开始函数标签
+        xml_result += f"<{function_name}>\n"
+
+        # 添加所有参数
+        for param_name, param_value in parameters.items():
+            xml_result += f"<{param_name}>{param_value}</{param_name}>\n"
+
+        # 结束函数标签
+        xml_result += f"</{function_name}>\n"
+
+    return xml_result
+
 if __name__ == "__main__":
-    os.system("clear")
+
+    # 运行本文件：python -m aient.utils.scripts
+    os.system("clear")
+    test_xml = """
+✅ 好的，我现在读取 `README.md` 文件。
+<tool_call>
+<read_file>
+<file_path>/Users/yanyuming/Downloads/GitHub/llama3_interpretability_sae/README.md</file_path>
+</read_file>
+</tool_call>好的，我现在读取 `README.md` 文件。
+"""
+    test_xml = """
+✅ 好的，我现在读取 `README.md` 文件。
+<read_file>
+<file_path>README.md</file_path>
+</read_file>
+<read_file>
+<file_path>README.md</file_path>
+</read_file>
+
+<tool_call>
+<read_file>
+<file_path>README.md</file_path>
+</read_file>
+</tool_call>
+好的，我现在读取 `README.md` 文件。
+"""
+    print(parse_function_xml(test_xml))

{aient-1.0.45.dist-info → aient-1.0.47.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aient
-Version: 1.0.45
+Version: 1.0.47
 Summary: Aient: The Awakening of Agent.
 Description-Content-Type: text/markdown
 License-File: LICENSE

{aient-1.0.45.dist-info → aient-1.0.47.dist-info}/RECORD

@@ -3,16 +3,16 @@ aient/core/.git,sha256=lrAcW1SxzRBUcUiuKL5tS9ykDmmTXxyLP3YYU-Y-Q-I,45
 aient/core/__init__.py,sha256=NxjebTlku35S4Dzr16rdSqSTWUvvwEeACe8KvHJnjPg,34
 aient/core/log_config.py,sha256=kz2_yJv1p-o3lUQOwA3qh-LSc3wMHv13iCQclw44W9c,274
 aient/core/models.py,sha256=H3_XuWA7aS25MWZPK1c-5RBiiuxWJbTfE3RAk0Pkc9A,7504
-aient/core/request.py,sha256=6c9drOddcvfeuLoUmDUWxP0gekW-ov839wiYETsNiZ0,48895
+aient/core/request.py,sha256=OlMkjGMcFAH-ItA1PgPuf2HT-RbI-Ca4JXncWApc3gM,49088
 aient/core/response.py,sha256=7RVSFfGHisejv2SlsHvp0t-N_8OpTS4edQU_NOi5BGU,25822
-aient/core/utils.py,sha256=i9ZwyywBLIhRM0fNmFSD3jF3dBL5QqVMOtSlG_ddv-I,24101
+aient/core/utils.py,sha256=I0u3WLWaMd4j1ShqKg_tz67m-1wr_uXlWgxGeUjIIiE,25098
 aient/core/test/test_base_api.py,sha256=CjfFzMG26r8C4xCPoVkKb3Ac6pp9gy5NUCbZJHoSSsM,393
 aient/core/test/test_image.py,sha256=_T4peNGdXKBHHxyQNx12u-NTyFE8TlYI6NvvagsG2LE,319
 aient/core/test/test_payload.py,sha256=8jBiJY1uidm1jzL-EiK0s6UGmW9XkdsuuKFGrwFhFkw,2755
 aient/models/__init__.py,sha256=ouNDNvoBBpIFrLsk09Q_sq23HR0GbLAKfGLIFmfEuXE,219
 aient/models/audio.py,sha256=kRd-8-WXzv4vwvsTGwnstK-WR8--vr9CdfCZzu8y9LA,1934
 aient/models/base.py,sha256=Loyt2F2WrDMBbK-sdmTtgkLVtdUXxK5tg4qoI6nc0Xo,7527
-aient/models/chatgpt.py,sha256=rF95RmO4C3h4PKRqE3Qk6fKoR0yIf-3zp8t7KBF_kjA,41685
+aient/models/chatgpt.py,sha256=r56r0Q7sTSU1WQcrFDfVfb3LOtHuHLJpoqhy-pAE1TA,42202
 aient/models/claude.py,sha256=thK9P8qkaaoUN3OOJ9Shw4KDs-pAGKPoX4FOPGFXva8,28597
 aient/models/duckduckgo.py,sha256=1l7vYCs9SG5SWPCbcl7q6pCcB5AUF_r-a4l9frz3Ogo,8115
 aient/models/gemini.py,sha256=chGLc-8G_DAOxr10HPoOhvVFW1RvMgHd6mt--VyAW98,14730
@@ -28,9 +28,9 @@ aient/plugins/today.py,sha256=btnXJNqWorJDKPvH9PBTdHaExpVI1YPuSAeRrq-fg9A,667
 aient/plugins/websearch.py,sha256=yiBzqXK5X220ibR-zko3VDsn4QOnLu1k6E2YOygCeTQ,15185
 aient/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 aient/utils/prompt.py,sha256=UcSzKkFE4-h_1b6NofI6xgk3GoleqALRKY8VBaXLjmI,11311
-aient/utils/scripts.py,sha256=obrf5oxzFQPCu1A5MYDDiZv_LM6l9C1QSkgWIqcu28k,25690
-aient-1.0.45.dist-info/licenses/LICENSE,sha256=XNdbcWldt0yaNXXWB_Bakoqnxb3OVhUft4MgMA_71ds,1051
-aient-1.0.45.dist-info/METADATA,sha256=Wt-dsD5uQjMdMfWGA052WOC7ITd8UQy84MiGPkABO8A,4986
-aient-1.0.45.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-aient-1.0.45.dist-info/top_level.txt,sha256=3oXzrP5sAVvyyqabpeq8A2_vfMtY554r4bVE-OHBrZk,6
-aient-1.0.45.dist-info/RECORD,,
+aient/utils/scripts.py,sha256=XCXMRdpWRJb34Znk4t9JkFnvzDzGHVA5Vv5WpUgP2_0,27152
+aient-1.0.47.dist-info/licenses/LICENSE,sha256=XNdbcWldt0yaNXXWB_Bakoqnxb3OVhUft4MgMA_71ds,1051
+aient-1.0.47.dist-info/METADATA,sha256=2qqnAF8-z1wWVwel2w3v7OL31j69wpY_fr224GFnJwQ,4986
+aient-1.0.47.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+aient-1.0.47.dist-info/top_level.txt,sha256=3oXzrP5sAVvyyqabpeq8A2_vfMtY554r4bVE-OHBrZk,6
+aient-1.0.47.dist-info/RECORD,,