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,7 +968,7 @@ 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", [])
@@ -991,6 +991,7 @@ def handsome_chat_completions():
         siliconflow_data = {
             "model": model_name,
             "prompt": user_content,
+            
         }
         if model_name == "black-forest-labs/FLUX.1-pro":
             siliconflow_data["width"] = data.get("width", 1024)
@@ -1004,26 +1005,27 @@ def handsome_chat_completions():
             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
+                siliconflow_data["seed"] = seed
             if siliconflow_data["width"] < 256 or siliconflow_data["width"] > 1440 or siliconflow_data["width"] % 32 != 0:
-                 siliconflow_data["width"] = 1024
+                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
+                siliconflow_data["steps"] = 20
             if siliconflow_data["guidance"] < 1.5 or siliconflow_data["guidance"] > 5:
-                siliconflow_data["guidance"] = 3
+                 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
+                 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"):
@@ -1031,66 +1033,106 @@ def handsome_chat_completions():
             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")
+               siliconflow_data["guidance_scale"] = data.get("guidance_scale")
             if data.get("negative_prompt"):
-                siliconflow_data["negative_prompt"] = data.get("negative_prompt")
+               siliconflow_data["negative_prompt"] = data.get("negative_prompt")
             if data.get("seed"):
-                siliconflow_data["seed"] = data.get("seed")
+               siliconflow_data["seed"] = data.get("seed")
             if data.get("prompt_enhancement"):
-                siliconflow_data["prompt_enhancement"] = data.get("prompt_enhancement")
+               siliconflow_data["prompt_enhancement"] = data.get("prompt_enhancement")
+
             if siliconflow_data["batch_size"] < 1:
-               siliconflow_data["batch_size"] = 1
+                siliconflow_data["batch_size"] = 1
             if siliconflow_data["batch_size"] > 4:
-               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
-           
+                siliconflow_data["num_inference_steps"] = 50
+                
             if siliconflow_data["guidance_scale"] < 0:
-               siliconflow_data["guidance_scale"] = 0
+                siliconflow_data["guidance_scale"] = 0
             if siliconflow_data["guidance_scale"] > 100:
-               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",
+            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 response.status_code == 429:
+                return jsonify(response.json()), 429
 
-           if data.get("stream", False):
+            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 = {
+                    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()),
@@ -1098,18 +1140,18 @@ def handsome_chat_completions():
                             "choices": [
                                 {
                                     "index": 0,
-                                    "delta": {
-                                        "role": "assistant",
-                                        "content": markdown_image_link
-                                    },
-                                    "finish_reason": None
+                                    "delta": {},
+                                    "finish_reason": "stop"
                                 }
                             ]
                         }
-                        yield f"data: {json.dumps(chunk_data)}\n\n".encode('utf-8')
-                        full_response_content = markdown_image_link
-                    else:
-                        chunk_data = {
+                        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()),
@@ -1119,168 +1161,110 @@ def handsome_chat_completions():
                                     "index": 0,
                                     "delta": {
                                         "role": "assistant",
-                                        "content": "Failed to generate image"
+                                        "content": f"Error: {str(e)}"
                                     },
                                     "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 = {
+                        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.chunk",
+                        "object": "chat.completion",
                         "created": int(time.time()),
                         "model": model_name,
                         "choices": [
                             {
-                                "index": 0,
-                                "delta": {},
-                                "finish_reason": "stop"
+                            "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",
+                            }
+                        ],
                     }
-                    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(
+                logging.info(
                     f"使用的key: {api_key}, "
                     f"总共用时: {total_time:.4f}秒, "
                     f"使用的模型: {model_name}"
-               )
-               with data_lock:
+                )
+                with data_lock:
                     request_timestamps.append(time.time())
                     token_counts.append(0)
-               return jsonify(response_data)
+                return jsonify(response_data)
 
         except requests.exceptions.RequestException as e:
-           logging.error(f"请求转发异常: {e}")
-           return jsonify({"error": str(e)}), 500
+            logging.error(f"请求转发异常: {e}")
+            return jsonify({"error": str(e)}), 500
     else:
-        tools = data.get("tools")
-        tool_choice = data.get("tool_choice")
-
-        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 tools:
-           siliconflow_data["tools"] = tools
-        if tool_choice:
-           siliconflow_data["tool_choice"] = tool_choice
-
         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
             )
@@ -1309,16 +1293,14 @@ def handsome_chat_completions():
                     prompt_tokens = 0
                     completion_tokens = 0
                     response_content = ""
-                    function_call = None
-                    tool_calls = []
-
                     for line in full_response_content.splitlines():
                         if line.startswith("data:"):
-                           line = line[5:].strip()
-                           if line == "[DONE]":
+                            line = line[5:].strip()
+                            if line == "[DONE]":
                                 continue
-                           try:
+                            try:
                                 response_json = json.loads(line)
+
                                 if (
                                     "usage" in response_json and
                                     "completion_tokens" in response_json["usage"]
@@ -1329,21 +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
@@ -1353,24 +1329,23 @@ def handsome_chat_completions():
                                         "usage"
                                     ]["prompt_tokens"]
 
-
-                           except (
+                            except (
                                 KeyError,
                                 ValueError,
                                 IndexError
-                           ) as e:
-                               logging.error(
+                            ) as e:
+                                logging.error(
                                     f"解析流式响应单行 JSON 失败: {e}, "
                                     f"行内容: {line}"
-                               )
+                                )
 
                     user_content = ""
                     messages = data.get("messages", [])
                     for message in messages:
-                       if message["role"] == "user":
-                          if isinstance(message["content"], str):
+                        if message["role"] == "user":
+                            if isinstance(message["content"], str):
                                 user_content += message["content"] + " "
-                          elif isinstance(message["content"], list):
+                            elif isinstance(message["content"], list):
                                 for item in message["content"]:
                                     if (
                                         isinstance(item, dict) and
@@ -1382,14 +1357,15 @@ def handsome_chat_completions():
                                         )
 
                     user_content = user_content.strip()
+
                     user_content_replaced = user_content.replace(
                         '\n', '\\n'
                     ).replace('\r', '\\n')
                     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}, "
@@ -1399,73 +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 tool_calls:
-                         if isinstance(tool_calls, list) and len(tool_calls) > 0:
-                                 
-                             first_tool_call = tool_calls[0]
-                             if isinstance(first_tool_call, dict) and "function" in first_tool_call:
-                                 function_call_data = first_tool_call.get("function")
-                                 if isinstance(function_call_data, dict) and "name" in function_call_data and "arguments" in function_call_data:
-                                        function_call = {
-                                                "name": function_call_data["name"],
-                                                "arguments": json.dumps(function_call_data["arguments"]) if isinstance(function_call_data.get("arguments"), dict) else function_call_data["arguments"]
-                                         }
-                                        response_data["choices"][0]["delta"]["function_call"] = function_call
-                                        response_data["choices"][0]["delta"]["content"] = None
-                                        response_data["choices"][0]["finish_reason"] = "function_call"
-                                 else:
-                                        response_data["choices"][0]["delta"]["tool_calls"] = tool_calls
-                                        response_data["choices"][0]["delta"]["content"] = None
-                         else:
-                                response_data["choices"][0]["delta"]["tool_calls"] = tool_calls
-                                response_data["choices"][0]["delta"]["content"] = None
-                    elif response_content:
-                           response_data["choices"][0]["delta"]["content"] = response_content
-
-
-                    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']
@@ -1484,10 +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}, "
@@ -1496,7 +1406,6 @@ def handsome_chat_completions():
                     prompt_tokens = 0
                     completion_tokens = 0
                     response_content = ""
-                    tool_calls = []
 
                 user_content = ""
                 messages = data.get("messages", [])
@@ -1511,8 +1420,7 @@ def handsome_chat_completions():
                                     item.get("type") == "text"
                                 ):
                                     user_content += (
-                                        item.get("text", "") +
-                                        " "
+                                        item.get("text", "") + " "
                                     )
 
                 user_content = user_content.strip()
@@ -1524,8 +1432,8 @@ def handsome_chat_completions():
                     '\n', '\\n'
                 ).replace('\r', '\\n')
 
-                log_message = (
-                     f"使用的key: {api_key}, "
+                logging.info(
+                    f"使用的key: {api_key}, "
                     f"提示token: {prompt_tokens}, "
                     f"输出token: {completion_tokens}, "
                     f"首字用时: 0, "
@@ -1534,59 +1442,14 @@ 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:
-                    if isinstance(tool_calls, list) and len(tool_calls) > 0:
-                         first_tool_call = tool_calls[0]
-                         if isinstance(first_tool_call, dict) and "function" in first_tool_call:
-                             function_call_data = first_tool_call.get("function")
-                             if isinstance(function_call_data, dict) and "name" in function_call_data and "arguments" in function_call_data:
-                                    function_call = {
-                                            "name": function_call_data["name"],
-                                            "arguments": json.dumps(function_call_data["arguments"]) if isinstance(function_call_data.get("arguments"), dict) else function_call_data["arguments"]
-                                    }
-                                    response_data["choices"][0]["message"]["function_call"] = function_call
-                                    response_data["choices"][0]["message"]["content"] = None
-                                    response_data["choices"][0]["finish_reason"] = "function_call"
-                             else:
-                                   response_data["choices"][0]["message"]["tool_calls"] = tool_calls
-                                   response_data["choices"][0]["message"]["content"] = None
-                    else:
-                         response_data["choices"][0]["message"]["tool_calls"] = tool_calls
-                         response_data["choices"][0]["message"]["content"] = None
-                     
-
-                return jsonify(response_data)
 
+                return jsonify(response_json)
 
         except requests.exceptions.RequestException as e:
             logging.error(f"请求转发异常: {e}")