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,303 +968,322 @@ 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 = {
+    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 = {
             "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 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 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 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")
+        
+        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"),
+        }
 
-                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)
+        if tools:
+           siliconflow_data["tools"] = tools
+        if tool_choice:
+           siliconflow_data["tool_choice"] = tool_choice
 
-        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=data,
+                json=siliconflow_data,
                 stream=data.get("stream", False),
                 timeout=60
             )
@@ -1293,6 +1312,7 @@ 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()
@@ -1311,15 +1331,22 @@ def handsome_chat_completions():
 
                                 if (
                                     "choices" in response_json and
-                                    len(response_json["choices"]) > 0 and
-                                    "delta" in response_json["choices"][0] and
-                                    "content" in response_json[
-                                        "choices"
-                                    ][0]["delta"]
+                                    len(response_json["choices"]) > 0
                                 ):
-                                    response_content += response_json[
-                                        "choices"
-                                    ][0]["delta"]["content"]
+                                    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"])
+
 
                                 if (
                                     "usage" in response_json and
@@ -1357,7 +1384,6 @@ def handsome_chat_completions():
                                         )
 
                     user_content = user_content.strip()
-
                     user_content_replaced = user_content.replace(
                         '\n', '\\n'
                     ).replace('\r', '\\n')
@@ -1365,7 +1391,7 @@ def handsome_chat_completions():
                         '\n', '\\n'
                     ).replace('\r', '\\n')
 
-                    logging.info(
+                    log_message = (
                         f"使用的key: {api_key}, "
                         f"提示token: {prompt_tokens}, "
                         f"输出token: {completion_tokens}, "
@@ -1375,11 +1401,56 @@ 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']
@@ -1398,6 +1469,11 @@ 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}, "
@@ -1406,6 +1482,7 @@ def handsome_chat_completions():
                     prompt_tokens = 0
                     completion_tokens = 0
                     response_content = ""
+                    tool_calls = []
 
                 user_content = ""
                 messages = data.get("messages", [])
@@ -1431,8 +1508,8 @@ def handsome_chat_completions():
                 response_content_replaced = response_content.replace(
                     '\n', '\\n'
                 ).replace('\r', '\\n')
-
-                logging.info(
+                
+                log_message = (
                     f"使用的key: {api_key}, "
                     f"提示token: {prompt_tokens}, "
                     f"输出token: {completion_tokens}, "
@@ -1442,15 +1519,40 @@ 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_json)
-
+                return jsonify(response_data)
         except requests.exceptions.RequestException as e:
             logging.error(f"请求转发异常: {e}")
             return jsonify({"error": str(e)}), 500