api-key-manager 2.1.0__py3-none-any.whl

key_manager/parser.py

@@ -0,0 +1,153 @@
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+
+def load_keys_file(path: str) -> dict:
+    keys_path = Path(path)
+    if keys_path.exists():
+        with open(keys_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    return {
+        "version": "1.0",
+        "updated_at": datetime.utcnow().isoformat() + "Z",
+        "imports": [],
+        "keys": {}
+    }
+
+
+def save_keys_file(data: dict, path: str):
+    data["updated_at"] = datetime.utcnow().isoformat() + "Z"
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2, ensure_ascii=False)
+
+
+def mask_key(key: str) -> str:
+    if len(key) <= 10:
+        return key
+    return f"{key[:6]}...{key[-4:]}"
+
+
+def extract_batch_from_filename(filename: str) -> str:
+    import re
+    match = re.search(r"(\d{4}-\d{2}-\d{2})", filename)
+    if match:
+        return match.group(1)
+    return datetime.now().strftime("%Y-%m-%d")
+
+
+def validate_import_path(path: str, allowed_dirs: list[str]) -> Path:
+    """Validate path is within allowed directories. Raises ValidationError if not."""
+    from key_manager.errors import ErrorCode, ValidationError
+    resolved = Path(path).resolve()
+    for allowed in allowed_dirs:
+        allowed_resolved = Path(allowed).resolve()
+        try:
+            resolved.relative_to(allowed_resolved)
+            return resolved
+        except ValueError:
+            continue
+    raise ValidationError(
+        code=ErrorCode.VALIDATION_FILE_NOT_FOUND,
+        message="Path outside allowed directories"
+    )
+
+
+def import_keys(file_path: Optional[str] = None,
+                directory: Optional[str] = None,
+                batch: Optional[str] = None,
+                keys_file: str = "./data/keys.json") -> tuple[int, int, list[str]]:
+    errors = []
+    new_keys = 0
+    duplicates = 0
+
+    data = load_keys_file(keys_file)
+    files_to_process = []
+
+    if file_path:
+        p = Path(file_path)
+        if p.exists() and p.suffix == ".json":
+            files_to_process.append(p)
+        else:
+            errors.append(f"File not found or not JSON: {file_path}")
+            return new_keys, duplicates, errors
+    elif directory:
+        d = Path(directory)
+        if d.exists():
+            files_to_process.extend(d.glob("*.json"))
+        else:
+            errors.append(f"Directory not found: {directory}")
+            return new_keys, duplicates, errors
+    else:
+        errors.append("No file or directory specified")
+        return new_keys, duplicates, errors
+
+    for fp in files_to_process:
+        try:
+            with open(fp, "r", encoding="utf-8") as f:
+                items = json.load(f)
+
+            if not isinstance(items, list):
+                errors.append(f"{fp.name}: not a JSON array")
+                continue
+
+            file_batch = batch or extract_batch_from_filename(fp.name)
+            import_record = {
+                "file": fp.name,
+                "batch": file_batch,
+                "imported_at": datetime.utcnow().isoformat() + "Z",
+                "key_count": len(items),
+                "new_keys": 0,
+                "duplicates": 0
+            }
+
+            for item in items:
+                if not isinstance(item, dict) or "key" not in item:
+                    continue
+
+                key = item["key"]
+                if key in data["keys"]:
+                    data["keys"][key]["sources"].append({
+                        "file": item.get("file_path", ""),
+                        "batch": file_batch,
+                        "imported_at": datetime.utcnow().isoformat() + "Z",
+                        "original_path": item.get("file_path", ""),
+                        "repo": item.get("repo_name", ""),
+                        "repo_url": item.get("repo_url", ""),
+                        "found_at": item.get("found_at", "")
+                    })
+                    duplicates += 1
+                    import_record["duplicates"] += 1
+                else:
+                    data["keys"][key] = {
+                        "key_masked": mask_key(key),
+                        "provider": item.get("provider", "unknown"),
+                        "provider_detected": None,
+                        "status": "unknown",
+                        "sources": [{
+                            "file": item.get("file_path", ""),
+                            "batch": file_batch,
+                            "imported_at": datetime.utcnow().isoformat() + "Z",
+                            "original_path": item.get("file_path", ""),
+                            "repo": item.get("repo_name", ""),
+                            "repo_url": item.get("repo_url", ""),
+                            "found_at": item.get("found_at", "")
+                        }],
+                        "checks": [],
+                        "tests": {},
+                        "first_seen": datetime.utcnow().isoformat() + "Z",
+                        "last_checked": None,
+                        "last_tested": None,
+                        "created_at": datetime.utcnow().isoformat() + "Z"
+                    }
+                    new_keys += 1
+                    import_record["new_keys"] += 1
+
+            data["imports"].append(import_record)
+            save_keys_file(data, keys_file)
+
+        except Exception as e:
+            errors.append(f"{fp.name}: {str(e)}")
+
+    return new_keys, duplicates, errors

key_manager/providers/__init__.py

@@ -0,0 +1,283 @@
+from .base import ProviderBase, CheckResult, TestResult
+from .openai import OpenAIProvider
+from .anthropic import AnthropicProvider
+from .google import GoogleProvider
+from .grok import GrokProvider
+from .deepseek import DeepSeekProvider
+from .groq import GroqProvider
+from .perplexity import PerplexityProvider
+from .together import TogetherProvider
+from .mistral import MistralProvider
+from .cohere import CohereProvider
+from .replicate import ReplicateProvider
+from .huggingface import HuggingFaceProvider
+from .fireworks import FireworksProvider
+from .openrouter import OpenRouterProvider
+from .dashscope import DashScopeProvider
+from .modelscope import ModelScopeProvider
+from .zhipu import ZhipuProvider
+from .kimi import KimiProvider
+from .minimax import MiniMaxProvider
+from .minimax_plan import MiniMaxTokenPlanProvider
+from .siliconflow import SiliconFlowProvider
+from .baichuan import BaichuanProvider
+from .yi import YiProvider
+from .cerebras import CerebrasProvider
+from .nvidia import NvidiaProvider
+from .hyperbolic import HyperbolicProvider
+from .poe import PoeProvider
+from .longcat import LongCatProvider
+from .mimo import MiMoProvider
+from .mimo_plan import MiMoPlanProvider
+from .stepfun import StepFunProvider
+from .doubao import DoubaoProvider
+from .infini import InfiniProvider
+from .zai import ZAIProvider
+from .ai302 import AI302Provider
+from .ppio import PPIOProvider
+from .dmxapi import DMXAPIProvider
+from .ocoolai import OCoolAIProvider
+from .dashscope_coding import DashScopeCodingProvider
+from .tencent_hunyuan import TencentHunyuanProvider
+from .cstcloud import CSTCloudProvider
+from .zhipu_coding import ZhipuCodingProvider
+from .kimi_coding import KimiCodingProvider
+from .infini_coding import InfiniCodingProvider
+
+# Provider registry
+PROVIDERS: dict[str, ProviderBase] = {
+    "openai": OpenAIProvider(),
+    "anthropic": AnthropicProvider(),
+    "google": GoogleProvider(),
+    "grok": GrokProvider(),
+    "deepseek": DeepSeekProvider(),
+    "groq": GroqProvider(),
+    "perplexity": PerplexityProvider(),
+    "together": TogetherProvider(),
+    "mistral": MistralProvider(),
+    "cohere": CohereProvider(),
+    "replicate": ReplicateProvider(),
+    "huggingface": HuggingFaceProvider(),
+    "fireworks": FireworksProvider(),
+    "openrouter": OpenRouterProvider(),
+    "dashscope": DashScopeProvider(),
+    "modelscope": ModelScopeProvider(),
+    "zhipu": ZhipuProvider(),
+    "kimi": KimiProvider(),
+    "minimax": MiniMaxProvider(),
+    "minimax-plan": MiniMaxTokenPlanProvider(),
+    "siliconflow": SiliconFlowProvider(),
+    "baichuan": BaichuanProvider(),
+    "yi": YiProvider(),
+    "cerebras": CerebrasProvider(),
+    "nvidia": NvidiaProvider(),
+    "hyperbolic": HyperbolicProvider(),
+    "poe": PoeProvider(),
+    "longcat": LongCatProvider(),
+    "mimo": MiMoProvider(),
+    "mimo-plan": MiMoPlanProvider(),
+    "stepfun": StepFunProvider(),
+    "doubao": DoubaoProvider(),
+    "infini": InfiniProvider(),
+    "zai": ZAIProvider(),
+    "ai302": AI302Provider(),
+    "ppio": PPIOProvider(),
+    "dmxapi": DMXAPIProvider(),
+    "ocoolai": OCoolAIProvider(),
+    "dashscope-coding": DashScopeCodingProvider(),
+    "tencent-hunyuan": TencentHunyuanProvider(),
+    "cstcloud": CSTCloudProvider(),
+    "zhipu-coding": ZhipuCodingProvider(),
+    "kimi-coding": KimiCodingProvider(),
+    "infini-coding": InfiniCodingProvider(),
+}
+
+# Key prefix to provider mapping (for auto-detection)
+# Key prefix to provider mapping (for auto-detection)
+# Ordered by specificity (longer prefixes first)
+KEY_PREFIX_MAP: dict[str, list[str]] = {
+    # AI Providers - unique prefixes
+    "sk-ant-api03-": ["anthropic"],
+    "sk-or-v1-": ["openrouter"],
+    "sk-proj-": ["openai"],
+    "sk-sp-": ["dashscope"],
+    "ms-": ["modelscope"],
+    "AIza": ["google"],
+    "xai-": ["grok"],
+    "hf_": ["huggingface"],
+    "r8_": ["replicate"],
+    "pplx-": ["perplexity"],
+    "gsk_": ["groq"],
+    "fw_": ["fireworks"],
+    "poe-": ["poe"],
+    "AKID": ["cstcloud"],
+    # Generic sk- prefix (must be last - shared by multiple providers)
+    # Excluded: ppio, nvidia, modelscope, ai21 - their /models endpoints don't validate keys
+    "sk-": ["openai", "deepseek", "together", "fireworks", "perplexity", "dashscope", "kimi", "siliconflow", "cerebras", "hyperbolic", "mimo", "stepfun", "infini", "zai", "ai302", "dmxapi", "ocoolai", "dashscope-coding", "tencent-hunyuan"],
+    # MiniMax Token Plan keys
+    "sk-cp-": ["minimax-plan", "infini-coding"],
+    # Kimi Coding Plan keys
+    "sk-kimi-": ["kimi-coding"],
+    # MiMo Token Plan keys
+    "tp-": ["mimo-plan"],
+}
+
+# Display names for UI (maps internal provider name → human-readable name)
+DISPLAY_NAMES: dict[str, str] = {
+    "openai": "OpenAI",
+    "anthropic": "Anthropic",
+    "google": "Google Gemini",
+    "deepseek": "DeepSeek",
+    "groq": "Groq",
+    "grok": "Grok (xAI)",
+    "perplexity": "Perplexity",
+    "together": "Together AI",
+    "mistral": "Mistral",
+    "cohere": "Cohere",
+    "replicate": "Replicate",
+    "huggingface": "Hugging Face",
+    "fireworks": "Fireworks",
+    "openrouter": "OpenRouter",
+    "dashscope": "阿里百炼",
+    "dashscope-coding": "阿里百炼编程",
+    "modelscope": "魔搭 ModelScope",
+    "zhipu": "智谱 GLM",
+    "kimi": "Kimi (月之暗面)",
+    "minimax": "MiniMax",
+    "minimax-plan": "MiniMax 计划版",
+    "siliconflow": "硅基流动",
+    "baichuan": "百川",
+    "yi": "零一万物",
+    "cerebras": "Cerebras",
+    "nvidia": "NVIDIA",
+    "hyperbolic": "Hyperbolic",
+    "poe": "Poe",
+    "longcat": "LongCat",
+    "mimo": "MiMo",
+    "mimo-plan": "MiMo 计划版",
+    "stepfun": "阶跃星辰",
+    "doubao": "豆包 (字节)",
+    "infini": "无问芯穹",
+    "zai": "ZAI",
+    "ai302": "AI302",
+    "ppio": "PPIO",
+    "dmxapi": "DMXAPI",
+    "ocoolai": "OCoolAI",
+    "tencent-hunyuan": "腾讯混元",
+    "zhipu-coding": "智谱 GLM 编程版",
+    "kimi-coding": "Kimi 编程版",
+    "infini-coding": "无问芯穹 编程版",
+    "cstcloud": "中算云",
+}
+
+
+def get_display_name(provider_name: str) -> str:
+    """Get human-readable display name for a provider."""
+    return DISPLAY_NAMES.get(provider_name, provider_name)
+
+
+# Error body signatures for provider detection when keys are invalid.
+# Each provider maps to a list of lowercase substrings found in their error responses.
+PROVIDER_ERROR_SIGNATURES: dict[str, list[str]] = {
+    # ═══ 国内服务商 ═══
+    "dashscope": ["aliyun", "model-studio", "modelstudio", "apikey-error"],
+    "dashscope-coding": ["aliyun", "model-studio", "modelstudio"],
+    "tencent-hunyuan": ["hunyuan", "console.cloud.tencent.com"],
+    "baichuan": ["baichuan-ai.com", "platform.baichuan-ai.com"],
+    "minimax": ["authorized_error", "login fail"],
+    "minimax-plan": ["authorized_error", "login fail"],
+    "yi": ["illegal apikey"],
+    "kimi": ["invalid_authentication_error"],
+    "kimi-coding": ["invalid_authentication_error", "the api key appears to be invalid"],
+    "siliconflow": ["api key is invalid"],
+    "stepfun": ["incorrect api key provided", "invalid_api_key"],
+    "doubao": ["authenticationerror"],
+    "infini": ["请使用正确的api key进行请求"],
+    "infini-coding": ["请使用正确的api key进行请求"],
+    "zhipu": ["令牌已过期或验证不正确"],
+    "zhipu-coding": ["令牌已过期或验证不正确"],
+    "mimo": ["invalid api key", "please provide valid api key"],
+    "mimo-plan": ["invalid api key", "please provide valid api key"],
+    "cstcloud": ["cstcloud", "zhongsuanyun"],
+    "modelscope": ["modelscope"],
+    "longcat": ["longcat"],
+    "ppio": ["ppio"],
+    # ═══ 国外服务商 ═══
+    "deepseek": ["authentication fails"],
+    "anthropic": ["request not allowed", "anthropic", "x-api-key"],
+    "openrouter": ["missing authentication header"],
+    "together": [],
+    "mistral": ["mistral", "la plateforme"],
+    "cohere": [],
+    "replicate": ["unauthenticated", "you did not pass a valid authentication token"],
+    "huggingface": ["huggingface", "hf_"],
+    "fireworks": ["fireworks", "accounts/fireworks"],
+    "perplexity": ["perplexity"],
+    # grok: 实际返回 "Incorrect API key provided: sk***45...console.x.ai."
+    "grok": ["console.x.ai"],
+    "cerebras": ["cerebras"],
+    "nvidia": ["nvidia", "nim.api"],
+    "hyperbolic": ["could not validate credentials"],
+    "poe": ["poe.com"],
+    "ai302": ["302.ai"],
+    "dmxapi": ["rix_api_error"],
+    "ocoolai": ["shell_api_error"],
+    "zai": ["token expired or incorrect"],
+    # openai: 实际返回 "Incorrect API key provided: sk-inval...platform.openai.com..."
+    "openai": ["platform.openai.com"],
+    "google": ["generativelanguage"],
+    # grok: 实际返回 "Incorrect API key provided: sk***45...console.x.ai."
+    "groq": ["groq"],
+}
+
+
+
+
+# Provider website and documentation URLs
+PROVIDER_WEBSITES: dict[str, dict[str, str]] = {
+    "openai": {"name": "OpenAI", "url": "https://platform.openai.com", "docs": "https://platform.openai.com/docs"},
+    "anthropic": {"name": "Anthropic", "url": "https://console.anthropic.com", "docs": "https://docs.anthropic.com"},
+    "google": {"name": "Google AI", "url": "https://aistudio.google.com", "docs": "https://ai.google.dev/docs"},
+    "deepseek": {"name": "DeepSeek", "url": "https://platform.deepseek.com", "docs": "https://platform.deepseek.com/api-docs"},
+    "groq": {"name": "Groq", "url": "https://console.groq.com", "docs": "https://docs.groq.com"},
+    "mistral": {"name": "Mistral AI", "url": "https://console.mistral.ai", "docs": "https://docs.mistral.ai"},
+    "cohere": {"name": "Cohere", "url": "https://dashboard.cohere.com", "docs": "https://docs.cohere.com"},
+    "replicate": {"name": "Replicate", "url": "https://replicate.com", "docs": "https://replicate.com/docs"},
+    "huggingface": {"name": "Hugging Face", "url": "https://huggingface.co", "docs": "https://huggingface.co/docs"},
+    "fireworks": {"name": "Fireworks AI", "url": "https://fireworks.ai", "docs": "https://docs.fireworks.ai"},
+    "perplexity": {"name": "Perplexity", "url": "https://perplexity.ai", "docs": "https://docs.perplexity.ai"},
+    "together": {"name": "Together AI", "url": "https://api.together.xyz", "docs": "https://docs.together.ai"},
+    "openrouter": {"name": "OpenRouter", "url": "https://openrouter.ai", "docs": "https://openrouter.ai/docs"},
+    "dashscope": {"name": "阿里百炼", "url": "https://dashscope.aliyun.com", "docs": "https://help.aliyun.com/zh/dashscope/"},
+    "zhipu": {"name": "智谱 AI", "url": "https://open.bigmodel.cn", "docs": "https://open.bigmodel.cn/dev/api"},
+    "kimi": {"name": "Kimi", "url": "https://platform.moonshot.cn", "docs": "https://platform.moonshot.cn/docs"},
+    "minimax": {"name": "MiniMax", "url": "https://platform.minimaxi.com", "docs": "https://platform.minimaxi.com/document"},
+    "siliconflow": {"name": "硅基流动", "url": "https://siliconflow.cn", "docs": "https://docs.siliconflow.cn"},
+    "baichuan": {"name": "百川智能", "url": "https://platform.baichuan-ai.com", "docs": "https://platform.baichuan-ai.com/docs"},
+    "yi": {"name": "零一万物", "url": "https://platform.lingyiwanwu.com", "docs": "https://platform.lingyiwanwu.com/docs"},
+    "cerebras": {"name": "Cerebras", "url": "https://cerebras.ai", "docs": "https://docs.cerebras.ai"},
+    "nvidia": {"name": "NVIDIA", "url": "https://build.nvidia.com", "docs": "https://docs.api.nvidia.com"},
+    "grok": {"name": "Grok (xAI)", "url": "https://console.x.ai", "docs": "https://docs.x.ai"},
+    "poe": {"name": "Poe", "url": "https://poe.com", "docs": "https://developer.poe.com"},
+    "stepfun": {"name": "阶跃星辰", "url": "https://platform.stepfun.com", "docs": "https://platform.stepfun.com/docs"},
+    "doubao": {"name": "豆包", "url": "https://console.volcengine.com/ark", "docs": "https://www.volcengine.com/docs/82379"},
+    "infini": {"name": "无问芯穹", "url": "https://cloud.infini-ai.com", "docs": "https://docs.infini-ai.com"},
+    "mimo": {"name": "MiMo", "url": "https://mimo.xiaomi.com", "docs": "https://mimo.xiaomi.com/docs"},
+    "hyperbolic": {"name": "Hyperbolic", "url": "https://hyperbolic.xyz", "docs": "https://docs.hyperbolic.xyz"},
+    "modelscope": {"name": "魔搭", "url": "https://modelscope.cn", "docs": "https://modelscope.cn/docs"},
+    "ppio": {"name": "PPIO", "url": "https://ppinfra.com", "docs": "https://docs.ppinfra.com"},
+    "dmxapi": {"name": "DMXAPI", "url": "https://www.dmxapi.cn", "docs": "https://www.dmxapi.cn/docs"},
+    "ocoolai": {"name": "OCoolAI", "url": "https://ocoolai.com", "docs": "https://ocoolai.com/docs"},
+    "ai302": {"name": "AI302", "url": "https://302.ai", "docs": "https://302.ai/docs"},
+    "zai": {"name": "ZAI", "url": "https://zai.ai", "docs": "https://zai.ai/docs"},
+    "longcat": {"name": "LongCat", "url": "https://longcat.com", "docs": "https://longcat.com/docs"},
+    "tencent-hunyuan": {"name": "腾讯混元", "url": "https://cloud.tencent.com/product/hunyuan", "docs": "https://cloud.tencent.com/document/product/1729"},
+    "cstcloud": {"name": "中算云", "url": "https://www.cstcloud.com", "docs": "https://www.cstcloud.com/docs"},
+    "dashscope-coding": {"name": "阿里百炼编程", "url": "https://dashscope.aliyun.com", "docs": "https://help.aliyun.com/zh/dashscope/"},
+    "mimo-plan": {"name": "MiMo 计划版", "url": "https://mimo.xiaomi.com", "docs": "https://mimo.xiaomi.com/docs"},
+    "minimax-plan": {"name": "MiniMax 计划版", "url": "https://platform.minimaxi.com", "docs": "https://platform.minimaxi.com/document"},
+    "zhipu-coding": {"name": "智谱 GLM 编程版", "url": "https://open.bigmodel.cn", "docs": "https://open.bigmodel.cn/dev/api"},
+    "kimi-coding": {"name": "Kimi 编程版", "url": "https://platform.moonshot.cn", "docs": "https://platform.moonshot.cn/docs"},
+    "infini-coding": {"name": "无问芯穹 编程版", "url": "https://cloud.infini-ai.com", "docs": "https://docs.infini-ai.com"},
+}
+

key_manager/providers/ai302.py

@@ -0,0 +1,109 @@
+import asyncio
+import time
+from .base import ProviderBase, CheckResult, TestResult
+
+
+class AI302Provider(ProviderBase):
+    name = "ai302"
+    base_url = "https://api.302.ai/v1"
+    check_endpoint = "/models"
+
+    def build_headers(self, key: str) -> dict:
+        return {"Authorization": f"Bearer {key}"}
+
+    async def get_models(self, client, key: str) -> list[str]:
+        headers = self.build_headers(key)
+        try:
+            resp = await client.get(
+                f"{self.get_base_url()}{self.check_endpoint}",
+                headers=headers
+            )
+            if resp.status_code == 200:
+                data = resp.json()
+                if "data" in data:
+                    return [m["id"] for m in data["data"] if "id" in m]
+            return []
+        except Exception:
+            return []
+
+    async def check(self, client, key: str) -> CheckResult:
+        """Real usage test - try to make a minimal chat completion request."""
+        headers = self.build_headers(key)
+        headers["Content-Type"] = "application/json"
+        start = time.monotonic()
+        try:
+            resp = await client.post(
+                f"{self.get_base_url()}/chat/completions",
+                headers=headers,
+                json={
+                    "model": "gpt-4o-mini",
+                    "messages": [{"role": "user", "content": "hi"}],
+                    "max_tokens": 5
+                }
+            )
+            latency = (time.monotonic() - start) * 1000
+
+            if resp.status_code == 200:
+                return CheckResult(True, 200, latency, None)
+            elif resp.status_code in (401, 403):
+                return CheckResult(False, resp.status_code, latency, "invalid key or forbidden")
+            elif resp.status_code == 429:
+                return CheckResult(False, 429, latency, "rate limited")
+            else:
+                try:
+                    data = resp.json()
+                    error_msg = data.get("error", {}).get("message", f"status {resp.status_code}")
+                except:
+                    error_msg = f"status {resp.status_code}"
+                return CheckResult(False, resp.status_code, latency, error_msg)
+        except Exception as e:
+            return CheckResult(False, None, (time.monotonic() - start) * 1000, str(e))
+
+    async def test_token_limit(self, client, key: str, token_steps: list[int]) -> TestResult:
+        headers = self.build_headers(key)
+        last_success = None
+        for step in token_steps:
+            try:
+                resp = await client.post(
+                    f"{self.get_base_url()}/chat/completions",
+                    headers=headers,
+                    json={
+                        "model": "gpt-4o-mini",
+                        "messages": [{"role": "user", "content": "hi"}],
+                        "max_tokens": step
+                    }
+                )
+                if resp.status_code == 200:
+                    last_success = step
+                elif resp.status_code in (400, 413):
+                    break
+                elif resp.status_code == 429:
+                    await asyncio.sleep(1)
+                    continue
+                else:
+                    break
+            except Exception:
+                break
+        return TestResult(max_tokens=last_success)
+
+
+    async def check_real(self, client, key: str) -> CheckResult:
+        return await self.check(client, key)
+    async def test_concurrency(self, client, key: str, concurrency_steps: list[int]) -> TestResult:
+        headers = self.build_headers(key)
+        last_success = None
+        for step in concurrency_steps:
+            tasks = [self._probe(client, headers) for _ in range(step)]
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+            rate_limited = sum(1 for r in results if not isinstance(r, Exception) and not r)
+            if rate_limited / step >= 0.3:
+                break
+            last_success = step
+        return TestResult(max_concurrency=last_success)
+
+    async def _probe(self, client, headers) -> bool:
+        try:
+            resp = await client.get(f"{self.get_base_url()}{self.check_endpoint}", headers=headers)
+            return resp.status_code == 200
+        except Exception:
+            return False

key_manager/providers/anthropic.py

@@ -0,0 +1,109 @@
+import asyncio
+import time
+from .base import ProviderBase, CheckResult, TestResult
+
+
+class AnthropicProvider(ProviderBase):
+    name = "anthropic"
+    base_url = "https://api.anthropic.com"
+    check_endpoint = "/v1/models"
+
+    def build_headers(self, key: str) -> dict:
+        return {
+            "x-api-key": key,
+            "anthropic-version": "2023-06-01"
+        }
+
+    async def get_models(self, client, key: str) -> list[str]:
+        headers = self.build_headers(key)
+        try:
+            resp = await client.get(
+                f"{self.get_base_url()}{self.check_endpoint}",
+                headers=headers
+            )
+            if resp.status_code == 200:
+                data = resp.json()
+                if "data" in data:
+                    return [m["id"] for m in data["data"] if "id" in m]
+            return []
+        except Exception:
+            return []
+
+    async def check(self, client, key: str) -> CheckResult:
+        """Real usage test - try to make a minimal messages request."""
+        headers = self.build_headers(key)
+        headers["Content-Type"] = "application/json"
+        start = time.monotonic()
+        try:
+            resp = await client.post(
+                f"{self.get_base_url()}/v1/messages",
+                headers=headers,
+                json={
+                    "model": "claude-3-haiku-20240307",
+                    "messages": [{"role": "user", "content": "hi"}],
+                    "max_tokens": 5
+                }
+            )
+            latency = (time.monotonic() - start) * 1000
+
+            if resp.status_code == 200:
+                return CheckResult(True, 200, latency, None)
+            elif resp.status_code in (401, 403):
+                return CheckResult(False, resp.status_code, latency, "invalid key or forbidden")
+            elif resp.status_code == 429:
+                return CheckResult(False, 429, latency, "rate limited")
+            else:
+                data = resp.json()
+                error_msg = data.get("error", {}).get("message", f"status {resp.status_code}")
+                return CheckResult(False, resp.status_code, latency, error_msg)
+        except Exception as e:
+            return CheckResult(False, None, (time.monotonic() - start) * 1000, str(e))
+
+    async def test_token_limit(self, client, key: str, token_steps: list[int]) -> TestResult:
+        headers = self.build_headers(key)
+        last_success = None
+        for step in token_steps:
+            try:
+                resp = await client.post(
+                    f"{self.get_base_url()}/v1/messages",
+                    headers=headers,
+                    json={
+                        "model": "claude-3-haiku-20240307",
+                        "messages": [{"role": "user", "content": "hi"}],
+                        "max_tokens": step
+                    }
+                )
+                if resp.status_code == 200:
+                    last_success = step
+                elif resp.status_code in (400, 413):
+                    break
+                elif resp.status_code == 429:
+                    await asyncio.sleep(1)
+                    continue
+                else:
+                    break
+            except Exception:
+                break
+        return TestResult(max_tokens=last_success)
+
+
+    async def check_real(self, client, key: str) -> CheckResult:
+        return await self.check(client, key)
+    async def test_concurrency(self, client, key: str, concurrency_steps: list[int]) -> TestResult:
+        headers = self.build_headers(key)
+        last_success = None
+        for step in concurrency_steps:
+            tasks = [self._probe(client, headers) for _ in range(step)]
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+            rate_limited = sum(1 for r in results if not isinstance(r, Exception) and not r)
+            if rate_limited / step >= 0.3:
+                break
+            last_success = step
+        return TestResult(max_concurrency=last_success)
+
+    async def _probe(self, client, headers) -> bool:
+        try:
+            resp = await client.get(f"{self.get_base_url()}{self.check_endpoint}", headers=headers)
+            return resp.status_code == 200
+        except Exception:
+            return False