Update app.py

app.py

@@ -403,27 +403,164 @@ def upload_image_to_wechat(image_data):
         logging.error(error_msg)
         raise
 
-def process_long_running_task(messages, message_type='text', image_data=None):
-    """
-    处理长时间运行的任务，支持文本对话和图片识别
-    Args:
-        messages: 消息历史记录列表
-        message_type: 消息类型，'text'或'image'
-        image_data: 图片相关数据，包含media_id等信息
-    Returns:
-        dict: 包含处理结果的字典
-    """
+# def process_long_running_task(messages, message_type='text', image_data=None):
+#     """
+#     处理长时间运行的任务，支持文本对话和图片识别
+#     Args:
+#         messages: 消息历史记录列表
+#         message_type: 消息类型，'text'或'image'
+#         image_data: 图片相关数据，包含media_id等信息
+#     Returns:
+#         dict: 包含处理结果的字典
+#     """
+#     try:
+#         logging.info(f"开始调用AI服务，消息类型: {message_type}")
+        
+#         if message_type == 'image':
+#             try:
+#                 # 获取图片内容
+#                 image_content = get_image_content(image_data['media_id'])
+#                 # 将图片内容转换为base64
+#                 image_base64 = base64.b64encode(image_content).decode('utf-8')
+                
+#                 # 构建图像识别请求
+#                 image_messages = [
+#                     {
+#                         "role": "user",
+#                         "content": [
+#                             {"type": "text", "text": "请详细描述这张图片中的内容，包括主要对象、场景、活动等关键信息"},
+#                             {
+#                                 "type": "image_url",
+#                                 "image_url": {
+#                                     "url": f"data:image/jpeg;base64,{image_base64}"
+#                                 }
+#                             }
+#                         ]
+#                     }
+#                 ]
+                
+#                 logging.info("开始调用图像识别模型")
+#                 image_response = client.chat.completions.create(
+#                     model="gpt-4o-mini",
+#                     messages=image_messages,
+#                     max_tokens=300,
+#                     timeout=60
+#                 )
+#                 logging.info("图像识别完成")
+                
+#                 # 检查响应是否成功
+#                 if not image_response.choices:
+#                     raise Exception("图像识别服务未返回有效结果")
+                    
+#                 return {
+#                     "type": "text",
+#                     "content": image_response.choices[0].message.content
+#                 }
+                
+#             except requests.exceptions.RequestException as e:
+#                 logging.error(f"获取或处理图片时发生网络错误: {str(e)}")
+#                 raise
+#             except Exception as e:
+#                 logging.error(f"图像识别过程中发生错误: {str(e)}")
+#                 raise
+                
+#         else:
+#             # 处理文本消息
+#             try:
+#                 logging.info("开始处理文本消息")
+#                 response = client.chat.completions.create(
+#                     model="o3-mini",
+#                     messages=messages,
+#                     tools=TOOLS,
+#                     tool_choice="auto",
+#                     timeout=60
+#                 )
+                
+#                 # 检查是否需要生成图片
+#                 if response.choices[0].message.tool_calls:
+#                     tool_call = response.choices[0].message.tool_calls[0]
+#                     if tool_call.function.name == "generate_image":
+#                         try:
+#                             logging.info("检测到图片生成请求")
+#                             args = json.loads(tool_call.function.arguments)
+                            
+#                             # 调用图片生成服务
+#                             image_generation_response = requests.post(
+#                                 IMAGE_MODEL_URL,
+#                                 headers={
+#                                     'Content-Type': 'application/json',
+#                                     'Authorization': f'Bearer {IMAGE_MODEL_KEY}'
+#                                 },
+#                                 json={
+#                                     "model": "grok-latest-image",
+#                                     "messages": [{
+#                                         "role": "user",
+#                                         "content": args['prompt']
+#                                     }]
+#                                 },
+#                                 timeout=60
+#                             )
+#                             image_generation_response.raise_for_status()
+#                             generation_result = image_generation_response.json()
+                            
+#                             if 'choices' not in generation_result or not generation_result['choices']:
+#                                 raise Exception("图片生成服务未返回有效结果")
+                                
+#                             # 从markdown格式中提取URL
+#                             markdown_content = generation_result['choices'][0]['message']['content']
+#                             image_url_match = re.search(r'\!\[image\]\((.*?)\)', markdown_content)
+#                             if not image_url_match:
+#                                 raise Exception("无法从响应中提取图片URL")
+                                
+#                             image_url = image_url_match.group(1)
+                            
+#                             # 下载生成的图片
+#                             img_response = requests.get(image_url, timeout=30)
+#                             img_response.raise_for_status()
+                            
+#                             # 上传图片到微信服务器
+#                             media_id = upload_image_to_wechat(img_response.content)
+                            
+#                             return {
+#                                 "type": "image",
+#                                 "media_id": media_id
+#                             }
+                            
+#                         except requests.exceptions.RequestException as e:
+#                             logging.error(f"图片生成过程中发生网络错误: {str(e)}")
+#                             raise
+#                         except Exception as e:
+#                             logging.error(f"图片生成过程中发生错误: {str(e)}")
+#                             raise
+                
+#                 # 返回文本响应
+#                 return {
+#                     "type": "text",
+#                     "content": response.choices[0].message.content
+#                 }
+                
+#             except requests.exceptions.RequestException as e:
+#                 logging.error(f"处理文本消息时发生网络错误: {str(e)}")
+#                 raise
+#             except Exception as e:
+#                 logging.error(f"处理文本消息时发生错误: {str(e)}")
+#                 raise
+                
+#     except Exception as e:
+#         logging.error(f"API调用错误: {str(e)}")
+#         raise
+async def process_long_running_task(messages, message_type='text', image_data=None):
     try:
-        logging.info(f"开始调用AI服务，消息类型: {message_type}")
+        logging.info(f"Starting AI service call, message type: {message_type}")
         
         if message_type == 'image':
             try:
-                # 获取图片内容
+                # Get image content
                 image_content = get_image_content(image_data['media_id'])
-                # 将图片内容转换为base64
+                # Convert image content to base64
                 image_base64 = base64.b64encode(image_content).decode('utf-8')
                 
-                # 构建图像识别请求
+                # Construct image recognition request
                 image_messages = [
                     {
                         "role": "user",
@@ -439,18 +576,17 @@ def process_long_running_task(messages, message_type='text', image_data=None):
                     }
                 ]
                 
-                logging.info("开始调用图像识别模型")
+                logging.info("Starting image recognition model")
                 image_response = client.chat.completions.create(
                     model="gpt-4o-mini",
                     messages=image_messages,
                     max_tokens=300,
                     timeout=60
                 )
-                logging.info("图像识别完成")
+                logging.info("Image recognition completed")
                 
-                # 检查响应是否成功
                 if not image_response.choices:
-                    raise Exception("图像识别服务未返回有效结果")
+                    raise Exception("Image recognition service did not return valid results")
                     
                 return {
                     "type": "text",
@@ -458,16 +594,16 @@ def process_long_running_task(messages, message_type='text', image_data=None):
                 }
                 
             except requests.exceptions.RequestException as e:
-                logging.error(f"获取或处理图片时发生网络错误: {str(e)}")
+                logging.error(f"Network error during image processing: {str(e)}")
                 raise
             except Exception as e:
-                logging.error(f"图像识别过程中发生错误: {str(e)}")
+                logging.error(f"Error during image recognition: {str(e)}")
                 raise
                 
         else:
-            # 处理文本消息
+            # Process text messages
             try:
-                logging.info("开始处理文本消息")
+                logging.info("Processing text message")
                 response = client.chat.completions.create(
                     model="o3-mini",
                     messages=messages,
@@ -476,15 +612,15 @@ def process_long_running_task(messages, message_type='text', image_data=None):
                     timeout=60
                 )
                 
-                # 检查是否需要生成图片
+                # Check if image generation is needed
                 if response.choices[0].message.tool_calls:
                     tool_call = response.choices[0].message.tool_calls[0]
                     if tool_call.function.name == "generate_image":
                         try:
-                            logging.info("检测到图片生成请求")
+                            logging.info("Image generation request detected")
                             args = json.loads(tool_call.function.arguments)
                             
-                            # 调用图片生成服务
+                            # Call image generation service
                             image_generation_response = requests.post(
                                 IMAGE_MODEL_URL,
                                 headers={
@@ -492,7 +628,7 @@ def process_long_running_task(messages, message_type='text', image_data=None):
                                     'Authorization': f'Bearer {IMAGE_MODEL_KEY}'
                                 },
                                 json={
-                                    "model": "grok-latest-image",
+                                    "model": "grok-3-imageGen",
                                     "messages": [{
                                         "role": "user",
                                         "content": args['prompt']
@@ -504,22 +640,20 @@ def process_long_running_task(messages, message_type='text', image_data=None):
                             generation_result = image_generation_response.json()
                             
                             if 'choices' not in generation_result or not generation_result['choices']:
-                                raise Exception("图片生成服务未返回有效结果")
-                                
-                            # 从markdown格式中提取URL
+                                raise Exception("Image generation service did not return valid results")
+                            
+                            # Extract base64 data from markdown response
                             markdown_content = generation_result['choices'][0]['message']['content']
-                            image_url_match = re.search(r'\!\[image\]\((.*?)\)', markdown_content)
-                            if not image_url_match:
-                                raise Exception("无法从响应中提取图片URL")
-                                
-                            image_url = image_url_match.group(1)
+                            base64_match = re.search(r'data:image\/[^;]+;base64,([^)]+)', markdown_content)
+                            
+                            if not base64_match:
+                                raise Exception("Could not extract base64 image data from response")
                             
-                            # 下载生成的图片
-                            img_response = requests.get(image_url, timeout=30)
-                            img_response.raise_for_status()
+                            # Decode base64 data
+                            image_data = base64.b64decode(base64_match.group(1))
                             
-                            # 上传图片到微信服务器
-                            media_id = upload_image_to_wechat(img_response.content)
+                            # Upload to WeChat server
+                            media_id = upload_image_to_wechat(image_data)
                             
                             return {
                                 "type": "image",
@@ -527,30 +661,29 @@ def process_long_running_task(messages, message_type='text', image_data=None):
                             }
                             
                         except requests.exceptions.RequestException as e:
-                            logging.error(f"图片生成过程中发生网络错误: {str(e)}")
+                            logging.error(f"Network error during image generation: {str(e)}")
                             raise
                         except Exception as e:
-                            logging.error(f"图片生成过程中发生错误: {str(e)}")
+                            logging.error(f"Error during image generation: {str(e)}")
                             raise
                 
-                # 返回文本响应
+                # Return text response
                 return {
                     "type": "text",
                     "content": response.choices[0].message.content
                 }
                 
             except requests.exceptions.RequestException as e:
-                logging.error(f"处理文本消息时发生网络错误: {str(e)}")
+                logging.error(f"Network error while processing text message: {str(e)}")
                 raise
             except Exception as e:
-                logging.error(f"处理文本消息时发生错误: {str(e)}")
+                logging.error(f"Error while processing text message: {str(e)}")
                 raise
-                
+    
     except Exception as e:
-        logging.error(f"API调用错误: {str(e)}")
+        logging.error(f"API call error: {str(e)}")
         raise
 
-
 def handle_async_task(session, task_id, messages=None, message_type='text', message_data=None):
     """
     处理异步任务，支持文本对话和图片识别