aient 1.1.75__tar.gz → 1.1.76__tar.gz

{aient-1.1.75 → aient-1.1.76}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aient
-Version: 1.1.75
+Version: 1.1.76
 Summary: Aient: The Awakening of Agent.
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{aient-1.1.75 → aient-1.1.76}/aient/core/response.py

@@ -3,6 +3,7 @@ import json
 import random
 import string
 import base64
+import asyncio
 from datetime import datetime
 
 from .log_config import logger
@@ -14,19 +15,19 @@ async def check_response(response, error_log):
         error_message = await response.aread()
         error_str = error_message.decode('utf-8', errors='replace')
         try:
-            error_json = json.loads(error_str)
+            error_json = await asyncio.to_thread(json.loads, error_str)
         except json.JSONDecodeError:
             error_json = error_str
         return {"error": f"{error_log} HTTP Error", "status_code": response.status_code, "details": error_json}
     return None
 
-def gemini_json_poccess(response_str):
+async def gemini_json_poccess(response_str):
     promptTokenCount = 0
     candidatesTokenCount = 0
     totalTokenCount = 0
     image_base64 = None
 
-    response_json = json.loads(response_str)
+    response_json = await asyncio.to_thread(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:
@@ -75,7 +76,7 @@ async def fetch_gemini_response_stream(client, url, headers, payload, model, tim
                 if line.startswith("data: "):
                     parts_json = line.lstrip("data: ").strip()
                     try:
-                        json.loads(parts_json)
+                        await asyncio.to_thread(json.loads, parts_json)
                     except json.JSONDecodeError:
                         logger.error(f"JSON decode error: {parts_json}")
                         continue
@@ -83,12 +84,12 @@ async def fetch_gemini_response_stream(client, url, headers, payload, model, tim
                     parts_json += line
                     parts_json = parts_json.lstrip("[,")
                     try:
-                        json.loads(parts_json)
+                        await asyncio.to_thread(json.loads, parts_json)
                     except json.JSONDecodeError:
                         continue
 
                 # https://ai.google.dev/api/generate-content?hl=zh-cn#FinishReason
-                is_thinking, reasoning_content, 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 = await gemini_json_poccess(parts_json)
 
                 if is_thinking:
                     sse_string = await generate_sse_response(timestamp, model, reasoning_content=reasoning_content)
@@ -159,7 +160,7 @@ async def fetch_vertex_claude_response_stream(client, url, headers, payload, mod
 
                 if line and '\"text\": \"' in line and is_finish == False:
                     try:
-                        json_data = json.loads( "{" + line.strip().rstrip(",") + "}")
+                        json_data = await asyncio.to_thread(json.loads, "{" + line.strip().rstrip(",") + "}")
                         content = json_data.get('text', '')
                         sse_string = await generate_sse_response(timestamp, model, content=content)
                         yield sse_string
@@ -176,7 +177,7 @@ async def fetch_vertex_claude_response_stream(client, url, headers, payload, mod
                     function_full_response += line
 
         if need_function_call:
-            function_call = json.loads(function_full_response)
+            function_call = await asyncio.to_thread(json.loads, function_full_response)
             function_call_name = function_call["name"]
             function_call_id = function_call["id"]
             sse_string = await generate_sse_response(timestamp, model, content=None, tools_id=function_call_id, function_call_name=function_call_name)
@@ -213,7 +214,7 @@ async def fetch_gpt_response_stream(client, url, headers, payload, timeout):
                 if line and not line.startswith(":") and (result:=line.lstrip("data: ").strip()):
                     if result.strip() == "[DONE]":
                         break
-                    line = json.loads(result)
+                    line = await asyncio.to_thread(json.loads, result)
                     line['id'] = f"chatcmpl-{random_str}"
 
                     # 处理 <think> 标签
@@ -327,7 +328,7 @@ async def fetch_azure_response_stream(client, url, headers, payload, timeout):
                 if line and not line.startswith(":") and (result:=line.lstrip("data: ").strip()):
                     if result.strip() == "[DONE]":
                         break
-                    line = json.loads(result)
+                    line = await asyncio.to_thread(json.loads, result)
                     no_stream_content = safe_get(line, "choices", 0, "message", "content", default="")
                     content = safe_get(line, "choices", 0, "delta", "content", default="")
 
@@ -380,7 +381,7 @@ async def fetch_cloudflare_response_stream(client, url, headers, payload, model,
                     line = line.lstrip("data: ")
                     if line == "[DONE]":
                         break
-                    resp: dict = json.loads(line)
+                    resp: dict = await asyncio.to_thread(json.loads, line)
                     message = resp.get("response")
                     if message:
                         sse_string = await generate_sse_response(timestamp, model, content=message)
@@ -401,7 +402,7 @@ async def fetch_cohere_response_stream(client, url, headers, payload, model, tim
             while "\n" in buffer:
                 line, buffer = buffer.split("\n", 1)
                 # logger.info("line: %s", repr(line))
-                resp: dict = json.loads(line)
+                resp: dict = await asyncio.to_thread(json.loads, line)
                 if resp.get("is_finished") == True:
                     break
                 if resp.get("event_type") == "text-generation":
@@ -427,7 +428,7 @@ async def fetch_claude_response_stream(client, url, headers, payload, model, tim
                 # logger.info(line)
 
                 if line.startswith("data:") and (line := line.lstrip("data: ")):
-                    resp: dict = json.loads(line)
+                    resp: dict = await asyncio.to_thread(json.loads, line)
 
                     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)
@@ -486,7 +487,7 @@ async def fetch_aws_response_stream(client, url, headers, payload, model, timeou
                 if not json_match:
                     continue
                 try:
-                    chunk_data = json.loads(json_match.group(0).lstrip('event'))
+                    chunk_data = await asyncio.to_thread(json.loads, json_match.group(0).lstrip('event'))
                 except json.JSONDecodeError:
                     logger.error(f"DEBUG json.JSONDecodeError: {json_match.group(0).lstrip('event')!r}")
                     continue
@@ -496,7 +497,7 @@ async def fetch_aws_response_stream(client, url, headers, payload, model, timeou
                     # 解码 Base64 编码的字节
                     decoded_bytes = base64.b64decode(chunk_data["bytes"])
                     # 将解码后的字节再次解析为 JSON
-                    payload_chunk = json.loads(decoded_bytes.decode('utf-8'))
+                    payload_chunk = await asyncio.to_thread(json.loads, decoded_bytes.decode('utf-8'))
                     # print(f"DEBUG payload_chunk: {payload_chunk!r}")
 
                     text = safe_get(payload_chunk, "delta", "text", default="")
@@ -530,7 +531,8 @@ async def fetch_response(client, url, headers, payload, engine, model, timeout=2
         yield response.read()
 
     elif engine == "gemini" or engine == "vertex-gemini" or engine == "aws":
-        response_json = response.json()
+        response_bytes = await response.aread()
+        response_json = await asyncio.to_thread(json.loads, response_bytes)
         # print("response_json", json.dumps(response_json, indent=4, ensure_ascii=False))
 
         if isinstance(response_json, str):
@@ -585,7 +587,8 @@ async def fetch_response(client, url, headers, payload, engine, model, timeout=2
         yield await generate_no_stream_response(timestamp, model, content=content, tools_id=None, function_call_name=function_call_name, function_call_content=function_call_content, role=role, total_tokens=total_tokens, prompt_tokens=prompt_tokens, completion_tokens=candidates_tokens, reasoning_content=reasoning_content, image_base64=image_base64)
 
     elif engine == "claude":
-        response_json = response.json()
+        response_bytes = await response.aread()
+        response_json = await asyncio.to_thread(json.loads, response_bytes)
         # print("response_json", json.dumps(response_json, indent=4, ensure_ascii=False))
 
         content = safe_get(response_json, "content", 0, "text")
@@ -604,7 +607,8 @@ async def fetch_response(client, url, headers, payload, engine, model, timeout=2
         yield await generate_no_stream_response(timestamp, model, content=content, tools_id=tools_id, function_call_name=function_call_name, function_call_content=function_call_content, role=role, total_tokens=total_tokens, prompt_tokens=prompt_tokens, completion_tokens=output_tokens)
 
     elif engine == "azure":
-        response_json = response.json()
+        response_bytes = await response.aread()
+        response_json = await asyncio.to_thread(json.loads, response_bytes)
         # 删除 content_filter_results
         if "choices" in response_json:
             for choice in response_json["choices"]:
@@ -618,11 +622,13 @@ async def fetch_response(client, url, headers, payload, engine, model, timeout=2
         yield response_json
 
     elif "dashscope.aliyuncs.com" in url and "multimodal-generation" in url:
-        response_json = response.json()
+        response_bytes = await response.aread()
+        response_json = await asyncio.to_thread(json.loads, response_bytes)
         content = safe_get(response_json, "output", "choices", 0, "message", "content", 0, default=None)
         yield content
     else:
-        response_json = response.json()
+        response_bytes = await response.aread()
+        response_json = await asyncio.to_thread(json.loads, response_bytes)
         yield response_json
 
 async def fetch_response_stream(client, url, headers, payload, engine, model, timeout=200):

{aient-1.1.75 → aient-1.1.76}/aient/models/chatgpt.py

@@ -15,6 +15,31 @@ from ..utils.scripts import safe_get, async_generator_to_sync, parse_function_xm
 from ..core.request import prepare_request_payload
 from ..core.response import fetch_response_stream, fetch_response
 
+class APITimeoutError(Exception):
+    """Custom exception for API timeout errors."""
+    pass
+
+class ValidationError(Exception):
+    """Custom exception for response validation errors."""
+    def __init__(self, message, response_text):
+        super().__init__(message)
+        self.response_text = response_text
+
+class EmptyResponseError(Exception):
+    """Custom exception for empty API responses."""
+    pass
+
+class ModelNotFoundError(Exception):
+    """Custom exception for model not found (404) errors."""
+    pass
+
+class TaskComplete(Exception):
+    """Exception-like signal to indicate the task is complete."""
+    def __init__(self, message):
+        self.completion_message = message
+        super().__init__(f"Task completed with message: {message}")
+
+
 class chatgpt(BaseLLM):
     """
     Official ChatGPT API
@@ -436,7 +461,7 @@ class chatgpt(BaseLLM):
                 yield chunk
 
         if not full_response.strip():
-            raise Exception(json.dumps({"type": "response_empty_error", "message": "Response is empty"}, ensure_ascii=False))
+            raise EmptyResponseError("Response is empty")
 
         if self.print_log:
             self.logger.info(f"total_tokens: {total_tokens}")
@@ -450,7 +475,7 @@ class chatgpt(BaseLLM):
             if self.check_done:
                 # self.logger.info(f"worker Response: {full_response}")
                 if not full_response.strip().endswith('[done]'):
-                    raise Exception(json.dumps({"type": "validation_error", "message": "Response is not ended with [done]", "response": full_response}, ensure_ascii=False))
+                    raise ValidationError("Response is not ended with [done]", response_text=full_response)
                 else:
                     full_response = full_response.strip().rstrip('[done]')
             full_response = full_response.replace("<tool_code>", "").replace("</tool_code>", "")
@@ -494,6 +519,8 @@ class chatgpt(BaseLLM):
                 # 删除 task_complete 跟其他工具一起调用的情况，因为 task_complete 必须单独调用
                 if len(function_parameter) > 1:
                     function_parameter = [tool_dict for tool_dict in function_parameter if tool_dict.get("function_name", "") != "task_complete"]
+                if len(function_parameter) == 1 and function_parameter[0].get("function_name", "") == "task_complete":
+                    raise TaskComplete(safe_get(function_parameter, 0, "parameter", "message", default="The task has been completed."))
 
                 if self.print_log and invalid_tools:
                     self.logger.error(f"invalid_tools: {invalid_tools}")
@@ -739,13 +766,20 @@ class chatgpt(BaseLLM):
                         )
 
                 # 处理正常响应
+                index = 0
                 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, stream=stream, **kwargs
                 ):
+                    if index == 0:
+                        if "HTTP Error', 'status_code': 524" in processed_chunk:
+                            raise APITimeoutError("Response timeout")
+                        if "HTTP Error', 'status_code': 404" in processed_chunk:
+                            raise ModelNotFoundError(f"Model: {model or self.engine} not found!")
                     yield processed_chunk
+                    index += 1
 
                 # 成功处理，跳出重试循环
                 break
@@ -754,17 +788,25 @@ class chatgpt(BaseLLM):
                 return # Stop iteration
             except httpx.RemoteProtocolError:
                 continue
+            except APITimeoutError:
+                self.logger.warning("API response timeout (524), retrying...")
+                continue
+            except ValidationError as e:
+                self.logger.warning(f"Validation failed: {e}. Retrying with corrective prompt.")
+                need_done_prompt = [
+                    {"role": "assistant", "content": e.response_text},
+                    {"role": "user", "content": "你的消息没有以[done]结尾，请重新输出"}
+                ]
+                continue
+            except EmptyResponseError as e:
+                self.logger.warning(f"{e}, retrying...")
+                continue
+            except TaskComplete as e:
+                raise
+            except ModelNotFoundError as e:
+                raise
             except Exception as e:
                 self.logger.error(f"{e}")
-                if "validation_error" in str(e):
-                    bad_assistant_message = json.loads(str(e))["response"]
-                    need_done_prompt = [
-                        {"role": "assistant", "content": bad_assistant_message},
-                        {"role": "user", "content": "你的消息没有以[done]结尾，请重新输出"}
-                    ]
-                    continue
-                if "response_empty_error" in str(e):
-                    continue
                 import traceback
                 self.logger.error(traceback.format_exc())
                 if "Invalid URL" in str(e):

{aient-1.1.75 → aient-1.1.76}/aient.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aient
-Version: 1.1.75
+Version: 1.1.76
 Summary: Aient: The Awakening of Agent.
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{aient-1.1.75 → aient-1.1.76}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aient"
-version = "1.1.75"
+version = "1.1.76"
 description = "Aient: The Awakening of Agent."
 readme = "README.md"
 requires-python = ">=3.11"