#!/usr/bin/env python3
"""Provider registry for hunt_all_deep.py."""

FAKES = ["xxxx", "your-", "example", "1234567890", "replace", "changeme",
         "placeholder", "sk-test", "your_api", "your-api", "<your", "<sk-",
         "sk-0000", "your-key", "demo", "sample", "test_key", "dummy",
         "aaaaaaaa", "bbbbbbbb", "sk-proj-0000", "sk-..."]


def build(ov):
    S = {}

    S["minimax"] = dict(
        queries=['"sk-cp-" minimaxi', '"sk-cp-" "MiniMax-M2"',
                 '"api.minimaxi.com" sk-', '"api.minimax.io" sk-',
                 '"minimax" "sk-cp-" extension:py',
                 '"minimax" "sk-cp-" extension:js',
                 '"minimax" "sk-cp-" extension:ts',
                 '"MINIMAX_API_KEY" extension:env',
                 '"MINIMAX_API_KEY" extension:json',
                 '"abab6.5s-chat" api_key'],
        patterns=[r"sk-cp-[A-Za-z0-9_\-]{40,140}", r"sk-[A-Za-z0-9]{48,90}\b"],
        verify=ov("https://api.minimaxi.com/v1", "/text/chatcompletion_v2",
                  ["MiniMax-M2.5", "MiniMax-M2.7", "MiniMax-M3", "abab6.5s-chat"]),
        context=["minimaxi.com", "minimax.io", "minimax", "abab6.5", "minimaxi",
                 "minimax-m2", "minimax_api"])

    S["deepseek"] = dict(
        queries=['"api.deepseek.com" sk-', '"DEEPSEEK_API_KEY" extension:env',
                 '"DEEPSEEK_API_KEY" extension:json', 'deepseek sk- extension:py',
                 '"deepseek-chat" api_key extension:py',
                 '"deepseek-reasoner" sk-'],
        patterns=[r"sk-[0-9a-fA-F]{32}\b"],
        verify=ov("https://api.deepseek.com", "/chat/completions",
                  ["deepseek-chat", "deepseek-reasoner"]),
        context=["deepseek", "deepseek-chat", "deepseek-reasoner"])

    S["kimi"] = dict(
        queries=['"api.moonshot.cn" sk-', '"MOONSHOT_API_KEY" extension:env',
                 '"MOONSHOT_API_KEY" extension:json', 'moonshot sk- extension:py',
                 '"moonshot-v1" api_key', '"kimi" "sk-" extension:env'],
        patterns=[r"sk-[A-Za-z0-9]{40,60}\b"],
        verify=ov("https://api.moonshot.cn/v1", "/chat/completions",
                  ["moonshot-v1-8k", "moonshot-v1-32k"]),
        context=["moonshot", "kimi", "api.moonshot"])

    S["siliconflow"] = dict(
        queries=['"api.siliconflow.cn" sk-', '"SILICONFLOW_API_KEY" extension:env',
                 '"SILICONFLOW_API_KEY" extension:json',
                 '"siliconflow" "sk-" extension:py',
                 '"SiliconCloud" api_key'],
        patterns=[r"sk-[A-Za-z0-9]{48}\b"],
        verify=ov("https://api.siliconflow.cn", "/v1/chat/completions",
                  ["Qwen/Qwen2.5-7B-Instruct", "deepseek-ai/DeepSeek-V3"]),
        context=["siliconflow", "siliconcloud"])

    S["zhipu_coding"] = dict(
        queries=['"open.bigmodel.cn/api/coding" sk-', '"ZHIPU_API_KEY" extension:env',
                 '"ZHIPU_API_KEY" extension:json', '"bigmodel.cn" sk- extension:py',
                 '"glm-5.2" api_key extension:json', '"glm-4" "api_key" extension:py'],
        patterns=[r"\b[0-9a-fA-F]{32}\.[A-Za-z0-9]{16}\b"],
        verify=ov("https://open.bigmodel.cn/api/coding/paas/v4", "/chat/completions",
                  ["glm-4.7-flash", "glm-4.5-flash", "glm-4-flash", "glm-5.2"]),
        context=["bigmodel", "zhipu", "glm-", "paas/v4"])

    S["zhipu_paas"] = dict(
        queries=['"open.bigmodel.cn/api/paas" sk-', '"bigmodel.cn/api/paas"',
                 '"https://open.bigmodel.cn" extension:json', 'zhipuai sk- extension:py'],
        patterns=[r"\b[0-9a-fA-F]{32}\.[A-Za-z0-9]{16}\b"],
        verify=ov("https://open.bigmodel.cn/api/paas/v4", "/chat/completions",
                  ["glm-4-flash", "glm-4.5-flash"]),
        context=["open.bigmodel.cn", "zhipuai", "bigmodel.cn"])

    S["ali_coding"] = dict(
        queries=['"coding.dashscope.aliyuncs.com" sk-', '"DASHSCOPE_API_KEY" extension:env',
                 '"DASHSCOPE_API_KEY" extension:json', '"sk-sp-" dashscope',
                 '"qwen3-coder" api_key extension:json', '"bailian" "sk-sp-"'],
        patterns=[r"sk-sp-[0-9a-fA-F]{32}\b", r"sk-[0-9a-fA-F]{32}\b"],
        verify=ov("https://coding.dashscope.aliyuncs.com/v1", "/chat/completions",
                  ["qwen3-coder-plus", "qwen-plus", "qwen3.7-max"]),
        context=["dashscope", "bailian", "aliyun", "qwen", "coding.dashscope"])

    S["dashscope"] = dict(
        queries=['"dashscope.aliyuncs.com/compatible-mode" sk-',
                 '"dashscope.aliyuncs.com" "sk-" extension:py',
                 '"DASHSCOPE_API_KEY" sk- extension:py'],
        patterns=[r"sk-[0-9a-fA-F]{32}\b"],
        verify=ov("https://dashscope.aliyuncs.com/compatible-mode/v1", "/chat/completions",
                  ["qwen-plus", "qwen-turbo", "qwen-max"]),
        context=["dashscope", "compatible-mode", "aliyun", "qwen"])

    S["volcano"] = dict(
        queries=['"ark.cn-beijing.volces.com/api/v3"', '"VOLC_ACCESSKEY" extension:env',
                 '"ARK_API_KEY" extension:env', '"ARK_API_KEY" extension:json',
                 '"volces" "sk-" extension:py', '"doubao" "api_key" extension:json',
                 '"ep-" volces extension:py'],
        patterns=[r"\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\b"],
        verify=ov("https://ark.cn-beijing.volces.com/api/v3", "/chat/completions",
                  ["doubao-seed-1-6-250615", "doubao-seed-1-6-flash-250615",
                   "doubao-1-5-lite-32k-250115", "doubao-1-5-pro-32k-250115"]),
        context=["volces", "volcengine", "ark.cn-beijing", "doubao", "火山"])

    S["longcat"] = dict(
        queries=['"api.longcat.chat" sk-', '"LONGCAT_API_KEY" extension:env',
                 '"LONGCAT_API_KEY" extension:json', '"LongCat-2.0" api_key',
                 '"longcat" "ak_" extension:py'],
        patterns=[r"ak_[A-Za-z0-9_-]{20,60}"],
        verify=ov("https://api.longcat.chat/openai/v1", "/chat/completions",
                  ["LongCat-2.0"]),
        context=["longcat", "meituan", "api.longcat"])

    S["mimo"] = dict(
        queries=['"api.xiaomimimo.com" sk-', '"MIMO_API_KEY" extension:env',
                 '"xiaomimimo" "sk-" extension:py', '"MiMo" api_key extension:json',
                 '"sk-cx-" mimo'],
        patterns=[r"sk-cx-[A-Za-z0-9]{45,55}", r"sk-cx-[A-Za-z0-9]+"],
        verify=ov("https://api.xiaomimimo.com/v1", "/chat/completions",
                  ["mimo-v2.5", "MiMo-7B"]),
        context=["mimo", "xiaomi"])

    S["qwen"] = S["dashscope"]  # alias captured under dashscope queries too

    S["iflytek"] = dict(
        queries=['"astron-code" extension:json', '"spark-api" "APIKey" extension:json',
                 '"iflytek" "api_key" extension:py', '"xfyun" "APISecret" extension:py',
                 '"iFlytek" "APIKey" extension:env'],
        patterns=[r"\b[0-9a-fA-F]{32,40}\b"],
        verify=ov("https://maas-api.cn-huabei-1.xfyun.cn/v1", "/chat/completions",
                  ["astron-code-latest", "generalv3.5"]),
        context=["iflytek", "xfyun", "spark", "xunfei", "astron", "讯飞"])

    S["openrouter"] = dict(
        queries=['"openrouter.ai/api" "sk-or-v1-"', '"OPENROUTER_API_KEY" extension:env',
                 '"OPENROUTER_API_KEY" extension:json', '"sk-or-v1-" extension:py',
                 '"openrouter.ai" Bearer extension:py'],
        patterns=[r"sk-or-v1-[0-9a-fA-F]{40,80}"],
        verify=ov("https://openrouter.ai/api/v1", "/chat/completions",
                  ["openai/gpt-4o-mini", "google/gemini-flash-1.5",
                   "meta-llama/llama-3.1-8b-instruct:free"]),
        context=["openrouter"])

    S["groq"] = dict(
        queries=['"api.groq.com" "gsk_"', '"GROQ_API_KEY" extension:env',
                 '"GROQ_API_KEY" extension:json', '"gsk_" extension:py',
                 '"groq" "gsk_" extension:yaml'],
        patterns=[r"gsk_[A-Za-z0-9]{40,60}"],
        verify=ov("https://api.groq.com/openai/v1", "/chat/completions",
                  ["llama-3.1-8b-instant", "llama3-8b-8192", "mixtral-8x7b-32768"]),
        context=["groq"])

    S["anthropic"] = dict(
        queries=['"api.anthropic.com" "sk-ant-"', '"ANTHROPIC_API_KEY" extension:env',
                 '"ANTHROPIC_API_KEY" extension:json', '"sk-ant-api03" extension:py',
                 '"x-api-key" "sk-ant" extension:py'],
        patterns=[r"sk-ant-[A-Za-z0-9_\-]{60,120}"],
        verify=ov("https://api.anthropic.com", "/v1/messages",
                  ["claude-3-5-haiku-20241022", "claude-haiku-4-5-20251001"],
                  extra_headers={"anthropic-version": "2023-06-01"}),
        context=["anthropic", "claude"])

    S["openai"] = dict(
        queries=['"api.openai.com" "sk-"', '"OPENAI_API_KEY" extension:env',
                 '"OPENAI_API_KEY" extension:json', '"sk-proj-" extension:py',
                 '"sk-proj-" extension:env', '"openai" "sk-" extension:yaml'],
        patterns=[r"sk-proj-[A-Za-z0-9_\-]{20,200}", r"sk-[A-Za-z0-9]{40,60}\b"],
        verify=ov("https://api.openai.com/v1", "/chat/completions",
                  ["gpt-4o-mini", "gpt-3.5-turbo"]),
        context=["openai", "gpt-"])

    S["togetherai"] = dict(
        queries=['"api.together.xyz" sk-', '"TOGETHER_API_KEY" extension:env',
                 '"TOGETHER_API_KEY" extension:json', '"together.ai" "sk-" extension:py',
                 '"togethercomputer" "sk-" extension:py'],
        patterns=[r"sk-[A-Za-z0-9]{40,80}\b"],
        verify=ov("https://api.together.xyz/v1", "/chat/completions",
                  ["meta-llama/Llama-3.3-70B-Instruct-Turbo",
                   "meta-llama/Llama-3.1-8B-Instruct-Turbo"]),
        context=["together"])

    S["mistral"] = dict(
        queries=['"api.mistral.ai" sk-', '"MISTRAL_API_KEY" extension:env',
                 '"MISTRAL_API_KEY" extension:json', '"mistralai" "sk-" extension:py',
                 '"mistral.ai" Bearer extension:py'],
        patterns=[r"sk-[A-Za-z0-9]{30,60}\b"],
        verify=ov("https://api.mistral.ai/v1", "/chat/completions",
                  ["open-mistral-nemo", "mistral-tiny", "codestral-latest"]),
        context=["mistral"])

    S["xai"] = dict(
        queries=['"api.x.ai" sk-', '"XAI_API_KEY" extension:env',
                 '"XAI_API_KEY" extension:json', '"x.ai" "sk-" extension:py',
                 '"grok" "XAI_API_KEY" extension:py'],
        patterns=[r"sk-[A-Za-z0-9]{40,60}\b"],
        verify=ov("https://api.x.ai/v1", "/chat/completions",
                  ["grok-2", "grok-beta", "grok-4.5"]),
        context=["x.ai", "xai", "grok"])

    S["google"] = dict(
        queries=['"generativelanguage.googleapis.com" AIza',
                 '"GEMINI_API_KEY" extension:env', '"GOOGLE_API_KEY" extension:json',
                 '"AIzaSy" extension:py', '"AIzaSy" extension:env'],
        patterns=[r"AIza[0-9A-Za-z_\-]{35}"],
        verify=None,  # custom: Google uses non-OpenAI path, handled in main
        context=["generativelanguage", "gemini", "googleapis"])

    S["deepinfra"] = dict(
        queries=['"api.deepinfra.com" sk-', '"DEEPINFRA_API_TOKEN" extension:env',
                 '"deepinfra" "sk-" extension:py', '"DEEPINFRA_TOKEN" extension:json'],
        patterns=[r"sk-[A-Za-z0-9]{40,60}\b"],
        verify=ov("https://api.deepinfra.com/v1/openai", "/chat/completions",
                  ["meta-llama/Meta-Llama-3.1-8B-Instruct",
                   "Qwen/Qwen2.5-72B-Instruct"]),
        context=["deepinfra"])

    S["fireworks"] = dict(
        queries=['"api.fireworks.ai" sk-', '"FIREWORKS_API_KEY" extension:env',
                 '"fireworks" "sk-" extension:py', '"FIREWORKS_API_KEY" extension:json'],
        patterns=[r"sk-[A-Za-z0-9]{40,60}\b"],
        verify=ov("https://api.fireworks.ai/inference/v1", "/chat/completions",
                  ["accounts/fireworks/models/llama-v3p1-8b-instruct"]),
        context=["fireworks"])

    S["stepfun"] = dict(
        queries=['"api.stepfun.com" sk-', '"STEPFUN_API_KEY" extension:env',
                 '"stepfun" "sk-" extension:py', '"step-1" api_key extension:json'],
        patterns=[r"sk-[A-Za-z0-9]{40,60}\b"],
        verify=ov("https://api.stepfun.com/v1", "/chat/completions",
                  ["step-3.7-flash", "step-2-16k"]),
        context=["stepfun", "阶跃"])

    S["yi"] = dict(
        queries=['"api.lingyiwanwu.com" sk-', '"LINGYI_API_KEY" extension:env',
                 '"lingyiwanwu" "sk-" extension:py', '"01-ai" "sk-" extension:py',
                 '"yi-large" api_key extension:json'],
        patterns=[r"sk-[A-Za-z0-9]{40,60}\b"],
        verify=ov("https://api.lingyiwanwu.com/v1", "/chat/completions",
                  ["yi-lightning", "yi-large"]),
        context=["lingyiwanwu", "01.ai", "零一万物"])

    S["baidu_qianfan"] = dict(
        queries=['"qianfan.baidubce.com" sk-', '"QIANFAN_ACCESS_KEY" extension:env',
                 '"qianfan" "sk-" extension:py', '"ERNIE" api_key extension:json'],
        patterns=[r"sk-[A-Za-z0-9]{30,60}\b", r"bce-v3/[A-Za-z0-9/]+=+"],
        verify=ov("https://qianfan.baidubce.com/v2", "/chat/completions",
                  ["ernie-4.0-8k-latest", "ernie-speed-128k"]),
        context=["qianfan", "baidubce", "wenxin", "ernie", "千帆"])

    # SCNet / Compshare / OpenCode / Infini use non-standard paths
    S["compshare"] = dict(
        queries=['"api.compshare.cn" sk-', '"COMPSHARE_API_KEY" extension:env',
                 '"compshare" "sk-" extension:py', '"ucloud" "sk-" extension:json'],
        patterns=[r"sk-[A-Za-z0-9_\-]{40,100}"],
        verify=ov("https://api.compshare.cn/v1", "/chat/completions",
                  ["gpt-4o-mini", "claude-3-5-haiku-20241022"]),
        context=["compshare", "ucloud"])

    S["opencode_go"] = dict(
        queries=['"opencode.ai/zen/go"', '"zen/go/v1"', '"OPENCODE_GO_API_KEY"',
                 '"OPENCODE_GO_KEY"', '"ANOMALY_API_KEY"', '"opencode-go" sk-'],
        patterns=[r"sk-[A-Za-z0-9_\-]{40,80}"],
        verify=ov("https://opencode.ai/zen/go/v1", "/chat/completions",
                  ["grok-4.5", "glm-5.2", "minimax-m3"]),
        context=["opencode", "anomaly", "zen/go"])

    S["infini"] = dict(
        queries=['"cloud.infini-ai.com" sk-', '"INFINI_API_KEY" extension:env',
                 '"infini-ai" "sk-" extension:py', '"INFINI_API_KEY" extension:json'],
        patterns=[r"sk-[A-Za-z0-9]{40,60}\b"],
        verify=ov("https://cloud.infini-ai.com/maas/v1", "/chat/completions",
                  ["deepseek-v3", "qwen2.5-72b-instruct"]),
        context=["infini"])

    S["scnet"] = dict(
        queries=['"scnet.cn" "sk-sp-"', '"SCNET_API_KEY" extension:env',
                 '"scnet" "sk-tp-" extension:py', '"scnet" "sk-sp-" extension:json'],
        patterns=[r"sk-sp-[A-Za-z0-9]{40,80}", r"sk-tp-[A-Za-z0-9]{40,80}"],
        verify=ov("https://api.scnet.cn/v1", "/chat/completions",
                  ["qwen-max", "deepseek-v3"]),
        context=["scnet"])

    # ── 2026-08-03 batch: newly confirmed OpenAI-compatible CN platforms ──
    S["360zhinao"] = dict(
        queries=['"api.360.cn" sk-', '"api.360.cn/v1"',
                 '"QH360_API_KEY" extension:env', '"360GPT_API_KEY" extension:env',
                 '"ZHINAO_API_KEY" extension:env', '"360AI_API_KEY" extension:env',
                 '"360gpt" "sk-" extension:py', '"360gpt" "sk-" extension:js',
                 '"360智脑" sk- extension:py', '"360 zhinao" api_key',
                 '"360gpt-pro" api_key', '"360gpt-turbo" api_key',
                 '"api.360.cn" extension:json', '"360.cn/v1/chat/completions"',
                 '"QH360_API_KEY" extension:json', '"360CHAT_API_KEY"'],
        patterns=[r"sk-[A-Za-z0-9]{32,64}\b"],
        verify=ov("https://api.360.cn/v1", "/chat/completions",
                  ["360gpt-pro", "360gpt-turbo", "360gpt2-pro"]),
        context=["360.cn", "360gpt", "zhinao", "智脑", "qh360", "360ai"])

    S["tencent_lkeap"] = dict(
        queries=['"api.lkeap.cloud.tencent.com"', '"lkeap.cloud.tencent.com" sk-',
                 '"LKEAP_API_KEY" extension:env', '"TENCENT_LKEAP" extension:env',
                 '"lkeap" "sk-" extension:py', '"lkeap" "sk-" extension:js',
                 '"hunyuan-code" api_key', '"hunyuan-coding" api_key',
                 '"lkeap.cloud.tencent.com/v1"', '"deepseek-v3" "lkeap"',
                 '"hunyuan-turbo" "api_key" tencent',
                 '"api.lkeap" extension:json', '"LKEAP_SECRET" extension:env'],
        patterns=[r"sk-[A-Za-z0-9]{32,64}\b"],
        verify=ov("https://api.lkeap.cloud.tencent.com/v1", "/chat/completions",
                  ["hunyuan-turbo", "hunyuan-code-latest",
                   "deepseek-v3", "glm-4.7"]),
        context=["lkeap", "tencent.com", "hunyuan-code", "腾讯元器", "知识引擎"])

    S["iflytek_maas"] = dict(
        queries=['"maas-api.cn-huabei-1.xf-yun.com"',
                 '"maas-api" "xf-yun" sk-',
                 '"IFLYTEK_MAAS_API_KEY" extension:env',
                 '"MAAS_API_KEY" "xf-yun" extension:env',
                 '"xf-yun.com/v1" extension:json',
                 '"iflytek-maas" sk- extension:py',
                 '"讯飞" "maas-api" api_key',
                 '"generalv3.5" "api_key" xfyun',
                 '"maas-api.xf-yun" extension:py',
                 '"4.0Ultra" "xf-yun" api_key'],
        patterns=[r"sk-[A-Za-z0-9]{32,64}\b",
                  r"\b[A-Za-z0-9]{32,48}\b"],
        verify=ov("https://maas-api.cn-huabei-1.xf-yun.com/v1",
                  "/chat/completions",
                  ["xop3qwen1b7", "xopglm5", "xopkimik26",
                   "xsparkx2flash", "xsparkx2",
                   "generalv3.5", "4.0Ultra", "generalv3"]),
        context=["maas-api", "xf-yun", "xfyun", "iflytek", "讯飞", "spark-api"])

    S["sensenova"] = dict(
        queries=['"api.sensenova.cn"', '"sensenova" "sk-" extension:py',
                 '"SENSENOVA_API_KEY" extension:env',
                 '"SENSENOVA_API_KEY" extension:json',
                 '"SenseNova" api_key extension:js',
                 '"sensenova.cn/v1" extension:json',
                 '"商汤" "sensenova" api_key', '"sensechat" api_key extension:py',
                 '"sensenova" "Bearer" extension:py',
                 '"SENSECHAT_API_KEY" extension:env',
                 '"sensenova" "ACCESS_KEY" extension:env',
                 '"api.sensenova.cn/compatible-mode"'],
        patterns=[r"sk-[A-Za-z0-9]{32,64}\b",
                  r"\b[A-Za-z0-9]{32,48}\b"],
        verify=ov("https://api.sensenova.cn/compatible-mode/v1",
                  "/chat/completions",
                  ["SenseChat-5", "SenseChat-Turbo",
                   "deepseek-v3", "glm-4.7"]),
        context=["sensenova", "sensechat", "sensetime", "商汤", "日日新"])

    # Tencent Hunyuan — OpenAI-compatible endpoint (distinct from LKEAP)
    S["tencent_hunyuan"] = dict(
        queries=['"api.hunyuan.cloud.tencent.com"',
                 '"hunyuan.cloud.tencent.com" sk-',
                 '"HUNYUAN_API_KEY" extension:env',
                 '"HUNYUAN_API_KEY" extension:json',
                 '"hunyuan" "sk-" extension:py',
                 '"hunyuan-turbos-latest" api_key',
                 '"hunyuan-turbo" api_key extension:json',
                 '"hunyuan-code" "api_key" tencent',
                 '"hunyuan.cloud.tencent.com/v1"'],
        patterns=[r"sk-[A-Za-z0-9]{32,64}\b"],
        verify=ov("https://api.hunyuan.cloud.tencent.com/v1", "/chat/completions",
                  ["hunyuan-turbos-latest", "hunyuan-turbo",
                   "hunyuan-standard", "hunyuan-code-latest"]),
        context=["hunyuan.cloud.tencent", "hunyuan", "腾讯混元"])

    # DMXAPI — one_api-style relay (popular CN aggregator)
    S["dmxapi"] = dict(
        queries=['"www.dmxapi.cn" sk-', '"dmxapi.cn" "sk-" extension:py',
                 '"dmxapi" "DMXAPI_API_KEY" extension:env',
                 '"DMX_API_KEY" extension:env', '"dmxapi.cn/v1" extension:json',
                 '"dmxapi" "Bearer" extension:py', '"dmxapi.cn" extension:js'],
        patterns=[r"sk-[A-Za-z0-9]{32,80}\b"],
        verify=ov("https://www.dmxapi.cn/v1", "/chat/completions",
                  ["gpt-4o-mini", "gpt-3.5-turbo", "claude-3-5-haiku-20241022",
                   "deepseek-chat", "glm-4-flash"]),
        context=["dmxapi", "dmxapi.cn"])

    # CloseAI / CloseAI-Asia relay
    S["closeai"] = dict(
        queries=['"api.closeai-asia.com"', '"closeai-asia" sk- extension:py',
                 '"closeai-asia" extension:env', '"CLOSEAI_API_KEY" extension:env',
                 '"closeai-asia.com/v1" extension:json',
                 '"closeai" "Bearer" extension:js',
                 '"api.closeai-proxy.com" sk-'],
        patterns=[r"sk-[A-Za-z0-9]{32,80}\b"],
        verify=ov("https://api.closeai-asia.com/v1", "/chat/completions",
                  ["gpt-4o-mini", "gpt-3.5-turbo", "claude-3-5-haiku-20241022"]),
        context=["closeai-asia", "closeai-proxy", "closeai"])

    # API2D (oa.api2d.net) — Chinese OpenAI/Anthropic relay
    S["api2d"] = dict(
        queries=['"oa.api2d.net" sk-', '"api2d.net" "sk-" extension:py',
                 '"API2D_API_KEY" extension:env', '"API2D_KEY" extension:env',
                 '"api2d.net/v1" extension:json', '"api2d" "Bearer" extension:js',
                 '"fk" "api2d" extension:py', '"api2d" extension:env',
                 '"oa.api2d.net" extension:json'],
        patterns=[r"sk-[A-Za-z0-9]{32,80}\b", r"fk[A-Za-z0-9]{30,80}\b"],
        verify=ov("https://oa.api2d.net/v1", "/chat/completions",
                  ["gpt-4o-mini", "gpt-3.5-turbo", "claude-3-5-haiku-20241022"]),
        context=["api2d", "oa.api2d.net"])

    # AIHubMix — international+CN model aggregator
    S["aihubmix"] = dict(
        queries=['"aihubmix.com" sk-', '"aihubmix" "sk-" extension:py',
                 '"AIHUBMIX_API_KEY" extension:env', '"AIHUBMIX_KEY" extension:env',
                 '"aihubmix.com/v1" extension:json',
                 '"aihubmix" "Bearer" extension:js',
                 '"aihubmix" extension:env', '"api.aihubmix.com" sk-'],
        patterns=[r"sk-[A-Za-z0-9]{32,80}\b"],
        verify=ov("https://aihubmix.com/v1", "/chat/completions",
                  ["gpt-4o-mini", "gpt-3.5-turbo", "claude-3-5-haiku-20241022",
                   "deepseek-chat", "glm-4-flash"]),
        context=["aihubmix"])

    for spec in S.values():
        spec["fakes"] = FAKES
    return S