Update app.py

app.py

@@ -7,6 +7,9 @@ import random
 import uuid
 import concurrent.futures
 import threading
+import base64
+import io
+from PIL import Image
 from datetime import datetime, timedelta
 from apscheduler.schedulers.background import BackgroundScheduler
 from flask import Flask, request, jsonify, Response, stream_with_context
@@ -545,9 +548,178 @@ def check_tokens():
                 )
 
     return jsonify(results)
+            
+@app.route('/handsome/v1/models', methods=['GET'])
+def list_models():
+    if not check_authorization(request):
+        return jsonify({"error": "Unauthorized"}), 401
 
-@app.route('/handsome/v1/chat/completions', methods=['POST'])
-def handsome_chat_completions():
+    detailed_models = []
+    
+    for model in text_models:
+        detailed_models.append({
+            "id": model,
+            "object": "model",
+            "created": 1678888888,
+            "owned_by": "openai",
+            "permission": [
+                {
+                    "id": f"modelperm-{uuid.uuid4().hex}",
+                    "object": "model_permission",
+                    "created": 1678888888,
+                    "allow_create_engine": False,
+                    "allow_sampling": True,
+                    "allow_logprobs": True,
+                    "allow_search_indices": False,
+                    "allow_view": True,
+                    "allow_fine_tuning": False,
+                    "organization": "*",
+                    "group": None,
+                    "is_blocking": False
+                }
+            ],
+            "root": model,
+            "parent": None
+        })
+
+    for model in embedding_models:
+        detailed_models.append({
+            "id": model,
+            "object": "model",
+            "created": 1678888888,
+            "owned_by": "openai",
+            "permission": [
+                {
+                    "id": f"modelperm-{uuid.uuid4().hex}",
+                    "object": "model_permission",
+                    "created": 1678888888,
+                    "allow_create_engine": False,
+                    "allow_sampling": True,
+                    "allow_logprobs": True,
+                    "allow_search_indices": False,
+                    "allow_view": True,
+                    "allow_fine_tuning": False,
+                    "organization": "*",
+                    "group": None,
+                    "is_blocking": False
+                }
+            ],
+            "root": model,
+            "parent": None
+        })
+    
+    for model in image_models:
+        detailed_models.append({
+            "id": model,
+            "object": "model",
+            "created": 1678888888,
+            "owned_by": "openai",
+            "permission": [
+                {
+                    "id": f"modelperm-{uuid.uuid4().hex}",
+                    "object": "model_permission",
+                    "created": 1678888888,
+                    "allow_create_engine": False,
+                    "allow_sampling": True,
+                    "allow_logprobs": True,
+                    "allow_search_indices": False,
+                    "allow_view": True,
+                    "allow_fine_tuning": False,
+                    "organization": "*",
+                    "group": None,
+                    "is_blocking": False
+                }
+            ],
+            "root": model,
+            "parent": None
+        })
+
+    return jsonify({
+        "success": True,
+        "data": detailed_models
+    })
+
+def get_billing_info():
+    keys = valid_keys_global + unverified_keys_global
+    total_balance = 0
+
+    with concurrent.futures.ThreadPoolExecutor(
+        max_workers=20
+    ) as executor:
+        futures = [
+            executor.submit(get_credit_summary, key) for key in keys
+        ]
+
+        for future in concurrent.futures.as_completed(futures):
+            try:
+                credit_summary = future.result()
+                if credit_summary:
+                    total_balance += credit_summary.get(
+                        "total_balance",
+                        0
+                    )
+            except Exception as exc:
+                logging.error(f"获取额度信息生成异常: {exc}")
+
+    return total_balance
+
+@app.route('/handsome/v1/dashboard/billing/usage', methods=['GET'])
+def billing_usage():
+    if not check_authorization(request):
+        return jsonify({"error": "Unauthorized"}), 401
+
+    end_date = datetime.now()
+    start_date = end_date - timedelta(days=30)
+
+    daily_usage = []
+    current_date = start_date
+    while current_date <= end_date:
+        daily_usage.append({
+            "timestamp": int(current_date.timestamp()),
+            "daily_usage": 0
+        })
+        current_date += timedelta(days=1)
+
+    return jsonify({
+        "object": "list",
+        "data": daily_usage,
+        "total_usage": 0
+    })
+
+@app.route('/handsome/v1/dashboard/billing/subscription', methods=['GET'])
+def billing_subscription():
+    if not check_authorization(request):
+        return jsonify({"error": "Unauthorized"}), 401
+
+    total_balance = get_billing_info()
+
+    return jsonify({
+        "object": "billing_subscription",
+        "has_payment_method": False,
+        "canceled": False,
+        "canceled_at": None,
+        "delinquent": None,
+        "access_until": int(datetime(9999, 12, 31).timestamp()),
+        "soft_limit": 0,
+        "hard_limit": total_balance,
+        "system_hard_limit": total_balance,
+        "soft_limit_usd": 0,
+        "hard_limit_usd": total_balance,
+        "system_hard_limit_usd": total_balance,
+        "plan": {
+            "name": "SiliconFlow API",
+            "id": "siliconflow-api"
+        },
+        "account_name": "SiliconFlow User",
+        "po_number": None,
+        "billing_email": None,
+        "tax_ids": [],
+        "billing_address": None,
+        "business_address": None
+    })
+
+@app.route('/handsome/v1/embeddings', methods=['POST'])
+def handsome_embeddings():
     if not check_authorization(request):
         return jsonify({"error": "Unauthorized"}), 401
 
@@ -556,13 +728,11 @@ 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
+        embedding_models,
+        free_embedding_models
     )
-    
     api_key = select_key(request_type, model_name)
 
     if not api_key:
@@ -580,692 +750,23 @@ def handsome_chat_completions():
         "Authorization": f"Bearer {api_key}",
         "Content-Type": "application/json"
     }
-    
-    if model_name in image_models:
-        # Handle image generation
-        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()
-
-        # Map OpenAI-style parameters to SiliconFlow's parameters
-        siliconflow_data = {
-            "model": model_name,
-            "prompt": user_content,
-            "image_size": "1024x1024", # Default value
-            "batch_size": 1, # Default value
-            "num_inference_steps": 20, # Default value
-            "guidance_scale": 7.5, # Default value
-            "prompt_enhancement": False, # Default value
-        }
 
-        # Override with user's params (if provided)
-        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")
+    try:
+        start_time = time.time()
+        response = requests.post(
+            EMBEDDINGS_ENDPOINT,
+            headers=headers,
+            json=data,
+            timeout=120
+        )
 
-        # Parameter validation and adjustments
-        if siliconflow_data["batch_size"] < 1:
-            siliconflow_data["batch_size"] = 1
-        if siliconflow_data["batch_size"] > 4:
-            siliconflow_data["batch_size"] = 4
+        if response.status_code == 429:
+            return jsonify(response.json()), 429
 
-        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"]:
-            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", [])
-                        
-                        # Extract the first URL if available
-                        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)  # Image generation doesn't use tokens
-                    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", [])
-                    
-                    # Extract the first URL if available
-                    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})"
-                    # Construct the expected JSON output - Mimicking 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": markdown_image_link if image_url else "Failed to generate image", # Directly return the URL in content
-                            },
-                            "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)  # Image generation doesn't use tokens
-
-                return jsonify(response_data)
-        except requests.exceptions.RequestException as e:
-            logging.error(f"请求转发异常: {e}")
-            return jsonify({"error": str(e)}), 500
-    else:
-         # Existing text-based model handling logic
-        try:
-            start_time = time.time()
-            response = requests.post(
-                TEST_MODEL_ENDPOINT,
-                headers=headers,
-                json=data,
-                stream=data.get("stream", False),
-                timeout=60
-            )
-            if response.status_code == 429:
-                return jsonify(response.json()), 429
-
-            if data.get("stream", False):
-                def generate():
-                    first_chunk_time = None
-                    full_response_content = ""
-                    for chunk in response.iter_content(chunk_size=1024):
-                        if chunk:
-                            if first_chunk_time is None:
-                                first_chunk_time = time.time()
-                            full_response_content += chunk.decode("utf-8")
-                            yield chunk
-
-                    end_time = time.time()
-                    first_token_time = (
-                        first_chunk_time - start_time
-                        if first_chunk_time else 0
-                    )
-                    total_time = end_time - start_time
-
-                    prompt_tokens = 0
-                    completion_tokens = 0
-                    response_content = ""
-                    for line in full_response_content.splitlines():
-                        if line.startswith("data:"):
-                            line = line[5:].strip()
-                            if line == "[DONE]":
-                                continue
-                            try:
-                                response_json = json.loads(line)
-
-                                if (
-                                    "usage" in response_json and
-                                    "completion_tokens" in response_json["usage"]
-                                ):
-                                    completion_tokens = response_json[
-                                        "usage"
-                                    ]["completion_tokens"]
-
-                                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"]
-                                ):
-                                    response_content += response_json[
-                                        "choices"
-                                    ][0]["delta"]["content"]
-
-                                if (
-                                    "usage" in response_json and
-                                    "prompt_tokens" in response_json["usage"]
-                                ):
-                                    prompt_tokens = response_json[
-                                        "usage"
-                                    ]["prompt_tokens"]
-
-                            except (
-                                KeyError,
-                                ValueError,
-                                IndexError
-                            ) 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):
-                                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()
-
-                    user_content_replaced = user_content.replace(
-                        '\n', '\\n'
-                    ).replace('\r', '\\n')
-                    response_content_replaced = response_content.replace(
-                        '\n', '\\n'
-                    ).replace('\r', '\\n')
-
-                    logging.info(
-                        f"使用的key: {api_key}, "
-                        f"提示token: {prompt_tokens}, "
-                        f"输出token: {completion_tokens}, "
-                        f"首字用时: {first_token_time:.4f}秒, "
-                        f"总共用时: {total_time:.4f}秒, "
-                        f"使用的模型: {model_name}, "
-                        f"用户的内容: {user_content_replaced}, "
-                        f"输出的内容: {response_content_replaced}"
-                    )
-
-                    with data_lock:
-                        request_timestamps.append(time.time())
-                        token_counts.append(prompt_tokens+completion_tokens)
-
-                return Response(
-                    stream_with_context(generate()),
-                    content_type=response.headers['Content-Type']
-                )
-            else:
-                response.raise_for_status()
-                end_time = time.time()
-                response_json = response.json()
-                total_time = end_time - start_time
-
-                try:
-                    prompt_tokens = response_json["usage"]["prompt_tokens"]
-                    completion_tokens = response_json[
-                        "usage"
-                    ]["completion_tokens"]
-                    response_content = response_json[
-                        "choices"
-                    ][0]["message"]["content"]
-                except (KeyError, ValueError, IndexError) as e:
-                    logging.error(
-                        f"解析非流式响应 JSON 失败: {e}, "
-                        f"完整内容: {response_json}"
-                    )
-                    prompt_tokens = 0
-                    completion_tokens = 0
-                    response_content = ""
-
-                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()
-
-                user_content_replaced = user_content.replace(
-                    '\n', '\\n'
-                ).replace('\r', '\\n')
-                response_content_replaced = response_content.replace(
-                    '\n', '\\n'
-                ).replace('\r', '\\n')
-
-                logging.info(
-                    f"使用的key: {api_key}, "
-                    f"提示token: {prompt_tokens}, "
-                    f"输出token: {completion_tokens}, "
-                    f"首字用时: 0, "
-                    f"总共用时: {total_time:.4f}秒, "
-                    f"使用的模型: {model_name}, "
-                    f"用户的内容: {user_content_replaced}, "
-                    f"输出的内容: {response_content_replaced}"
-                )
-                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)
-
-                return jsonify(response_json)
-
-        except requests.exceptions.RequestException as e:
-            logging.error(f"请求转发异常: {e}")
-            return jsonify({"error": str(e)}), 500
-            
-@app.route('/handsome/v1/models', methods=['GET'])
-def list_models():
-    if not check_authorization(request):
-        return jsonify({"error": "Unauthorized"}), 401
-
-    detailed_models = []
-    
-    for model in text_models:
-        detailed_models.append({
-            "id": model,
-            "object": "model",
-            "created": 1678888888,
-            "owned_by": "openai",
-            "permission": [
-                {
-                    "id": f"modelperm-{uuid.uuid4().hex}",
-                    "object": "model_permission",
-                    "created": 1678888888,
-                    "allow_create_engine": False,
-                    "allow_sampling": True,
-                    "allow_logprobs": True,
-                    "allow_search_indices": False,
-                    "allow_view": True,
-                    "allow_fine_tuning": False,
-                    "organization": "*",
-                    "group": None,
-                    "is_blocking": False
-                }
-            ],
-            "root": model,
-            "parent": None
-        })
-
-    for model in embedding_models:
-        detailed_models.append({
-            "id": model,
-            "object": "model",
-            "created": 1678888888,
-            "owned_by": "openai",
-            "permission": [
-                {
-                    "id": f"modelperm-{uuid.uuid4().hex}",
-                    "object": "model_permission",
-                    "created": 1678888888,
-                    "allow_create_engine": False,
-                    "allow_sampling": True,
-                    "allow_logprobs": True,
-                    "allow_search_indices": False,
-                    "allow_view": True,
-                    "allow_fine_tuning": False,
-                    "organization": "*",
-                    "group": None,
-                    "is_blocking": False
-                }
-            ],
-            "root": model,
-            "parent": None
-        })
-    
-    for model in image_models:
-        detailed_models.append({
-            "id": model,
-            "object": "model",
-            "created": 1678888888,
-            "owned_by": "openai",
-            "permission": [
-                {
-                    "id": f"modelperm-{uuid.uuid4().hex}",
-                    "object": "model_permission",
-                    "created": 1678888888,
-                    "allow_create_engine": False,
-                    "allow_sampling": True,
-                    "allow_logprobs": True,
-                    "allow_search_indices": False,
-                    "allow_view": True,
-                    "allow_fine_tuning": False,
-                    "organization": "*",
-                    "group": None,
-                    "is_blocking": False
-                }
-            ],
-            "root": model,
-            "parent": None
-        })
-
-    return jsonify({
-        "success": True,
-        "data": detailed_models
-    })
-
-def get_billing_info():
-    keys = valid_keys_global + unverified_keys_global
-    total_balance = 0
-
-    with concurrent.futures.ThreadPoolExecutor(
-        max_workers=20
-    ) as executor:
-        futures = [
-            executor.submit(get_credit_summary, key) for key in keys
-        ]
-
-        for future in concurrent.futures.as_completed(futures):
-            try:
-                credit_summary = future.result()
-                if credit_summary:
-                    total_balance += credit_summary.get(
-                        "total_balance",
-                        0
-                    )
-            except Exception as exc:
-                logging.error(f"获取额度信息生成异常: {exc}")
-
-    return total_balance
-
-@app.route('/handsome/v1/dashboard/billing/usage', methods=['GET'])
-def billing_usage():
-    if not check_authorization(request):
-        return jsonify({"error": "Unauthorized"}), 401
-
-    end_date = datetime.now()
-    start_date = end_date - timedelta(days=30)
-
-    daily_usage = []
-    current_date = start_date
-    while current_date <= end_date:
-        daily_usage.append({
-            "timestamp": int(current_date.timestamp()),
-            "daily_usage": 0
-        })
-        current_date += timedelta(days=1)
-
-    return jsonify({
-        "object": "list",
-        "data": daily_usage,
-        "total_usage": 0
-    })
-
-@app.route('/handsome/v1/dashboard/billing/subscription', methods=['GET'])
-def billing_subscription():
-    if not check_authorization(request):
-        return jsonify({"error": "Unauthorized"}), 401
-
-    total_balance = get_billing_info()
-
-    return jsonify({
-        "object": "billing_subscription",
-        "has_payment_method": False,
-        "canceled": False,
-        "canceled_at": None,
-        "delinquent": None,
-        "access_until": int(datetime(9999, 12, 31).timestamp()),
-        "soft_limit": 0,
-        "hard_limit": total_balance,
-        "system_hard_limit": total_balance,
-        "soft_limit_usd": 0,
-        "hard_limit_usd": total_balance,
-        "system_hard_limit_usd": total_balance,
-        "plan": {
-            "name": "SiliconFlow API",
-            "id": "siliconflow-api"
-        },
-        "account_name": "SiliconFlow User",
-        "po_number": None,
-        "billing_email": None,
-        "tax_ids": [],
-        "billing_address": None,
-        "business_address": None
-    })
-
-@app.route('/handsome/v1/embeddings', methods=['POST'])
-def handsome_embeddings():
-    if not check_authorization(request):
-        return jsonify({"error": "Unauthorized"}), 401
-
-    data = request.get_json()
-    if not data or 'model' not in data:
-        return jsonify({"error": "Invalid request data"}), 400
-
-    model_name = data['model']
-    request_type = determine_request_type(
-        model_name,
-        embedding_models,
-        free_embedding_models
-    )
-    api_key = select_key(request_type, model_name)
-
-    if not api_key:
-        return jsonify(
-            {
-                "error": (
-                    "No available API key for this "
-                    "request type or all keys have "
-                    "reached their limits"
-                )
-            }
-        ), 429
-
-    headers = {
-        "Authorization": f"Bearer {api_key}",
-        "Content-Type": "application/json"
-    }
-
-    try:
-        start_time = time.time()
-        response = requests.post(
-            EMBEDDINGS_ENDPOINT,
-            headers=headers,
-            json=data,
-            timeout=120
-        )
-
-        if response.status_code == 429:
-            return jsonify(response.json()), 429
-
-        response.raise_for_status()
-        end_time = time.time()
-        response_json = response.json()
-        total_time = end_time - start_time
+        response.raise_for_status()
+        end_time = time.time()
+        response_json = response.json()
+        total_time = end_time - start_time
 
         try:
             prompt_tokens = response_json["usage"]["prompt_tokens"]
@@ -1302,10 +803,6 @@ def handsome_embeddings():
     except requests.exceptions.RequestException as e:
         return jsonify({"error": str(e)}), 500
 
-import base64
-import io
-from PIL import Image
-
 @app.route('/handsome/v1/images/generations', methods=['POST'])
 def handsome_images_generations():
     if not check_authorization(request):
@@ -1341,116 +838,610 @@ def handsome_images_generations():
         "Content-Type": "application/json"
     }
     
-    response_data = {}
-    
-    if "stable-diffusion" in model_name:
-        # Map OpenAI-style parameters to SiliconFlow's parameters
+    response_data = {}
+    
+    if "stable-diffusion" in model_name:
+        siliconflow_data = {
+            "model": model_name,
+            "prompt": data.get("prompt"),
+            "image_size": data.get("size", "1024x1024"),
+            "batch_size": data.get("n", 1),
+            "num_inference_steps": data.get("steps", 20),
+            "guidance_scale": data.get("guidance_scale", 7.5),
+            "negative_prompt": data.get("negative_prompt"),
+            "seed": data.get("seed"),
+            "prompt_enhancement": False,
+        }
+
+        # Parameter validation and adjustments
+        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"]:
+            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
+            )
+
+            if response.status_code == 429:
+                return jsonify(response.json()), 429
+
+            response.raise_for_status()
+            end_time = time.time()
+            response_json = response.json()
+            total_time = end_time - start_time
+            
+            try:
+                images = response_json.get("images", [])
+                openai_images = []
+                for item in images:
+                    if isinstance(item, dict) and "url" in item:
+                        image_url = item["url"]
+                        print(f"image_url: {image_url}")
+                        if data.get("response_format") == "b64_json":
+                           try:
+                                image_data = requests.get(image_url, stream=True).raw
+                                image = Image.open(image_data)
+                                buffered = io.BytesIO()
+                                image.save(buffered, format="PNG")
+                                img_str = base64.b64encode(buffered.getvalue()).decode()
+                                openai_images.append({"b64_json": img_str})
+                           except Exception as e:
+                                logging.error(f"图片转base64失败: {e}")
+                                openai_images.append({"url": image_url})
+                        else:
+                            openai_images.append({"url": image_url})
+                    else:
+                        logging.error(f"无效的图片数据: {item}")
+                        openai_images.append({"url": item})
+
+
+                response_data = {
+                    "created": int(time.time()),
+                    "data": openai_images
+                }
+
+            except (KeyError, ValueError, IndexError) as e:
+                logging.error(
+                    f"解析响应 JSON 失败: {e}, "
+                    f"完整内容: {response_json}"
+                )
+                response_data = {
+                    "created": int(time.time()),
+                    "data": []
+                }
+
+
+            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:
+        return jsonify({"error": "Unsupported model"}), 400
+
+@app.route('/handsome/v1/chat/completions', methods=['POST'])
+def handsome_chat_completions():
+    if not check_authorization(request):
+        return jsonify({"error": "Unauthorized"}), 401
+
+    data = request.get_json()
+    if not data or 'model' not in data:
+        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:
+        return jsonify(
+            {
+                "error": (
+                    "No available API key for this "
+                    "request type or all keys have "
+                    "reached their limits"
+                )
+            }
+        ), 429
+
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json"
+    }
+    
+    if model_name in image_models:
+        # Handle image generation
+        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": data.get("prompt"),
-            "image_size": data.get("size", "1024x1024"),
-            "batch_size": data.get("n", 1),
-            "num_inference_steps": data.get("steps", 20),
-            "guidance_scale": data.get("guidance_scale", 7.5),
-            "negative_prompt": data.get("negative_prompt"),
-            "seed": data.get("seed"),
+            "prompt": user_content,
+            "image_size": "1024x1024",
+            "batch_size": 1,
+            "num_inference_steps": 20,
+            "guidance_scale": 7.5,
             "prompt_enhancement": False,
         }
 
-        # Parameter validation and adjustments
-        if siliconflow_data["batch_size"] < 1:
-            siliconflow_data["batch_size"] = 1
-        if siliconflow_data["batch_size"] > 4:
-            siliconflow_data["batch_size"] = 4
+        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 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"]:
+            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", # Directly return the URL in content
+                            },
+                            "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)
 
-        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"]:
-            siliconflow_data["image_size"] = "1024x1024"
-    
+                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(
-                "https://api.siliconflow.cn/v1/images/generations",
+                TEST_MODEL_ENDPOINT,
                 headers=headers,
-                json=siliconflow_data,
-                timeout=120
+                json=data,
+                stream=data.get("stream", False),
+                timeout=60
             )
-
             if response.status_code == 429:
                 return jsonify(response.json()), 429
 
-            response.raise_for_status()
-            end_time = time.time()
-            response_json = response.json()
-            total_time = end_time - start_time
-            
-            try:
-                images = response_json.get("images", [])
-                openai_images = []
-                for item in images:
-                    if isinstance(item, dict) and "url" in item:
-                        image_url = item["url"]
-                        print(f"image_url: {image_url}")  # 打印 URL
-                        if data.get("response_format") == "b64_json":
-                           try:
-                                image_data = requests.get(image_url, stream=True).raw
-                                image = Image.open(image_data)
-                                buffered = io.BytesIO()
-                                image.save(buffered, format="PNG")
-                                img_str = base64.b64encode(buffered.getvalue()).decode()
-                                openai_images.append({"b64_json": img_str})
-                           except Exception as e:
-                                logging.error(f"图片转base64失败: {e}")
-                                openai_images.append({"url": image_url})
-                        else:
-                            openai_images.append({"url": image_url})
-                    else:
-                        logging.error(f"无效的图片数据: {item}")
-                        openai_images.append({"url": item})
+            if data.get("stream", False):
+                def generate():
+                    first_chunk_time = None
+                    full_response_content = ""
+                    for chunk in response.iter_content(chunk_size=1024):
+                        if chunk:
+                            if first_chunk_time is None:
+                                first_chunk_time = time.time()
+                            full_response_content += chunk.decode("utf-8")
+                            yield chunk
 
+                    end_time = time.time()
+                    first_token_time = (
+                        first_chunk_time - start_time
+                        if first_chunk_time else 0
+                    )
+                    total_time = end_time - start_time
 
-                response_data = {
-                    "created": int(time.time()),
-                    "data": openai_images
-                }
+                    prompt_tokens = 0
+                    completion_tokens = 0
+                    response_content = ""
+                    for line in full_response_content.splitlines():
+                        if line.startswith("data:"):
+                            line = line[5:].strip()
+                            if line == "[DONE]":
+                                continue
+                            try:
+                                response_json = json.loads(line)
 
-            except (KeyError, ValueError, IndexError) as e:
-                logging.error(
-                    f"解析响应 JSON 失败: {e}, "
-                    f"完整内容: {response_json}"
+                                if (
+                                    "usage" in response_json and
+                                    "completion_tokens" in response_json["usage"]
+                                ):
+                                    completion_tokens = response_json[
+                                        "usage"
+                                    ]["completion_tokens"]
+
+                                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"]
+                                ):
+                                    response_content += response_json[
+                                        "choices"
+                                    ][0]["delta"]["content"]
+
+                                if (
+                                    "usage" in response_json and
+                                    "prompt_tokens" in response_json["usage"]
+                                ):
+                                    prompt_tokens = response_json[
+                                        "usage"
+                                    ]["prompt_tokens"]
+
+                            except (
+                                KeyError,
+                                ValueError,
+                                IndexError
+                            ) 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):
+                                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()
+
+                    user_content_replaced = user_content.replace(
+                        '\n', '\\n'
+                    ).replace('\r', '\\n')
+                    response_content_replaced = response_content.replace(
+                        '\n', '\\n'
+                    ).replace('\r', '\\n')
+
+                    logging.info(
+                        f"使用的key: {api_key}, "
+                        f"提示token: {prompt_tokens}, "
+                        f"输出token: {completion_tokens}, "
+                        f"首字用时: {first_token_time:.4f}秒, "
+                        f"总共用时: {total_time:.4f}秒, "
+                        f"使用的模型: {model_name}, "
+                        f"用户的内容: {user_content_replaced}, "
+                        f"输出的内容: {response_content_replaced}"
+                    )
+
+                    with data_lock:
+                        request_timestamps.append(time.time())
+                        token_counts.append(prompt_tokens+completion_tokens)
+
+                return Response(
+                    stream_with_context(generate()),
+                    content_type=response.headers['Content-Type']
                 )
-                response_data = {
-                    "created": int(time.time()),
-                    "data": []
-                }
+            else:
+                response.raise_for_status()
+                end_time = time.time()
+                response_json = response.json()
+                total_time = end_time - start_time
+
+                try:
+                    prompt_tokens = response_json["usage"]["prompt_tokens"]
+                    completion_tokens = response_json[
+                        "usage"
+                    ]["completion_tokens"]
+                    response_content = response_json[
+                        "choices"
+                    ][0]["message"]["content"]
+                except (KeyError, ValueError, IndexError) as e:
+                    logging.error(
+                        f"解析非流式响应 JSON 失败: {e}, "
+                        f"完整内容: {response_json}"
+                    )
+                    prompt_tokens = 0
+                    completion_tokens = 0
+                    response_content = ""
 
+                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", "") +
+                                        " "
+                                    )
 
-            logging.info(
-                f"使用的key: {api_key}, "
-                f"总共用时: {total_time:.4f}秒, "
-                f"使用的模型: {model_name}"
-            )
+                user_content = user_content.strip()
 
-            with data_lock:
-                request_timestamps.append(time.time())
-                token_counts.append(0)  # Image generation doesn't use tokens
+                user_content_replaced = user_content.replace(
+                    '\n', '\\n'
+                ).replace('\r', '\\n')
+                response_content_replaced = response_content.replace(
+                    '\n', '\\n'
+                ).replace('\r', '\\n')
 
-            return jsonify(response_data)
+                logging.info(
+                    f"使用的key: {api_key}, "
+                    f"提示token: {prompt_tokens}, "
+                    f"输出token: {completion_tokens}, "
+                    f"首字用时: 0, "
+                    f"总共用时: {total_time:.4f}秒, "
+                    f"使用的模型: {model_name}, "
+                    f"用户的内容: {user_content_replaced}, "
+                    f"输出的内容: {response_content_replaced}"
+                )
+                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)
+
+                return jsonify(response_json)
 
         except requests.exceptions.RequestException as e:
             logging.error(f"请求转发异常: {e}")
-            return jsonify({"error": str(e)}), 500
-    else:
-        return jsonify({"error": "Unsupported model"}), 400
+            return jsonify({"error": str(e)}), 500        
 
 if __name__ == '__main__':
     import json