Update app.py

app.py

@@ -944,13 +944,13 @@ def handsome_chat_completions():
         return jsonify({"error": "Invalid request data"}), 400
 
     model_name = data['model']
-
+    
     request_type = determine_request_type(
         model_name,
         text_models + image_models,
         free_text_models + free_image_models
     )
-
+    
     api_key = select_key(request_type, model_name)
 
     if not api_key:
@@ -968,322 +968,303 @@ def handsome_chat_completions():
         "Authorization": f"Bearer {api_key}",
         "Content-Type": "application/json"
     }
-
+    
     if model_name in image_models:
-       user_content = ""
-       messages = data.get("messages", [])
-       for message in messages:
-           if message["role"] == "user":
-               if isinstance(message["content"], str):
-                   user_content += message["content"] + " "
-               elif isinstance(message["content"], list):
-                   for item in message["content"]:
-                       if (
-                           isinstance(item, dict) and
-                           item.get("type") == "text"
-                       ):
-                           user_content += (
-                               item.get("text", "") +
-                               " "
-                           )
-       user_content = user_content.strip()
-
-       siliconflow_data = {
+        user_content = ""
+        messages = data.get("messages", [])
+        for message in messages:
+            if message["role"] == "user":
+                if isinstance(message["content"], str):
+                    user_content += message["content"] + " "
+                elif isinstance(message["content"], list):
+                    for item in message["content"]:
+                        if (
+                            isinstance(item, dict) and
+                            item.get("type") == "text"
+                        ):
+                            user_content += (
+                                item.get("text", "") +
+                                " "
+                            )
+        user_content = user_content.strip()
+
+        siliconflow_data = {
             "model": model_name,
             "prompt": user_content,
-          
+            
         }
-       if model_name == "black-forest-labs/FLUX.1-pro":
-           siliconflow_data["width"] = data.get("width", 1024)
-           siliconflow_data["height"] = data.get("height", 768)
-           siliconflow_data["prompt_upsampling"] = data.get("prompt_upsampling", False)
-           siliconflow_data["image_prompt"] = data.get("image_prompt")
-           siliconflow_data["steps"] = data.get("steps", 20)
-           siliconflow_data["guidance"] = data.get("guidance", 3)
-           siliconflow_data["safety_tolerance"] = data.get("safety_tolerance", 2)
-           siliconflow_data["interval"] = data.get("interval", 2)
-           siliconflow_data["output_format"] = data.get("output_format", "png")
-           seed = data.get("seed")
-           if isinstance(seed, int) and 0 < seed < 9999999999:
-               siliconflow_data["seed"] = seed
-           if siliconflow_data["width"] < 256 or siliconflow_data["width"] > 1440 or siliconflow_data["width"] % 32 != 0:
-               siliconflow_data["width"] = 1024
-           if siliconflow_data["height"] < 256 or siliconflow_data["height"] > 1440 or siliconflow_data["height"] % 32 != 0:
-                siliconflow_data["height"] = 768
-
-           if siliconflow_data["steps"] < 1 or siliconflow_data["steps"] > 50:
-               siliconflow_data["steps"] = 20
-           if siliconflow_data["guidance"] < 1.5 or siliconflow_data["guidance"] > 5:
-                siliconflow_data["guidance"] = 3
-           if siliconflow_data["safety_tolerance"] < 0 or siliconflow_data["safety_tolerance"] > 6:
-               siliconflow_data["safety_tolerance"] = 2
-           if siliconflow_data["interval"] < 1 or siliconflow_data["interval"] > 4 :
-                siliconflow_data["interval"] = 2
-       else:
-           siliconflow_data["image_size"] = "1024x1024"
-           siliconflow_data["batch_size"] = 1
-           siliconflow_data["num_inference_steps"] = 20
-           siliconflow_data["guidance_scale"] = 7.5
-           siliconflow_data["prompt_enhancement"] = False
-     
-           if data.get("size"):
-               siliconflow_data["image_size"] = data.get("size")
-           if data.get("n"):
-               siliconflow_data["batch_size"] = data.get("n")
-           if data.get("steps"):
-               siliconflow_data["num_inference_steps"] = data.get("steps")
-           if data.get("guidance_scale"):
-              siliconflow_data["guidance_scale"] = data.get("guidance_scale")
-           if data.get("negative_prompt"):
-              siliconflow_data["negative_prompt"] = data.get("negative_prompt")
-           if data.get("seed"):
-              siliconflow_data["seed"] = data.get("seed")
-           if data.get("prompt_enhancement"):
-              siliconflow_data["prompt_enhancement"] = data.get("prompt_enhancement")
-
-           if siliconflow_data["batch_size"] < 1:
-               siliconflow_data["batch_size"] = 1
-           if siliconflow_data["batch_size"] > 4:
-               siliconflow_data["batch_size"] = 4
-
-           if siliconflow_data["num_inference_steps"] < 1:
-               siliconflow_data["num_inference_steps"] = 1
-           if siliconflow_data["num_inference_steps"] > 50:
-               siliconflow_data["num_inference_steps"] = 50
-             
-           if siliconflow_data["guidance_scale"] < 0:
-               siliconflow_data["guidance_scale"] = 0
-           if siliconflow_data["guidance_scale"] > 100:
-               siliconflow_data["guidance_scale"] = 100
-         
-           if siliconflow_data["image_size"] not in ["1024x1024", "512x1024", "768x512", "768x1024", "1024x576", "576x1024", "960x1280", "720x1440", "720x1280"]:
-               siliconflow_data["image_size"] = "1024x1024"
-       try:
-           start_time = time.time()
-           response = requests.post(
-               "https://api-st.siliconflow.cn/v1/images/generations",
-               headers=headers,
-               json=siliconflow_data,
-               timeout=120,
-               stream=data.get("stream", False)
-           )
-        
-           if response.status_code == 429:
-               return jsonify(response.json()), 429
-
-           if data.get("stream", False):
-               def generate():
-                   first_chunk_time = None
-                   full_response_content = ""
-                   try:
-                       response.raise_for_status()
-                       end_time = time.time()
-                       response_json = response.json()
-                       total_time = end_time - start_time
-                 
-                       images = response_json.get("images", [])
-                     
-                       image_url = ""
-                       if images and isinstance(images[0], dict) and "url" in images[0]:
-                           image_url = images[0]["url"]
-                           logging.info(f"Extracted image URL: {image_url}")
-                       elif images and isinstance(images[0], str):
-                           image_url = images[0]
-                           logging.info(f"Extracted image URL: {image_url}")
-                     
-                       markdown_image_link = f"![image]({image_url})"
-                       if image_url:
-                           chunk_data = {
-                               "id": f"chatcmpl-{uuid.uuid4()}",
-                               "object": "chat.completion.chunk",
-                               "created": int(time.time()),
-                               "model": model_name,
-                               "choices": [
-                                   {
-                                       "index": 0,
-                                       "delta": {
-                                           "role": "assistant",
-                                           "content": markdown_image_link
-                                       },
-                                       "finish_reason": None
-                                   }
-                               ]
-                           }
-                           yield f"data: {json.dumps(chunk_data)}\n\n".encode('utf-8')
-                           full_response_content = markdown_image_link
-                       else:
-                           chunk_data = {
-                               "id": f"chatcmpl-{uuid.uuid4()}",
-                               "object": "chat.completion.chunk",
-                               "created": int(time.time()),
-                               "model": model_name,
-                               "choices": [
-                                   {
-                                       "index": 0,
-                                       "delta": {
-                                           "role": "assistant",
-                                           "content": "Failed to generate image"
-                                       },
-                                       "finish_reason": None
-                                   }
-                               ]
-                           }
-                           yield f"data: {json.dumps(chunk_data)}\n\n".encode('utf-8')
-                           full_response_content = "Failed to generate image"
-                     
-                       end_chunk_data = {
-                           "id": f"chatcmpl-{uuid.uuid4()}",
-                           "object": "chat.completion.chunk",
-                           "created": int(time.time()),
-                           "model": model_name,
-                           "choices": [
-                               {
-                                   "index": 0,
-                                   "delta": {},
-                                   "finish_reason": "stop"
-                               }
-                           ]
-                       }
-                       yield f"data: {json.dumps(end_chunk_data)}\n\n".encode('utf-8')
-                       with data_lock:
-                           request_timestamps.append(time.time())
-                           token_counts.append(0)
-                   except requests.exceptions.RequestException as e:
-                       logging.error(f"请求转发异常: {e}")
-                       error_chunk_data = {
-                           "id": f"chatcmpl-{uuid.uuid4()}",
-                           "object": "chat.completion.chunk",
-                           "created": int(time.time()),
-                           "model": model_name,
-                           "choices": [
-                               {
-                                   "index": 0,
-                                   "delta": {
-                                       "role": "assistant",
-                                       "content": f"Error: {str(e)}"
-                                   },
-                                   "finish_reason": None
-                               }
-                           ]
-                       }
-                       yield f"data: {json.dumps(error_chunk_data)}\n\n".encode('utf-8')
-                       end_chunk_data = {
-                               "id": f"chatcmpl-{uuid.uuid4()}",
-                               "object": "chat.completion.chunk",
-                               "created": int(time.time()),
-                               "model": model_name,
-                               "choices": [
-                                   {
-                                       "index": 0,
-                                       "delta": {},
-                                       "finish_reason": "stop"
-                                   }
-                               ]
-                           }
-                       yield f"data: {json.dumps(end_chunk_data)}\n\n".encode('utf-8')
-                   logging.info(
-                       f"使用的key: {api_key}, "
-                       f"使用的模型: {model_name}"
-                   )
-                   yield "data: [DONE]\n\n".encode('utf-8')
-               return Response(stream_with_context(generate()), content_type='text/event-stream')
-
-           else:
-               response.raise_for_status()
-               end_time = time.time()
-               response_json = response.json()
-               total_time = end_time - start_time
-         
-               try:
-                   images = response_json.get("images", [])
-                 
-                   image_url = ""
-                   if images and isinstance(images[0], dict) and "url" in images[0]:
-                       image_url = images[0]["url"]
-                       logging.info(f"Extracted image URL: {image_url}")
-                   elif images and isinstance(images[0], str):
-                       image_url = images[0]
-                       logging.info(f"Extracted image URL: {image_url}")
-                 
-                   markdown_image_link = f"![image]({image_url})"
-                   response_data = {
-                       "id": f"chatcmpl-{uuid.uuid4()}",
-                       "object": "chat.completion",
-                       "created": int(time.time()),
-                       "model": model_name,
-                       "choices": [
-                           {
-                           "index": 0,
-                           "message": {
-                               "role": "assistant",
-                               "content": markdown_image_link if image_url else "Failed to generate image",
-                           },
-                           "finish_reason": "stop",
-                           }
-                       ],
-                   }
-               except (KeyError, ValueError, IndexError) as e:
-                   logging.error(
-                       f"解析响应 JSON 失败: {e}, "
-                       f"完整内容: {response_json}"
-                   )
-                   response_data = {
-                       "id": f"chatcmpl-{uuid.uuid4()}",
-                       "object": "chat.completion",
-                       "created": int(time.time()),
-                       "model": model_name,
-                       "choices": [
-                           {
-                           "index": 0,
-                           "message": {
-                               "role": "assistant",
-                               "content": "Failed to process image data",
-                           },
-                           "finish_reason": "stop",
-                           }
-                       ],
-                   }
-
-               logging.info(
-                   f"使用的key: {api_key}, "
-                   f"总共用时: {total_time:.4f}秒, "
-                   f"使用的模型: {model_name}"
-               )
-               with data_lock:
-                   request_timestamps.append(time.time())
-                   token_counts.append(0)
-               return jsonify(response_data)
-
-       except requests.exceptions.RequestException as e:
-           logging.error(f"请求转发异常: {e}")
-           return jsonify({"error": str(e)}), 500
-    else:
-        tools = data.get("tools")
-        tool_choice = data.get("tool_choice")
+        if model_name == "black-forest-labs/FLUX.1-pro":
+            siliconflow_data["width"] = data.get("width", 1024)
+            siliconflow_data["height"] = data.get("height", 768)
+            siliconflow_data["prompt_upsampling"] = data.get("prompt_upsampling", False)
+            siliconflow_data["image_prompt"] = data.get("image_prompt")
+            siliconflow_data["steps"] = data.get("steps", 20)
+            siliconflow_data["guidance"] = data.get("guidance", 3)
+            siliconflow_data["safety_tolerance"] = data.get("safety_tolerance", 2)
+            siliconflow_data["interval"] = data.get("interval", 2)
+            siliconflow_data["output_format"] = data.get("output_format", "png")
+            seed = data.get("seed")
+            if isinstance(seed, int) and 0 < seed < 9999999999:
+                siliconflow_data["seed"] = seed
+            if siliconflow_data["width"] < 256 or siliconflow_data["width"] > 1440 or siliconflow_data["width"] % 32 != 0:
+                siliconflow_data["width"] = 1024
+            if siliconflow_data["height"] < 256 or siliconflow_data["height"] > 1440 or siliconflow_data["height"] % 32 != 0:
+                 siliconflow_data["height"] = 768
+
+            if siliconflow_data["steps"] < 1 or siliconflow_data["steps"] > 50:
+                siliconflow_data["steps"] = 20
+            if siliconflow_data["guidance"] < 1.5 or siliconflow_data["guidance"] > 5:
+                 siliconflow_data["guidance"] = 3
+            if siliconflow_data["safety_tolerance"] < 0 or siliconflow_data["safety_tolerance"] > 6:
+                siliconflow_data["safety_tolerance"] = 2
+            if siliconflow_data["interval"] < 1 or siliconflow_data["interval"] > 4 :
+                 siliconflow_data["interval"] = 2
+        else:
+            siliconflow_data["image_size"] = "1024x1024"
+            siliconflow_data["batch_size"] = 1
+            siliconflow_data["num_inference_steps"] = 20
+            siliconflow_data["guidance_scale"] = 7.5
+            siliconflow_data["prompt_enhancement"] = False
         
-        siliconflow_data = {
-            "model": model_name,
-            "messages": data.get("messages", []),
-            "stream": data.get("stream", False),
-            "max_tokens": data.get("max_tokens"),
-            "temperature": data.get("temperature"),
-            "top_p": data.get("top_p"),
-            "frequency_penalty": data.get("frequency_penalty"),
-            "presence_penalty": data.get("presence_penalty"),
-            "stop": data.get("stop"),
-        }
+            if data.get("size"):
+                siliconflow_data["image_size"] = data.get("size")
+            if data.get("n"):
+                siliconflow_data["batch_size"] = data.get("n")
+            if data.get("steps"):
+                siliconflow_data["num_inference_steps"] = data.get("steps")
+            if data.get("guidance_scale"):
+               siliconflow_data["guidance_scale"] = data.get("guidance_scale")
+            if data.get("negative_prompt"):
+               siliconflow_data["negative_prompt"] = data.get("negative_prompt")
+            if data.get("seed"):
+               siliconflow_data["seed"] = data.get("seed")
+            if data.get("prompt_enhancement"):
+               siliconflow_data["prompt_enhancement"] = data.get("prompt_enhancement")
+
+            if siliconflow_data["batch_size"] < 1:
+                siliconflow_data["batch_size"] = 1
+            if siliconflow_data["batch_size"] > 4:
+                siliconflow_data["batch_size"] = 4
+
+            if siliconflow_data["num_inference_steps"] < 1:
+                siliconflow_data["num_inference_steps"] = 1
+            if siliconflow_data["num_inference_steps"] > 50:
+                siliconflow_data["num_inference_steps"] = 50
+                
+            if siliconflow_data["guidance_scale"] < 0:
+                siliconflow_data["guidance_scale"] = 0
+            if siliconflow_data["guidance_scale"] > 100:
+                siliconflow_data["guidance_scale"] = 100
+            
+            if siliconflow_data["image_size"] not in ["1024x1024", "512x1024", "768x512", "768x1024", "1024x576", "576x1024", "960x1280", "720x1440", "720x1280"]:
+                siliconflow_data["image_size"] = "1024x1024"
+
+        try:
+            start_time = time.time()
+            response = requests.post(
+                "https://api.siliconflow.cn/v1/images/generations",
+                headers=headers,
+                json=siliconflow_data,
+                timeout=120,
+                stream=data.get("stream", False)
+            )
+           
+            if response.status_code == 429:
+                return jsonify(response.json()), 429
+
+            if data.get("stream", False):
+                def generate():
+                    first_chunk_time = None
+                    full_response_content = ""
+                    try:
+                        response.raise_for_status()
+                        end_time = time.time()
+                        response_json = response.json()
+                        total_time = end_time - start_time
+                    
+                        images = response_json.get("images", [])
+                        
+                        image_url = ""
+                        if images and isinstance(images[0], dict) and "url" in images[0]:
+                            image_url = images[0]["url"]
+                            logging.info(f"Extracted image URL: {image_url}")
+                        elif images and isinstance(images[0], str):
+                            image_url = images[0]
+                            logging.info(f"Extracted image URL: {image_url}")
+                        
+                        markdown_image_link = f"![image]({image_url})"
+                        if image_url:
+                            chunk_data = {
+                                "id": f"chatcmpl-{uuid.uuid4()}",
+                                "object": "chat.completion.chunk",
+                                "created": int(time.time()),
+                                "model": model_name,
+                                "choices": [
+                                    {
+                                        "index": 0,
+                                        "delta": {
+                                            "role": "assistant",
+                                            "content": markdown_image_link
+                                        },
+                                        "finish_reason": None
+                                    }
+                                ]
+                            }
+                            yield f"data: {json.dumps(chunk_data)}\n\n".encode('utf-8')
+                            full_response_content = markdown_image_link
+                        else:
+                            chunk_data = {
+                                "id": f"chatcmpl-{uuid.uuid4()}",
+                                "object": "chat.completion.chunk",
+                                "created": int(time.time()),
+                                "model": model_name,
+                                "choices": [
+                                    {
+                                        "index": 0,
+                                        "delta": {
+                                            "role": "assistant",
+                                            "content": "Failed to generate image"
+                                        },
+                                        "finish_reason": None
+                                    }
+                                ]
+                            }
+                            yield f"data: {json.dumps(chunk_data)}\n\n".encode('utf-8')
+                            full_response_content = "Failed to generate image"
+                        
+                        end_chunk_data = {
+                            "id": f"chatcmpl-{uuid.uuid4()}",
+                            "object": "chat.completion.chunk",
+                            "created": int(time.time()),
+                            "model": model_name,
+                            "choices": [
+                                {
+                                    "index": 0,
+                                    "delta": {},
+                                    "finish_reason": "stop"
+                                }
+                            ]
+                        }
+                        yield f"data: {json.dumps(end_chunk_data)}\n\n".encode('utf-8')
+                        with data_lock:
+                            request_timestamps.append(time.time())
+                            token_counts.append(0)
+                    except requests.exceptions.RequestException as e:
+                        logging.error(f"请求转发异常: {e}")
+                        error_chunk_data = {
+                            "id": f"chatcmpl-{uuid.uuid4()}",
+                            "object": "chat.completion.chunk",
+                            "created": int(time.time()),
+                            "model": model_name,
+                            "choices": [
+                                {
+                                    "index": 0,
+                                    "delta": {
+                                        "role": "assistant",
+                                        "content": f"Error: {str(e)}"
+                                    },
+                                    "finish_reason": None
+                                }
+                            ]
+                        }
+                        yield f"data: {json.dumps(error_chunk_data)}\n\n".encode('utf-8')
+                        end_chunk_data = {
+                                "id": f"chatcmpl-{uuid.uuid4()}",
+                                "object": "chat.completion.chunk",
+                                "created": int(time.time()),
+                                "model": model_name,
+                                "choices": [
+                                    {
+                                        "index": 0,
+                                        "delta": {},
+                                        "finish_reason": "stop"
+                                    }
+                                ]
+                            }
+                        yield f"data: {json.dumps(end_chunk_data)}\n\n".encode('utf-8')
+                    logging.info(
+                        f"使用的key: {api_key}, "
+                        f"使用的模型: {model_name}"
+                    )
+                    yield "data: [DONE]\n\n".encode('utf-8')
+                return Response(stream_with_context(generate()), content_type='text/event-stream')
+
+            else:
+                response.raise_for_status()
+                end_time = time.time()
+                response_json = response.json()
+                total_time = end_time - start_time
+            
+                try:
+                    images = response_json.get("images", [])
+                    
+                    image_url = ""
+                    if images and isinstance(images[0], dict) and "url" in images[0]:
+                        image_url = images[0]["url"]
+                        logging.info(f"Extracted image URL: {image_url}")
+                    elif images and isinstance(images[0], str):
+                        image_url = images[0]
+                        logging.info(f"Extracted image URL: {image_url}")
+                    
+                    markdown_image_link = f"![image]({image_url})"
+                    response_data = {
+                        "id": f"chatcmpl-{uuid.uuid4()}",
+                        "object": "chat.completion",
+                        "created": int(time.time()),
+                        "model": model_name,
+                        "choices": [
+                            {
+                            "index": 0,
+                            "message": {
+                                "role": "assistant",
+                                "content": markdown_image_link if image_url else "Failed to generate image",
+                            },
+                            "finish_reason": "stop",
+                            }
+                        ],
+                    }
+                except (KeyError, ValueError, IndexError) as e:
+                    logging.error(
+                        f"解析响应 JSON 失败: {e}, "
+                        f"完整内容: {response_json}"
+                    )
+                    response_data = {
+                        "id": f"chatcmpl-{uuid.uuid4()}",
+                        "object": "chat.completion",
+                        "created": int(time.time()),
+                        "model": model_name,
+                        "choices": [
+                            {
+                            "index": 0,
+                            "message": {
+                                "role": "assistant",
+                                "content": "Failed to process image data",
+                            },
+                            "finish_reason": "stop",
+                            }
+                        ],
+                    }
 
-        if tools:
-           siliconflow_data["tools"] = tools
-        if tool_choice:
-           siliconflow_data["tool_choice"] = tool_choice
+                logging.info(
+                    f"使用的key: {api_key}, "
+                    f"总共用时: {total_time:.4f}秒, "
+                    f"使用的模型: {model_name}"
+                )
+                with data_lock:
+                    request_timestamps.append(time.time())
+                    token_counts.append(0)
+                return jsonify(response_data)
 
+        except requests.exceptions.RequestException as e:
+            logging.error(f"请求转发异常: {e}")
+            return jsonify({"error": str(e)}), 500
+    else:
         try:
             start_time = time.time()
             response = requests.post(
                 TEST_MODEL_ENDPOINT,
                 headers=headers,
-                json=siliconflow_data,
+                json=data,
                 stream=data.get("stream", False),
                 timeout=60
             )
@@ -1312,7 +1293,6 @@ def handsome_chat_completions():
                     prompt_tokens = 0
                     completion_tokens = 0
                     response_content = ""
-                    tool_calls = []
                     for line in full_response_content.splitlines():
                         if line.startswith("data:"):
                             line = line[5:].strip()
@@ -1331,22 +1311,15 @@ def handsome_chat_completions():
 
                                 if (
                                     "choices" in response_json and
-                                    len(response_json["choices"]) > 0
+                                    len(response_json["choices"]) > 0 and
+                                    "delta" in response_json["choices"][0] and
+                                    "content" in response_json[
+                                        "choices"
+                                    ][0]["delta"]
                                 ):
-                                    choice = response_json["choices"][0]
-                                    if "delta" in choice:
-                                        delta = choice["delta"]
-                                        if "content" in delta:
-                                            response_content += delta["content"]
-                                        if "tool_calls" in delta:
-                                            tool_calls.extend(delta["tool_calls"])
-                                    elif "message" in choice:
-                                        message = choice["message"]
-                                        if "content" in message and message["content"]:
-                                            response_content += message["content"]
-                                        if "tool_calls" in message:
-                                            tool_calls.extend(message["tool_calls"])
-
+                                    response_content += response_json[
+                                        "choices"
+                                    ][0]["delta"]["content"]
 
                                 if (
                                     "usage" in response_json and
@@ -1384,6 +1357,7 @@ def handsome_chat_completions():
                                         )
 
                     user_content = user_content.strip()
+
                     user_content_replaced = user_content.replace(
                         '\n', '\\n'
                     ).replace('\r', '\\n')
@@ -1391,7 +1365,7 @@ def handsome_chat_completions():
                         '\n', '\\n'
                     ).replace('\r', '\\n')
 
-                    log_message = (
+                    logging.info(
                         f"使用的key: {api_key}, "
                         f"提示token: {prompt_tokens}, "
                         f"输出token: {completion_tokens}, "
@@ -1401,56 +1375,11 @@ def handsome_chat_completions():
                         f"用户的内容: {user_content_replaced}, "
                         f"输出的内容: {response_content_replaced}"
                     )
-                    if tool_calls:
-                        log_message += f", tool_calls: {tool_calls}"
-
-                    logging.info(log_message)
 
                     with data_lock:
                         request_timestamps.append(time.time())
                         token_counts.append(prompt_tokens+completion_tokens)
-                    
-                    
-                    
-                    # 构造 OpenAI 格式的响应数据
-                    response_data = {
-                        "id": f"chatcmpl-{uuid.uuid4()}",
-                        "object": "chat.completion.chunk",
-                        "created": int(time.time()),
-                        "model": model_name,
-                        "choices": [
-                            {
-                                "index": 0,
-                                "delta": {
-                                    "role": "assistant",
-                                },
-                                "finish_reason": None
-                            }
-                        ]
-                    }
-
-                    if response_content:
-                        response_data["choices"][0]["delta"]["content"] = response_content
-                    
-                    if tool_calls:
-                        response_data["choices"][0]["delta"]["tool_calls"] = tool_calls
-                        
-                    yield f"data: {json.dumps(response_data)}\n\n".encode('utf-8')
 
-                    end_chunk_data = {
-                            "id": f"chatcmpl-{uuid.uuid4()}",
-                            "object": "chat.completion.chunk",
-                            "created": int(time.time()),
-                            "model": model_name,
-                            "choices": [
-                                {
-                                    "index": 0,
-                                    "delta": {},
-                                    "finish_reason": "stop"
-                                }
-                            ]
-                        }
-                    yield f"data: {json.dumps(end_chunk_data)}\n\n".encode('utf-8')
                 return Response(
                     stream_with_context(generate()),
                     content_type=response.headers['Content-Type']
@@ -1469,11 +1398,6 @@ def handsome_chat_completions():
                     response_content = response_json[
                         "choices"
                     ][0]["message"]["content"]
-                    
-                    if "tool_calls" in response_json["choices"][0]["message"]:
-                        tool_calls = response_json["choices"][0]["message"]["tool_calls"]
-                    else:
-                       tool_calls = []
                 except (KeyError, ValueError, IndexError) as e:
                     logging.error(
                         f"解析非流式响应 JSON 失败: {e}, "
@@ -1482,7 +1406,6 @@ def handsome_chat_completions():
                     prompt_tokens = 0
                     completion_tokens = 0
                     response_content = ""
-                    tool_calls = []
 
                 user_content = ""
                 messages = data.get("messages", [])
@@ -1508,8 +1431,8 @@ def handsome_chat_completions():
                 response_content_replaced = response_content.replace(
                     '\n', '\\n'
                 ).replace('\r', '\\n')
-                
-                log_message = (
+
+                logging.info(
                     f"使用的key: {api_key}, "
                     f"提示token: {prompt_tokens}, "
                     f"输出token: {completion_tokens}, "
@@ -1519,40 +1442,15 @@ def handsome_chat_completions():
                     f"用户的内容: {user_content_replaced}, "
                     f"输出的内容: {response_content_replaced}"
                 )
-
-                if tool_calls:
-                    log_message += f", tool_calls: {tool_calls}"
-                  
-                logging.info(log_message)
                 with data_lock:
                     request_timestamps.append(time.time())
                     if "prompt_tokens" in response_json["usage"] and "completion_tokens" in response_json["usage"]:
                         token_counts.append(response_json["usage"]["prompt_tokens"] + response_json["usage"]["completion_tokens"])
                     else:
                         token_counts.append(0)
-                    
-                # 构造 OpenAI 格式的响应数据
-                response_data = {
-                    "id": f"chatcmpl-{uuid.uuid4()}",
-                    "object": "chat.completion",
-                    "created": int(time.time()),
-                    "model": model_name,
-                    "choices": [
-                        {
-                        "index": 0,
-                        "message": {
-                            "role": "assistant",
-                            "content": response_content,
-                        },
-                        "finish_reason": "stop",
-                        }
-                    ],
-                }
-                
-                if tool_calls:
-                   response_data["choices"][0]["message"]["tool_calls"] = tool_calls
 
-                return jsonify(response_data)
+                return jsonify(response_json)
+
         except requests.exceptions.RequestException as e:
             logging.error(f"请求转发异常: {e}")
             return jsonify({"error": str(e)}), 500