Update app.py

app.py

@@ -1,71 +1,41 @@
+import asyncio
 import gradio as gr
-import requests, re
-from api_usage import get_subscription, check_key_availability, get_orgs_me, check_key_ant_availability, check_ant_rate_limit, check_key_gemini_availability, check_key_azure_availability, get_azure_status, get_azure_deploy, check_key_mistral_availability, check_mistral_quota, check_key_replicate_availability, check_key_aws_availability, check_key_or_availability, check_key_or_limits, check_gcp_anthropic, check_groq_status, check_nai_status, check_elevenlabs_status, check_xai_status, check_stability_status, check_deepseek_status
+import requests
+import re
+from typing import List, Dict, Tuple, Any # 添加类型提示
 
-async def sort_key(key, rate_limit, claude_model):
-    _key = key.strip()
-    
-    if re.match(re.compile("sk-or-v1-[a-z0-9]{64}"), _key):    
-        return get_key_openrouter_info(_key)
-        
-    if re.match(re.compile("sk-ant-api03-[a-zA-Z0-9\-_]{93}AA"), _key) or (_key.startswith("sk-ant-") and len(_key) == 93) or (len(_key) == 89 and re.match(re.compile("sk-[a-zA-Z0-9]{86}"), _key)):
-        return await get_key_ant_info(_key, rate_limit, claude_model)
-    
-    if re.match(re.compile(r"sk-[a-zA-Z0-9]{48}"), _key) and len(_key) == 51 and 'T3BlbkFJ' not in _key:
-        return get_key_stability_info(_key)
-    
-    if re.match(re.compile(r"sk-[a-f0-9]{32}"), _key):
-        return get_key_deepseek_info(_key)
-    
-    if _key.startswith("sk-"):    
-        return get_key_oai_info(_key)
-        
-    if _key.startswith("AIzaSy"):
-        return get_key_gemini_info(_key)
-    
-    if _key.startswith("pst-"):
-        return get_key_nai_info(_key)
-        
-    if (_key.startswith("r8_") and len(_key) == 40) or (_key.islower() and len(_key) == 40):
-        return get_key_replicate_info(_key)
-        
-    if _key.startswith("xai-"):  
-        return get_key_xai_info(_key)
-        
-    if len(_key.split(':')) == 2 and _key.split(':')[1].islower() and len(_key.split(':')[1]) == 32 and "openai.azure.com" not in _key.split(':')[1]:
-        endpoint = f"{_key.split(':')[0]}.openai.azure.com"
-        api_key = _key.split(':')[1]
-        return get_key_azure_info(endpoint, api_key)
-        
-    if "openai.azure.com" in _key.split(';')[0]:
-        endpoint = _key.split(';')[0]
-        api_key = _key.split(';')[1]
-        return get_key_azure_info(endpoint, api_key)
-        
-    if _key.startswith("AKIA") and len(_key.split(':')[0]) == 20 and _key.split(':')[0].isupper():
-        return await get_key_aws_info(_key)
-    
-    if re.match(re.compile(r"[a-f0-9]{32}"), _key) or re.match(re.compile(r"sk_[a-f0-9]{48}"), _key):
-        return get_key_elevenlabs_info(_key)
-    
-    if re.match(re.compile(r"[a-zA-Z0-9]{32}"), _key):
-        return get_key_mistral_info(_key)
-        
-    if re.match(re.compile(r"gsk_[a-zA-Z0-9]{20}WGdyb3FY[a-zA-Z0-9]{24}"), _key):
-        return get_key_groq_info(_key)
-        
-    if re.match(re.compile(r"[\w\-]+:[\w\-@\.]+:[\w-]+:.+"), _key): # 0: refresh token
-        return await get_key_gcp_info(_key, 0)
-        
-    if re.match(re.compile(r"[\w\-]+:[\w\-@\.]+:.+\\n"), _key): # 1: service account
-        return await get_key_gcp_info(_key, 1)
-        
-    return not_supported(_key)
-
-def get_key_oai_info(key):
-    # Return a dictionary containing key information
-    session = requests.Session()
+# 假设api_usage模块根据用户环境存在
+# 导入需要的函数（实际使用时需要此模块）
+from api_usage import (
+    get_subscription,
+    check_key_availability,
+    get_orgs_me,
+    check_key_ant_availability,
+    check_ant_rate_limit,
+    check_key_gemini_availability, # 假设此函数返回(bool, str)元组
+    check_key_azure_availability,
+    get_azure_status,
+    get_azure_deploy,
+    check_key_mistral_availability,
+    check_mistral_quota,
+    check_key_replicate_availability,
+    check_key_aws_availability,
+    check_key_or_availability,
+    check_key_or_limits,
+    check_gcp_anthropic,
+    check_groq_status,
+    check_nai_status,
+    check_elevenlabs_status,
+    check_xai_status,
+    check_stability_status,
+    check_deepseek_status,
+)
 
+# ─────────────────────────────────────────
+# 特定密钥的帮助函数（保持原样 - 包括Gemini）
+# ─────────────────────────────────────────
+def get_key_oai_info(key: str) -> Dict[str, Any]:
+    session = requests.Session()
     status, org_data = check_key_availability(session, key)
 
     info_dict = {
@@ -80,7 +50,7 @@ def get_key_oai_info(key):
         "requests_per_minute": "",
         "tokens_per_minute": "",
         "quota": "",
-        "all_models": ""
+        "all_models": "",
     }
 
     if not status:
@@ -90,41 +60,42 @@ def get_key_oai_info(key):
         status_me, orgs_me = get_orgs_me(session, key)
         if status_me == 200:
             org_data = orgs_me
-        
-    subscription_info = get_subscription(key, session, org_data)
-
-    # Update the info_dict with subscription details
-    info_dict.update({
-        "gpt4_availability": subscription_info["has_gpt4"],
-        "gpt4_32k_availability": subscription_info["has_gpt4_32k"],
-        "default_org": subscription_info["default_org"],
-        "org_description": subscription_info["org_description"],
-        "organization": subscription_info["organization"],
-        "models": subscription_info["models"],
-        "requests_per_minute": subscription_info["rpm"],
-        "tokens_per_minute": subscription_info["tpm"],
-        "quota": subscription_info["quota"],
-        "all_models": subscription_info["all_models"]
-    })
 
+    subscription_info = get_subscription(key, session, org_data)
+    if subscription_info:
+        info_dict.update(
+            {
+                "gpt4_availability": subscription_info.get("has_gpt4", ""),
+                "gpt4_32k_availability": subscription_info.get("has_gpt4_32k", ""),
+                "default_org": subscription_info.get("default_org", ""),
+                "org_description": subscription_info.get("org_description", ""),
+                "organization": subscription_info.get("organization", ""),
+                "models": subscription_info.get("models", ""),
+                "requests_per_minute": subscription_info.get("rpm", ""),
+                "tokens_per_minute": subscription_info.get("tpm", ""),
+                "quota": subscription_info.get("quota", ""),
+                "all_models": subscription_info.get("all_models", ""),
+            }
+        )
     return info_dict
 
-async def get_key_ant_info(key, rate_limit, claude_model):
-    # Return a dictionary containing key information
+
+async def get_key_ant_info(key: str, rate_limit: bool, claude_model: str) -> Dict[str, Any]:
     key_avai = await check_key_ant_availability(key, claude_model)
-    info_dict = {#"account_name": "",
-                 "key_type": "Anthropic Claude",
-                 "key_availability": key_avai[0],
-                 "status": "",
-                 "filter_response": "",
-                 "requests_per_minute": "",
-                 "tokens_per_minute": "",
-                 "tokens_input_per_minute": "",
-                 "tokens_output_per_minute": "",
-                 "tier": "",
-                 "concurrent_rate_limit": "",
-                 "models": ""}
-    
+    info_dict = {
+        "key_type": "Anthropic Claude",
+        "key_availability": key_avai[0],
+        "status": "",
+        "filter_response": "",
+        "requests_per_minute": "",
+        "tokens_per_minute": "",
+        "tokens_input_per_minute": "",
+        "tokens_output_per_minute": "",
+        "tier": "",
+        "concurrent_rate_limit": "",
+        "models": "",
+    }
+
     info_dict["status"] = key_avai[1]
     info_dict["filter_response"] = key_avai[2]
     info_dict["requests_per_minute"] = key_avai[3] + ("" if key_avai[3] == "" else f" ({key_avai[4]} left)")
@@ -133,251 +104,491 @@ async def get_key_ant_info(key, rate_limit, claude_model):
     info_dict["tokens_output_per_minute"] = key_avai[10] + ("" if key_avai[10] == "" else f" ({key_avai[11]} left)")
     info_dict["tier"] = key_avai[7]
     info_dict["models"] = key_avai[12]
-        
+
     if rate_limit:
         rate = await check_ant_rate_limit(key, claude_model)
         info_dict["concurrent_rate_limit"] = rate
-        
+
     return info_dict
 
-def get_key_gemini_info(key):
-    key_avai = check_key_gemini_availability(key)
-    info_dict = {#"account_name": "",
-                 "key_type": "Google Gemini",
-                 "key_availability": key_avai[0],
-                 "status": key_avai[1],
-                 "models": key_avai[2]}
+
+# 保持用户原始的get_key_gemini_info函数
+def get_key_gemini_info(key: str) -> Dict[str, Any]:
+    """获取Gemini密钥信息（用户原始版本）。"""
+    key_avai = check_key_gemini_availability(key) # 假设返回(bool, str)元组
+    info_dict = {
+        "key": key, # 原版中有key字段
+        "key_availability": key_avai[0],
+        "status": key_avai[1],
+    }
     return info_dict
 
-def get_key_azure_info(endpoint, api_key):
+
+def get_key_azure_info(endpoint: str, api_key: str) -> Dict[str, Any]:
     key_avai = check_key_azure_availability(endpoint, api_key)
-    info_dict = {#"account_name": "",
-             "key_type": "Microsoft Azure OpenAI",
-             "key_availability": key_avai[0],
-             "gpt35_availability": "",
-             "gpt4_availability": "",
-             "gpt4_32k_availability": "",             
-             "dall_e_3_availability": "",             
-             "moderation_status": "",
-             "models": "",
-             "deployments": ""}
-    if key_avai[0]:        
+    info_dict = {
+        "key_type": "Microsoft Azure OpenAI",
+        "key_availability": key_avai[0],
+        "gpt35_availability": "",
+        "gpt4_availability": "",
+        "gpt4_32k_availability": "",
+        "dall_e_3_availability": "",
+        "moderation_status": "",
+        "models": "",
+        "deployments": "",
+    }
+    if key_avai[0]:
         azure_deploy = get_azure_deploy(endpoint, api_key)
-        status = get_azure_status(endpoint, api_key, azure_deploy)
-        info_dict["gpt35_availability"] = status[1]
-        info_dict["gpt4_availability"] = status[2]
-        info_dict["gpt4_32k_availability"] = status[3]
-        info_dict["dall_e_3_availability"] = status[4]
-        info_dict["moderation_status"] = status[0]
+        if azure_deploy:
+            status = get_azure_status(endpoint, api_key, azure_deploy)
+            if status:
+                info_dict["gpt35_availability"] = status[1]
+                info_dict["gpt4_availability"] = status[2]
+                info_dict["gpt4_32k_availability"] = status[3]
+                info_dict["dall_e_3_availability"] = status[4]
+                info_dict["moderation_status"] = status[0]
         info_dict["models"] = key_avai[1]
-        info_dict["deployments"] = azure_deploy
+        info_dict["deployments"] = azure_deploy if azure_deploy else "N/A"
     return info_dict
 
-def get_key_mistral_info(key):
+
+def get_key_mistral_info(key: str) -> Dict[str, Any]:
     key_avai = check_key_mistral_availability(key)
-    info_dict = {#"account_name": "",
-                 "key_type": "Mistral AI",
-                 "key_availability": True if key_avai else False,
-                 "has_quota": "",
-                 "limits": "",
-                 "models": ""}
+    info_dict = {
+        "key_type": "Mistral AI",
+        "key_availability": True if key_avai else False,
+        "has_quota": "",
+        "limits": "",
+        "models": "",
+    }
     if key_avai:
         quota_info = check_mistral_quota(key)
-        info_dict['has_quota'] = quota_info[0]
-        if quota_info[1]:
-            info_dict['limits'] = quota_info[1]
-        info_dict['models'] = key_avai
+        if quota_info:
+            info_dict["has_quota"] = quota_info[0]
+            if quota_info[1]:
+                info_dict["limits"] = quota_info[1]
+        info_dict["models"] = key_avai
     return info_dict
 
-def get_key_replicate_info(key):
+
+def get_key_replicate_info(key: str) -> Dict[str, Any]:
     key_avai = check_key_replicate_availability(key)
-    info_dict = {#"account_name": "",
-                 "key_type": "Replicate",
-                 "key_availability": key_avai[0],
-                 "account_name": "",
-                 "type": "",
-                 "has_quota": "",
-                 "hardware_available": ""}
-    if key_avai[0]:
-        info_dict['account_name'] = key_avai[1]['username']
-        info_dict['type'] = key_avai[1]['type']
-        info_dict['has_quota'] = key_avai[2]
-        info_dict['hardware_available'] = key_avai[3]
+    info_dict = {
+        "key_type": "Replicate",
+        "key_availability": key_avai[0],
+        "account_name": "",
+        "type": "",
+        "has_quota": "",
+        "hardware_available": "",
+    }
+    if key_avai[0] and isinstance(key_avai[1], dict):
+        info_dict["account_name"] = key_avai[1].get("username", "")
+        info_dict["type"] = key_avai[1].get("type", "")
+        info_dict["has_quota"] = key_avai[2]
+        info_dict["hardware_available"] = key_avai[3]
     return info_dict
 
-async def get_key_aws_info(key):
+
+async def get_key_aws_info(key: str) -> Dict[str, Any]:
     key_avai = await check_key_aws_availability(key)
-    info_dict = {#"account_name": "",
-                 "key_type": "Amazon AWS Claude",
-                 "key_availability": key_avai[0],
-                 "username": "",
-                 "root": "",
-                 "admin": "",
-                 "quarantine": "",
-                 "iam_full_access": "",         
-                 "iam_user_change_password": "",         
-                 "aws_bedrock_full_access": "",         
-                 "enabled_region": "",
-                 "models_usage": "", 
-                 "cost_and_usage": key_avai[1]}
+    info_dict = {
+        "key_type": "Amazon AWS Claude",
+        "key_availability": key_avai[0],
+        "username": "",
+        "root": "",
+        "admin": "",
+        "quarantine": "",
+        "iam_full_access": "",
+        "iam_user_change_password": "",
+        "aws_bedrock_full_access": "",
+        "enabled_region": "",
+        "models_usage": "",
+        "cost_and_usage": key_avai[1] if not key_avai[0] else "",
+    }
     if key_avai[0]:
-        info_dict['username'] = key_avai[1]
-        info_dict['root'] = key_avai[2]
-        info_dict['admin'] = key_avai[3]
-        info_dict['quarantine'] = key_avai[4] 
-        info_dict['iam_full_access'] = key_avai[5]
-        info_dict['iam_user_change_password'] = key_avai[6]
-        info_dict['aws_bedrock_full_access'] = key_avai[7]
-        info_dict['enabled_region'] = key_avai[8]
-        info_dict['models_usage'] = key_avai[9]
-        info_dict['cost_and_usage'] = key_avai[10]
+        info_dict["username"] = key_avai[1]
+        info_dict["root"] = key_avai[2]
+        info_dict["admin"] = key_avai[3]
+        info_dict["quarantine"] = key_avai[4]
+        info_dict["iam_full_access"] = key_avai[5]
+        info_dict["iam_user_change_password"] = key_avai[6]
+        info_dict["aws_bedrock_full_access"] = key_avai[7]
+        info_dict["enabled_region"] = key_avai[8]
+        info_dict["models_usage"] = key_avai[9]
+        info_dict["cost_and_usage"] = key_avai[10]
     return info_dict
 
-def get_key_openrouter_info(key):    
+
+def get_key_openrouter_info(key: str) -> Dict[str, Any]:
     key_avai = check_key_or_availability(key)
-    info_dict = {#"account_name": "",
-                 "key_type": "OpenRouter",
-                 "key_availability": key_avai[0],
-                 "is_free_tier": "",
-                 "usage": "",
-                 "balance": "",
-                 "limit": "",
-                 "limit_remaining": "",
-                 "rate_limit_per_minite": "",
-                 "4_turbo_per_request_tokens_limit": "",
-                 "sonnet_per_request_tokens_limit": "",
-                 "opus_per_request_tokens_limit": ""}
-    if key_avai[0]:
+    info_dict = {
+        "key_type": "OpenRouter",
+        "key_availability": key_avai[0],
+        "is_free_tier": "",
+        "usage": "",
+        "balance": "",
+        "limit": "",
+        "limit_remaining": "",
+        "rate_limit_per_minite": "",
+        "4_turbo_per_request_tokens_limit": "",
+        "sonnet_per_request_tokens_limit": "",
+        "opus_per_request_tokens_limit": "",
+    }
+    if key_avai[0] and isinstance(key_avai[1], dict):
         models_info = check_key_or_limits(key)
-        info_dict['is_free_tier'] = key_avai[1]['is_free_tier']
-        info_dict['limit'] = key_avai[1]['limit']
-        info_dict['limit_remaining'] = key_avai[1]['limit_remaining']
-        info_dict['usage'] = f"${format(key_avai[1]['usage'], '.4f')}"
-        info_dict['balance'] = f"${format(models_info[0], '.4f')}" if models_info[0] else f"${key_avai[2]/60} (estimated)" 
-        info_dict['rate_limit_per_minite'] = key_avai[2]
-        info_dict['4_turbo_per_request_tokens_limit'] = models_info[1]['openai/gpt-4o']
-        info_dict['sonnet_per_request_tokens_limit'] = models_info[1]['anthropic/claude-3.5-sonnet:beta']
-        info_dict['opus_per_request_tokens_limit'] = models_info[1]['anthropic/claude-3-opus:beta']
-    else:
-        info_dict['usage'] = key_avai[1]
+        info_dict["is_free_tier"] = key_avai[1].get("is_free_tier", "")
+        info_dict["limit"] = key_avai[1].get("limit", "")
+        info_dict["limit_remaining"] = key_avai[1].get("limit_remaining", "")
+        usage_val = key_avai[1].get("usage")
+        info_dict["usage"] = f"${format(usage_val, '.4f')}" if isinstance(usage_val, (int, float)) else ""
+
+        balance_val = models_info[0] if models_info else None
+        rate_limit_val = key_avai[2] if len(key_avai) > 2 else None
+
+        if balance_val is not None:
+             info_dict["balance"] = f"${format(balance_val, '.4f')}"
+        elif rate_limit_val is not None:
+             try:
+                 estimated_balance = float(rate_limit_val) / 60
+                 info_dict["balance"] = f"${format(estimated_balance, '.4f')} (estimated)"
+             except (ValueError, TypeError):
+                 info_dict["balance"] = "$N/A (estimation failed)"
+        else:
+            info_dict["balance"] = "$N/A"
+
+        info_dict["rate_limit_per_minite"] = rate_limit_val if rate_limit_val is not None else ""
+
+        if models_info and isinstance(models_info[1], dict):
+             model_limits = models_info[1]
+             info_dict["4_turbo_per_request_tokens_limit"] = model_limits.get("openai/gpt-4o", "")
+             info_dict["sonnet_per_request_tokens_limit"] = model_limits.get("anthropic/claude-3.5-sonnet:beta", "")
+             info_dict["opus_per_request_tokens_limit"] = model_limits.get("anthropic/claude-3-opus:beta", "")
+    elif not key_avai[0] and len(key_avai) > 1:
+        info_dict["usage"] = key_avai[1]
     return info_dict
 
-async def get_key_gcp_info(key, type):    
+
+async def get_key_gcp_info(key: str, type: int) -> Dict[str, Any]:
     key_avai = await check_gcp_anthropic(key, type)
-    info_dict = {#"account_name": "",
-                 "key_type": "Vertex AI (GCP)",
-                 "key_availability": key_avai[0],
-                 "status": "",
-                 "enabled_region": ""}
+    info_dict = {
+        "key_type": "Vertex AI (GCP)",
+        "key_availability": key_avai[0],
+        "status": "",
+        "enabled_region": "",
+    }
     if key_avai[0]:
-        info_dict['enabled_region'] = key_avai[2]
-    else:
-        info_dict['status'] = key_avai[1]
+        info_dict["enabled_region"] = key_avai[2]
+    elif len(key_avai) > 1:
+        info_dict["status"] = key_avai[1]
     return info_dict
 
-def get_key_groq_info(key):
+
+def get_key_groq_info(key: str) -> Dict[str, Any]:
     key_avai = check_groq_status(key)
-    info_dict = {#"account_name": "",
-                 "key_type": "Groq",
-                 "key_availability": True if key_avai else False,
-                 "models": key_avai if key_avai else ""}
+    info_dict = {
+        "key_type": "Groq",
+        "key_availability": True if key_avai else False,
+        "models": key_avai if key_avai else "",
+    }
     return info_dict
 
-def get_key_nai_info(key):
+
+def get_key_nai_info(key: str) -> Dict[str, Any]:
     key_avai = check_nai_status(key)
-    info_dict = {#"account_name": "",
-                 "key_type": "NovelAI",
-                 "key_availability": True if key_avai[0] else False,
-                 "user_info": key_avai[1] if key_avai[0] else ""}
+    info_dict = {
+        "key_type": "NovelAI",
+        "key_availability": True if key_avai[0] else False,
+        "user_info": key_avai[1] if key_avai[0] else "",
+    }
     return info_dict
-    
-def get_key_elevenlabs_info(key):
+
+
+def get_key_elevenlabs_info(key: str) -> Dict[str, Any]:
     key_avai = check_elevenlabs_status(key)
-    info_dict = {#"account_name": "",
-                 "key_type": "ElevenLabs",
-                 "key_availability": key_avai[0],
-                 "user_info": key_avai[1],
-                 "voices_info": key_avai[2]}
+    info_dict = {
+        "key_type": "ElevenLabs",
+        "key_availability": key_avai[0],
+        "user_info": key_avai[1] if len(key_avai) > 1 else "",
+        "voices_info": key_avai[2] if len(key_avai) > 2 else "",
+    }
     return info_dict
 
-def get_key_xai_info(key):
+
+def get_key_xai_info(key: str) -> Dict[str, Any]:
     key_avai = check_xai_status(key)
-    info_dict = {#"account_name": "",
-                 "key_type": "xAI Grok",
-                 "key_availability": key_avai[0],
-                 "key_status": "",
-                 "models": ""}
+    info_dict = {
+        "key_type": "xAI Grok",
+        "key_availability": key_avai[0],
+        "key_status": "",
+        "models": "",
+    }
     if key_avai[0]:
-        info_dict['key_status'] = key_avai[1]
-        info_dict['models'] = key_avai[2]
+        info_dict["key_status"] = key_avai[1] if len(key_avai) > 1 else ""
+        info_dict["models"] = key_avai[2] if len(key_avai) > 2 else ""
     return info_dict
-    
-def get_key_stability_info(key):
+
+
+def get_key_stability_info(key: str) -> Dict[str, Any]:
     key_avai = check_stability_status(key)
-    info_dict = {#"account_name": "",
-                 "key_type": "Stability AI",
-                 "key_availability": key_avai[0],
-                 "account_info": "",
-                 "credits": "",
-                 "models": ""}
+    info_dict = {
+        "key_type": "Stability AI",
+        "key_availability": key_avai[0],
+        "account_info": "",
+        "credits": "",
+        "models": "",
+    }
     if key_avai[0]:
-        info_dict['account_info'] = key_avai[1]
-        info_dict['credits'] = key_avai[2]
-        info_dict['models'] = key_avai[3]
+        info_dict["account_info"] = key_avai[1] if len(key_avai) > 1 else ""
+        info_dict["credits"] = key_avai[2] if len(key_avai) > 2 else ""
+        info_dict["models"] = key_avai[3] if len(key_avai) > 3 else ""
     return info_dict
 
-def get_key_deepseek_info(key):
+
+def get_key_deepseek_info(key: str) -> Dict[str, Any]:
     key_avai = check_deepseek_status(key)
-    info_dict = {#"account_name": "",
-                 "key_type": "deepseek",
-                 "key_availability": key_avai[0],
-                 "balance": "",
-                 "models": ""}
-    if key_avai[0]:        
-        info_dict['models'] = key_avai[1]
-        info_dict['balance'] = key_avai[2]
+    info_dict = {
+        "key_type": "DeepSeek",
+        "key_availability": key_avai[0],
+        "balance": "",
+        "models": "",
+    }
+    if key_avai[0]:
+        info_dict["models"] = key_avai[1] if len(key_avai) > 1 else ""
+        info_dict["balance"] = key_avai[2] if len(key_avai) > 2 else ""
     return info_dict
 
-def not_supported(key):
-    info_dict = {#"account_name": "",
-                     "key_type": "Not supported",
-                     "status": ""}
-    return info_dict
-    
-def clear_inputs(text):
-    return ""
 
+def not_supported(key: str) -> Dict[str, Any]:
+    return {
+        "key_type": "Not supported",
+        "key_availability": False,
+        "status": "Unknown key format",
+    }
+
+
+# ─────────────────────────────────────────
+#  单个密钥异步处理（已更新）
+# ─────────────────────────────────────────
+async def process_single_key(key: str, rate_limit: bool, claude_model: str) -> Dict[str, Any]:
+    """分析给定的单个密钥并返回信息字典。包含Gemini密钥的工作状态标志。"""
+    _key = key.strip()
+
+    if not _key:
+        return {"key": "", "key_type": "Empty", "key_availability": False}
+
+    # OpenRouter
+    if re.match(re.compile(r"sk-or-v1-[a-z0-9]{64}"), _key):
+        result = get_key_openrouter_info(_key)
+        return {"key": _key, **result} # key_type在get_key_openrouter_info中返回
+
+    # Anthropic Claude
+    if re.match(re.compile(r"sk-ant-api03-[a-zA-Z0-9\-_]{93}AA"), _key) or \
+       (_key.startswith("sk-ant-") and len(_key) == 93) or \
+       (len(_key) == 89 and re.match(re.compile(r"sk-[a-zA-Z0-9]{86}"), _key)):
+        result = await get_key_ant_info(_key, rate_limit, claude_model)
+        return {"key": _key, **result} # 包含key_type
+
+    # Stability
+    if re.match(re.compile(r"sk-[a-zA-Z0-9]{48}"), _key) and len(_key) == 51 and "T3BlbkFJ" not in _key:
+        result = get_key_stability_info(_key)
+        return {"key": _key, **result} # 包含key_type
+
+    # Deepseek
+    if re.match(re.compile(r"sk-[a-f0-9]{32}"), _key):
+         result = get_key_deepseek_info(_key)
+         return {"key": _key, **result} # 包含key_type
+
+    # OpenAI (应该位于其他sk-模式之后)
+    if _key.startswith("sk-"):
+        result = get_key_oai_info(_key)
+        return {"key": _key, **result} # 包含key_type
+
+    # Google Gemini处理（已修改）
+    if _key.startswith("AIzaSy"):
+        gemini_info = get_key_gemini_info(_key) # 调用原始函数
+        # 添加工作状态标志（检查status）
+        is_working = gemini_info.get("key_availability") and gemini_info.get("status") == "Working"
+        # 构建结果字典：原始信息 + key_type + 工作状态标志
+        # gemini_info已经包含'key'
+        result = {
+            "key_type": "Google Gemini", # 明确添加类型信息
+            **gemini_info,
+            "is_gemini_working": is_working # 工作状态标志
+        }
+        return result
+
+    # NovelAI
+    if _key.startswith("pst-"):
+        result = get_key_nai_info(_key)
+        return {"key": _key, **result} # 包含key_type
+
+    # Replicate
+    if (_key.startswith("r8_") and len(_key) == 40) or (_key.islower() and len(_key) == 40):
+        result = get_key_replicate_info(_key)
+        return {"key": _key, **result} # 包含key_type
+
+    # xAI
+    if _key.startswith("xai-"):
+        result = get_key_xai_info(_key)
+        return {"key": _key, **result} # 包含key_type
+
+    # Azure endpoint: "name:key"
+    if len(_key.split(":")) == 2:
+        name, potential_key = _key.split(":", 1)
+        if re.fullmatch(r'[a-fA-F0-9]{32}', potential_key) and "openai.azure.com" not in name:
+             endpoint = f"https://{name}.openai.azure.com/"
+             api_key = potential_key
+             result = get_key_azure_info(endpoint, api_key)
+             return {"key": _key, **result} # 包含key_type
+
+    # Azure endpoint: "https://xxx.openai.azure.com;key"
+    if ";" in _key and "openai.azure.com" in _key.split(";")[0]:
+        endpoint, api_key = _key.split(";", 1)
+        result = get_key_azure_info(endpoint, api_key)
+        return {"key": _key, **result} # 包含key_type
+
+    # AWS
+    if _key.startswith("AKIA") and len(_key.split(":")[0]) == 20 and _key.split(":")[0].isalnum() and _key.split(":")[0].isupper() and len(_key.split(':')) == 2:
+        result = await get_key_aws_info(_key)
+        return {"key": _key, **result} # 包含key_type
+
+    # ElevenLabs
+    if re.fullmatch(r"[a-f0-9]{32}", _key) or re.fullmatch(r"sk_[a-f0-9]{48}", _key):
+        result = get_key_elevenlabs_info(_key)
+        return {"key": _key, **result} # 包含key_type
+
+    # Mistral
+    if re.fullmatch(r"[a-zA-Z0-9]{32}", _key) and not _key.startswith('sk-'):
+        result = get_key_mistral_info(_key)
+        return {"key": _key, **result} # 包含key_type
+
+    # Groq
+    if re.match(re.compile(r"gsk_[a-zA-Z0-9]{20}WGdyb3FY[a-zA-Z0-9]{24}"), _key):
+        result = get_key_groq_info(_key)
+        return {"key": _key, **result} # 包含key_type
+
+    # GCP - refresh token
+    if re.match(re.compile(r"[\w\-]+:[\w\-@\.]+:.+:.+"), _key):
+        parts = _key.split(':')
+        if len(parts) >= 4:
+            result = await get_key_gcp_info(_key, 0)
+            return {"key": _key, **result} # 包含key_type
+
+    # GCP - service account
+    if re.match(re.compile(r"[\w\-]+:[\w\-@\.]+:.+\\n"), _key):
+         parts = _key.split(':')
+         if len(parts) >= 3:
+            result = await get_key_gcp_info(_key, 1)
+            return {"key": _key, **result} # 包含key_type
+
+    # Not supported
+    result = not_supported(_key) # 包含key_type, key_availability, status
+    # 添加密钥值并返回
+    return {"key": _key, **result}
+
+
+# ─────────────────────────────────────────
+#  多密钥异步处理函数（已更新）
+# ─────────────────────────────────────────
+async def sort_keys(text: str, rate_limit: bool, claude_model: str) -> Tuple[List[Dict[str, Any]], str]:
+    """分析文本框中输入的多个密钥（按行），并返回完整结果和有效Gemini密钥列表。"""
+    keys = [k.strip() for k in text.splitlines() if k.strip()]
+    if not keys:
+        return [], ""
+
+    tasks = [process_single_key(k, rate_limit, claude_model) for k in keys]
+    results = await asyncio.gather(*tasks)
+
+    # 仅筛选有效的Gemini密钥（使用is_gemini_working标志）
+    working_gemini_keys = []
+    for result in results:
+        # 检查is_gemini_working键是否存在且为True
+        if result.get("is_gemini_working"): # 使用get()避免键不存在时出错
+            # 原始get_key_gemini_info包含'key'字段，可直接使用
+            working_gemini_keys.append(result["key"])
+
+    # 返回JSON列表结果和Gemini密钥列表字符串
+    return results, "\n".join(working_gemini_keys)
+
+
+# ─────────────────────────────────────────
+#  UI工具函数
+# ─────────────────────────────────────────
+def clear_inputs(): # 移除输入参数（不需要key_box值）
+    return "", "", "" # 重置所有输入/输出
+
+
+# ─────────────────────────────────────────
+#  Gradio界面（已更新）
+# ─────────────────────────────────────────
 with gr.Blocks() as demo:
-    gr.Markdown('''
-    # OpenAI/Anthropic/Gemini/Azure/Mistral/Replicate/AWS Claude/OpenRouter/Vertex AI(GCP Anthropic)/Groq/NovelAI/ElevenLabs/xAI/Stability/Deepseek API Key Status Checker
-    
-    *(Based on shaocongma, CncAnon1, su, Drago, kingbased key checkers)*
-    AWS credential's format: AWS_ACCESS_KEY_ID:AWS_SECRET_ACCESS_KEY (root might not be accurate)
-    
-    Azure endpoint's format: YOUR_RESOURCE_NAME:YOUR_API_KEY or (https://)YOUR_RESOURCE_NAME.openai.azure.com;YOUR_API_KEY
-    
-    GCP format: PROJECT_ID:CLIENT_EMAIL:PRIVATE_KEY (including \\n)
-     | or refresh token: PROJECT_ID:CLIENT_ID:CLIENT_SECRET:REFRESH_TOKEN
-    ''')
+    gr.Markdown(
+        """
+# 多API密钥状态检查器（Gemini增强版）
+*（基于shaocongma、CncAnon1、su、Drago、kingbased密钥检查器）*
+检查各种API密钥的状态和详细信息，包括OpenAI、Anthropic、Gemini、Azure、Mistral、Replicate、AWS Claude、OpenRouter、Vertex AI（GCP Anthropic）、Groq、NovelAI、ElevenLabs、xAI、Stability AI和DeepSeek。
+**密钥格式：**
+*   **AWS:** `AWS_ACCESS_KEY_ID:AWS_SECRET_ACCESS_KEY`（root可能不准确）
+*   **Azure:** `RESOURCE_NAME:API_KEY` **或** `https://RESOURCE_NAME.openai.azure.com;API_KEY`
+*   **GCP服务账号:** `PROJECT_ID:CLIENT_EMAIL:PRIVATE_KEY`（确保在密钥中包含`\\n`作为换行符）
+*   **GCP刷新令牌:** `PROJECT_ID:CLIENT_ID:CLIENT_SECRET:REFRESH_TOKEN`
+*   **其他密钥:** 供应商提供的标准格式。
+"""
+    )
+
     claude_options = [
-    'claude-3-haiku-20240307',
-    'claude-3-sonnet-20240229',
-    'claude-3-opus-20240229',
-    'claude-3-5-sonnet-20240620',
-    'claude-3-5-sonnet-20241022',
-    'claude-3-5-haiku-20241022'
+        "claude-3-haiku-20240307",
+        "claude-3-sonnet-20240229",
+        "claude-3-opus-20240229",
+        "claude-3-5-sonnet-20240620",
     ]
+
     with gr.Row():
-        with gr.Column():
-            key = gr.Textbox(lines=1, max_lines=5, label="API Key")
-            claude_model = gr.Dropdown(claude_options, value="claude-3-haiku-20240307", label="Claude API model", info="model for filter_response and concurrent check")
-            rate_limit = gr.Checkbox(label="Check concurrent rate limit (API Claude, experimental)")
+        with gr.Column(scale=1):
+            key_box = gr.Textbox(
+                lines=5,
+                max_lines=20,
+                label="API密钥（每行一个）",
+                placeholder="在此处输入API密钥，每行一个。",
+            )
+            with gr.Row():
+                 claude_model = gr.Dropdown(
+                    claude_options,
+                    value="claude-3-haiku-20240307",
+                    label="Claude模型（用于过滤/并发检查）",
+                    scale=3
+                 )
+                 rate_limit = gr.Checkbox(label="检查Claude并发限制（实验性）", scale=1)
+
             with gr.Row():
-                clear_button = gr.Button("Clear")
-                submit_button = gr.Button("Submit", variant="primary")
-        with gr.Column():
-            info = gr.JSON(label="API Key Information", open=True)
+                clear_button = gr.Button("清除所有")
+                submit_button = gr.Button("检查密钥", variant="primary")
+
+        with gr.Column(scale=2):
+            info = gr.JSON(label="API密钥信息（所有结果）", open=True)
+            # 添加Gemini专用输出框
+            gemini_keys_output = gr.Textbox(
+                label="有效的Gemini密钥",
+                info="列出确认为'有效'的Gemini密钥。",
+                lines=3,
+                max_lines=10,
+                interactive=False, # 用户不可编辑
+            )
+
+    # 点击清除按钮时重置输入框和输出框
+    clear_button.click(
+        fn=clear_inputs, # 使用修改后的函数
+        inputs=None,
+        outputs=[key_box, info, gemini_keys_output]
+    )
+
+    # 点击提交按钮时调用sort_keys函数并分配结果
+    submit_button.click(
+        fn=sort_keys,
+        inputs=[key_box, rate_limit, claude_model],
+        outputs=[info, gemini_keys_output], # 将结果映射到两个输出组件
+        api_name="sort_keys",
+    )
 
-    clear_button.click(fn=clear_inputs, inputs=[key], outputs=[key])
-    submit_button.click(fn=sort_key, inputs=[key, rate_limit, claude_model], outputs=[info], api_name="sort_key")
+# demo.launch(share=True) # 需要时激活共享链接
 demo.launch()