coding-proxy 0.1.0__py3-none-any.whl

coding/proxy/convert/openai_to_anthropic.py

@@ -0,0 +1,88 @@
+"""OpenAI Chat Completions → Anthropic Messages 转换."""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def convert_response(response: dict[str, Any]) -> dict[str, Any]:
+    """转换 OpenAI chat.completions 响应为 Anthropic message 响应."""
+    choices = response.get("choices", [])
+    text_blocks: list[dict[str, Any]] = []
+    tool_use_blocks: list[dict[str, Any]] = []
+    finish_reason = None
+
+    for choice in choices:
+        if not isinstance(choice, dict):
+            continue
+        finish_reason = choice.get("finish_reason") or finish_reason
+        message = choice.get("message", {})
+        reasoning_content = message.get("reasoning_content")
+        if isinstance(reasoning_content, str) and reasoning_content.strip():
+            text_blocks.append({"type": "thinking", "thinking": reasoning_content})
+            logger.debug(
+                "copilot: response reasoning_content -> thinking block (%d chars)",
+                len(reasoning_content),
+            )
+        content = message.get("content")
+        if isinstance(content, str) and content:
+            text_blocks.append({"type": "text", "text": content})
+        elif isinstance(content, list):
+            for part in content:
+                if isinstance(part, dict) and part.get("type") == "text" and part.get("text"):
+                    text_blocks.append({"type": "text", "text": part["text"]})
+
+        for tool_call in message.get("tool_calls", []) or []:
+            if not isinstance(tool_call, dict):
+                continue
+            function = tool_call.get("function", {})
+            arguments = function.get("arguments", "{}")
+            try:
+                parsed_arguments = json.loads(arguments) if isinstance(arguments, str) else arguments
+            except json.JSONDecodeError:
+                parsed_arguments = {}
+            tool_use_blocks.append({
+                "type": "tool_use",
+                "id": tool_call.get("id", ""),
+                "name": function.get("name", ""),
+                "input": parsed_arguments if isinstance(parsed_arguments, dict) else {},
+            })
+
+    usage = response.get("usage", {}) or {}
+    cached_tokens = ((usage.get("prompt_tokens_details") or {}).get("cached_tokens", 0))
+    content_blocks = [*text_blocks, *tool_use_blocks]
+
+    return {
+        "id": response.get("request_id", "") or response.get("id", ""),
+        "type": "message",
+        "role": "assistant",
+        "model": response.get("model", ""),
+        "content": content_blocks,
+        "stop_reason": _map_stop_reason(finish_reason) or "end_turn",
+        "stop_sequence": None,
+        "usage": {
+            "input_tokens": max((usage.get("prompt_tokens", 0) or 0) - cached_tokens, 0),
+            "output_tokens": usage.get("completion_tokens", 0) or 0,
+            **({"cache_read_input_tokens": cached_tokens} if cached_tokens else {}),
+        },
+    }
+
+
+def _map_stop_reason(reason: str | None) -> str | None:
+    if reason is None:
+        return None
+    mapping = {
+        "stop": "end_turn",
+        "length": "max_tokens",
+        "tool_calls": "tool_use",
+        "content_filter": "end_turn",
+    }
+    mapped = mapping.get(reason)
+    if mapped is None:
+        logger.debug("copilot: unknown finish_reason '%s', defaulting to end_turn", reason)
+        return "end_turn"
+    return mapped

coding/proxy/logging/__init__.py

@@ -0,0 +1,49 @@
+"""日志模块."""
+from __future__ import annotations
+
+
+def build_log_config(level: str = "INFO") -> dict:
+    """构建 uvicorn log_config，使用 yyyy-MM-dd HH:mm:ss 时间格式."""
+    return {
+        "version": 1,
+        "disable_existing_loggers": False,
+        "formatters": {
+            "default": {
+                "()": "uvicorn.logging.DefaultFormatter",
+                "fmt": "%(asctime)s %(levelprefix)s %(message)s",
+                "datefmt": "%Y-%m-%d %H:%M:%S",
+                "use_colors": None,
+            },
+            "access": {
+                "()": "uvicorn.logging.AccessFormatter",
+                "fmt": '%(asctime)s %(levelprefix)s %(client_addr)s - "%(request_line)s" %(status_code)s',
+                "datefmt": "%Y-%m-%d %H:%M:%S",
+            },
+        },
+        "handlers": {
+            "default": {
+                "formatter": "default",
+                "class": "logging.StreamHandler",
+                "stream": "ext://sys.stderr",
+            },
+            "access": {
+                "formatter": "access",
+                "class": "logging.StreamHandler",
+                "stream": "ext://sys.stdout",
+            },
+        },
+        "loggers": {
+            "uvicorn": {"handlers": ["default"], "level": level, "propagate": False},
+            "uvicorn.error": {"level": level},
+            "uvicorn.access": {
+                "handlers": ["access"],
+                "level": "INFO",
+                "propagate": False,
+            },
+            "coding.proxy": {
+                "handlers": ["default"],
+                "level": level,
+                "propagate": False,
+            },
+        },
+    }

coding/proxy/logging/db.py

@@ -0,0 +1,308 @@
+"""Token 用量 SQLite 日志."""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime, timedelta, timezone
+
+import aiosqlite
+from pathlib import Path
+from zoneinfo import ZoneInfo
+
+logger = logging.getLogger(__name__)
+
+
+def _local_tz() -> ZoneInfo:
+    """获取系统本地时区，失败降级 UTC."""
+    try:
+        return datetime.now().astimezone().tzinfo  # type: ignore[return-value]
+    except Exception:
+        logger.warning("无法获取系统本地时区，降级使用 UTC")
+        return timezone.utc
+
+
+def _days_start_utc_iso(days: int) -> str:
+    """
+    计算本地时区下「往前推 days-1 天的那天 00:00:00」对应的 UTC ISO 字符串.
+
+    语义: days=1 → 今天 00:00 local → 转 UTC
+          days=7 → 6 天前 00:00 local → 转 UTC
+    """
+    tz = _local_tz()
+    start_date = datetime.now(tz).date() - timedelta(days=max(1, days) - 1)
+    start_dt = datetime(start_date.year, start_date.month, start_date.day, tzinfo=tz)
+    return start_dt.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%f+00:00")
+
+
+def _hours_ago_utc_iso(hours: float) -> str:
+    """计算 hours 小时前的 UTC ISO 字符串（用于滚动窗口）."""
+    cutoff = datetime.now(timezone.utc) - timedelta(hours=hours)
+    return cutoff.strftime("%Y-%m-%dT%H:%M:%f+00:00")
+
+
+def _local_date_udf(ts_str: str) -> str:
+    """
+    SQLite UDF：将 UTC ISO 时间戳转为本地日期字符串.
+
+    设计要点：
+    - 动态调用 _local_tz()（非闭包捕获），使 unittest.mock.patch 可注入测试时区
+    - 容错处理非 ISO 格式（如旧迁移数据 ts='now'），降级为字符串截取前 10 位
+    - 永不抛异常（SQLite UDF 异常会导致整个查询失败）
+    """
+    try:
+        tz = _local_tz()
+        return datetime.fromisoformat(
+            ts_str.replace("Z", "+00:00")
+        ).astimezone(tz).strftime("%Y-%m-%d")
+    except (ValueError, TypeError, AttributeError):
+        # 非 ISO 格式（如旧数据 'now'）降级为字符串截取前 10 位
+        if isinstance(ts_str, str) and len(ts_str) >= 10:
+            return ts_str[:10]
+        return ""
+
+
+_CREATE_TABLES = """
+CREATE TABLE IF NOT EXISTS usage_log (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    ts TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    vendor TEXT NOT NULL,
+    model_requested TEXT NOT NULL,
+    model_served TEXT NOT NULL,
+    input_tokens INTEGER DEFAULT 0,
+    output_tokens INTEGER DEFAULT 0,
+    cache_creation_tokens INTEGER DEFAULT 0,
+    cache_read_tokens INTEGER DEFAULT 0,
+    duration_ms INTEGER DEFAULT 0,
+    success BOOLEAN NOT NULL DEFAULT 1,
+    failover BOOLEAN NOT NULL DEFAULT 0,
+    failover_from TEXT DEFAULT NULL,
+    request_id TEXT DEFAULT ''
+);
+CREATE TABLE IF NOT EXISTS usage_evidence (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    ts TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    vendor TEXT NOT NULL,
+    request_id TEXT DEFAULT '',
+    model_served TEXT NOT NULL DEFAULT '',
+    evidence_kind TEXT NOT NULL,
+    raw_usage_json TEXT NOT NULL DEFAULT '{}',
+    parsed_input_tokens INTEGER DEFAULT 0,
+    parsed_output_tokens INTEGER DEFAULT 0,
+    parsed_cache_creation_tokens INTEGER DEFAULT 0,
+    parsed_cache_read_tokens INTEGER DEFAULT 0,
+    cache_signal_present BOOLEAN NOT NULL DEFAULT 0,
+    source_field_map_json TEXT NOT NULL DEFAULT '{}'
+);
+"""
+
+_CREATE_INDEXES = """
+CREATE INDEX IF NOT EXISTS idx_usage_ts ON usage_log(ts);
+CREATE INDEX IF NOT EXISTS idx_usage_vendor ON usage_log(vendor);
+CREATE INDEX IF NOT EXISTS idx_usage_evidence_request_id ON usage_evidence(request_id);
+CREATE INDEX IF NOT EXISTS idx_usage_evidence_vendor ON usage_evidence(vendor);
+"""
+
+
+class TokenLogger:
+    def __init__(self, db_path: Path) -> None:
+        self._db_path = db_path
+        self._db: aiosqlite.Connection | None = None
+
+    async def init(self) -> None:
+        self._db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._db = await aiosqlite.connect(str(self._db_path))
+        self._db.row_factory = aiosqlite.Row
+        await self._db.execute("PRAGMA journal_mode=WAL")
+        await self._db.executescript(_CREATE_TABLES)
+        # 迁移必须在建索引之前执行，确保 vendor 列已存在
+        await self._migrate_rename_backend_to_vendor()
+        await self._migrate_add_failover_from()
+        await self._db.executescript(_CREATE_INDEXES)
+        # 注册时区感知的日期函数：将 UTC 时间戳转为本地日期
+        await self._db.create_function("local_date", 1, _local_date_udf)
+        await self._db.commit()
+
+    async def _migrate_add_failover_from(self) -> None:
+        """幂等迁移：为已有数据库添加 failover_from 列."""
+        if not self._db:
+            return
+        cursor = await self._db.execute("PRAGMA table_info(usage_log)")
+        columns = {row["name"] for row in await cursor.fetchall()}
+        if "failover_from" not in columns:
+            await self._db.execute(
+                "ALTER TABLE usage_log ADD COLUMN failover_from TEXT DEFAULT NULL"
+            )
+            logger.info("Migration: added failover_from column to usage_log")
+
+    async def _migrate_rename_backend_to_vendor(self) -> None:
+        """幂等迁移：重命名 backend 列为 vendor."""
+        if not self._db:
+            return
+        for table in ("usage_log", "usage_evidence"):
+            cursor = await self._db.execute(f"PRAGMA table_info({table})")
+            columns = {row["name"] for row in await cursor.fetchall()}
+            if "backend" in columns and "vendor" not in columns:
+                await self._db.execute(f"ALTER TABLE {table} RENAME COLUMN backend TO vendor")
+                logger.info("Migration: renamed 'backend' column to 'vendor' in %s", table)
+
+    async def log(self, vendor: str, model_requested: str, model_served: str,
+                  input_tokens: int = 0, output_tokens: int = 0,
+                  cache_creation_tokens: int = 0, cache_read_tokens: int = 0,
+                  duration_ms: int = 0, success: bool = True,
+                  failover: bool = False, failover_from: str | None = None,
+                  request_id: str = "") -> None:
+        if not self._db:
+            return
+        await self._db.execute(
+            """INSERT INTO usage_log
+               (vendor, model_requested, model_served,
+                input_tokens, output_tokens,
+                cache_creation_tokens, cache_read_tokens,
+                duration_ms, success, failover, failover_from, request_id)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+            (vendor, model_requested, model_served,
+             input_tokens, output_tokens,
+             cache_creation_tokens, cache_read_tokens,
+             duration_ms, success, failover, failover_from, request_id))
+        await self._db.commit()
+
+    async def log_evidence(
+        self,
+        *,
+        vendor: str,
+        request_id: str = "",
+        model_served: str = "",
+        evidence_kind: str,
+        raw_usage_json: str,
+        parsed_input_tokens: int = 0,
+        parsed_output_tokens: int = 0,
+        parsed_cache_creation_tokens: int = 0,
+        parsed_cache_read_tokens: int = 0,
+        cache_signal_present: bool = False,
+        source_field_map_json: str = "{}",
+    ) -> None:
+        if not self._db:
+            return
+        await self._db.execute(
+            """INSERT INTO usage_evidence
+               (vendor, request_id, model_served, evidence_kind, raw_usage_json,
+                parsed_input_tokens, parsed_output_tokens,
+                parsed_cache_creation_tokens, parsed_cache_read_tokens,
+                cache_signal_present, source_field_map_json)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+            (
+                vendor,
+                request_id,
+                model_served,
+                evidence_kind,
+                raw_usage_json,
+                parsed_input_tokens,
+                parsed_output_tokens,
+                parsed_cache_creation_tokens,
+                parsed_cache_read_tokens,
+                cache_signal_present,
+                source_field_map_json,
+            ),
+        )
+        await self._db.commit()
+
+    async def query_evidence(self, request_id: str) -> list[dict]:
+        if not self._db:
+            return []
+        cursor = await self._db.execute(
+            """SELECT vendor, request_id, model_served, evidence_kind, raw_usage_json,
+                      parsed_input_tokens, parsed_output_tokens,
+                      parsed_cache_creation_tokens, parsed_cache_read_tokens,
+                      cache_signal_present, source_field_map_json
+               FROM usage_evidence
+               WHERE request_id = ?
+               ORDER BY id ASC""",
+            (request_id,),
+        )
+        rows = await cursor.fetchall()
+        return [dict(row) for row in rows]
+
+    async def query_daily(self, days: int = 7, vendor: str | None = None,
+                          model: str | None = None) -> list[dict]:
+        if not self._db:
+            return []
+        days = max(1, days)
+        start_iso = _days_start_utc_iso(days)
+        sql = """SELECT local_date(ts) AS date, vendor, model_requested, model_served,
+                   COUNT(*) AS total_requests,
+                   SUM(input_tokens) AS total_input,
+                   SUM(output_tokens) AS total_output,
+                   SUM(cache_creation_tokens) AS total_cache_creation,
+                   SUM(cache_read_tokens) AS total_cache_read,
+                   SUM(CASE WHEN failover THEN 1 ELSE 0 END) AS total_failovers,
+                   AVG(duration_ms) AS avg_duration_ms
+               FROM usage_log WHERE ts >= ?"""
+        params: list = [start_iso]
+        if vendor:
+            sql += " AND vendor = ?"
+            params.append(vendor)
+        if model:
+            sql += " AND model_requested = ?"
+            params.append(model)
+        sql += (" GROUP BY local_date(ts), vendor, model_requested, model_served"
+                " ORDER BY local_date(ts) DESC, vendor, model_requested, model_served")
+        cursor = await self._db.execute(sql, params)
+        rows = await cursor.fetchall()
+        return [dict(row) for row in rows]
+
+    async def query_failover_stats(self, days: int = 7, include_model_info: bool = False) -> list[dict]:
+        """
+        按 failover_from → vendor 聚合故障转移次数.
+
+        Args:
+            days: 查询天数
+            include_model_info: 是否在聚合中包含模型信息
+                              - False: 按 (failover_from, vendor) 聚合 (默认,向后兼容)
+                              - True: 按 (failover_from, vendor, model_requested, model_served) 聚合
+        """
+        if not self._db:
+            return []
+        days = max(1, days)
+        start_iso = _days_start_utc_iso(days)
+
+        if include_model_info:
+            sql = """SELECT failover_from, vendor, model_requested, model_served,
+                       COUNT(*) AS count
+                   FROM usage_log
+                   WHERE failover = 1 AND ts >= ?
+                   GROUP BY failover_from, vendor, model_requested, model_served
+                   ORDER BY count DESC"""
+        else:
+            # 保持原有的聚合逻辑确保向后兼容
+            sql = """SELECT failover_from, vendor,
+                       COUNT(*) AS count
+                   FROM usage_log
+                   WHERE failover = 1 AND ts >= ?
+                   GROUP BY failover_from, vendor
+                   ORDER BY count DESC"""
+
+        cursor = await self._db.execute(sql, [start_iso])
+        rows = await cursor.fetchall()
+        return [dict(row) for row in rows]
+
+    async def query_window_total(
+        self, window_hours: float, vendor: str = "anthropic",
+    ) -> int:
+        """查询滚动时间窗口内指定供应商的 token 总用量."""
+        if not self._db:
+            return 0
+        cutoff_iso = _hours_ago_utc_iso(window_hours)
+        cursor = await self._db.execute(
+            """SELECT COALESCE(SUM(input_tokens + output_tokens), 0) AS total
+               FROM usage_log
+               WHERE vendor = ? AND success = 1
+                 AND ts >= ?""",
+            (vendor, cutoff_iso),
+        )
+        row = await cursor.fetchone()
+        return row["total"] if row else 0
+
+    async def close(self) -> None:
+        if self._db:
+            await self._db.close()
+            self._db = None

coding/proxy/logging/stats.py

@@ -0,0 +1,129 @@
+"""使用统计查询与展示."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from rich.console import Console
+from rich.table import Table
+
+from .db import TokenLogger
+
+if TYPE_CHECKING:
+    from ..pricing import PricingTable
+
+
+def _format_model_display(model_value: str | None) -> str:
+    """格式化模型显示，处理 None 或空值."""
+    if not model_value or model_value.strip() == "":
+        return "[dim]<未知>[/dim]"
+    return model_value
+
+
+def _format_tokens(n: int) -> str:
+    """将 Token 数量格式化为 K/M/B 计量单位显示（最多 2 位小数）."""
+    if n >= 1_000_000_000:
+        return f"{n / 1_000_000_000:.2f}".rstrip("0").rstrip(".") + "B"
+    if n >= 1_000_000:
+        return f"{n / 1_000_000:.2f}".rstrip("0").rstrip(".") + "M"
+    if n >= 1_000:
+        return f"{n / 1_000:.2f}".rstrip("0").rstrip(".") + "K"
+    return str(n)
+
+
+def _detect_model_variants(failover_stats: list[dict]) -> bool:
+    """检测是否存在模型差异，用于决定是否建议详细模式."""
+    if not failover_stats or "model_requested" not in failover_stats[0]:
+        return False
+
+    # 计算唯一的模型对
+    model_pairs = {
+        (stat.get("model_requested", ""), stat.get("model_served", ""))
+        for stat in failover_stats
+    }
+    # 检查是否存在模型映射（请求模型与实际模型不同）
+    return any(
+        pair[0] != pair[1]
+        for pair in model_pairs
+        if pair[0] and pair[1]
+    )
+
+
+async def show_usage(
+    logger: TokenLogger,
+    days: int = 7,
+    vendor: str | None = None,
+    model: str | None = None,
+    pricing_table: "PricingTable | None" = None,
+) -> None:
+    """展示 Token 使用统计."""
+    console = Console()
+    rows = await logger.query_daily(days=days, vendor=vendor, model=model)
+
+    if not rows:
+        console.print("[yellow]暂无使用记录[/yellow]")
+        return
+
+    table = Table(title=f"Token 使用统计（最近 {days} 天）")
+    table.add_column("日期", style="cyan")
+    table.add_column("供应商", style="green")
+    table.add_column("请求模型", style="magenta")
+    table.add_column("实际模型", style="yellow")
+    table.add_column("请求数", justify="right")
+    table.add_column("输入 Token", justify="right", style="blue")
+    table.add_column("输出 Token", justify="right", style="blue")
+    table.add_column("缓存创建 Token", justify="right", style="dim blue")
+    table.add_column("缓存读取 Token", justify="right", style="dim cyan")
+    table.add_column("总 Token", justify="right", style="bold white")
+    table.add_column("Cost", justify="right", style="bold green")
+    table.add_column("平均耗时(ms)", justify="right")
+
+    for row in rows:
+        total_input = row.get("total_input", 0) or 0
+        total_output = row.get("total_output", 0) or 0
+        total_cache_creation = row.get("total_cache_creation", 0) or 0
+        total_cache_read = row.get("total_cache_read", 0) or 0
+        total_tokens = total_input + total_output + total_cache_creation + total_cache_read
+
+        vendor_name = str(row.get("vendor", ""))
+        model_served = str(row.get("model_served", ""))
+        if pricing_table is not None:
+            cost_value = pricing_table.compute_cost(
+                vendor_name, model_served,
+                total_input, total_output, total_cache_creation, total_cache_read,
+            )
+            cost_str = cost_value.format() if cost_value is not None else "-"
+        else:
+            cost_str = "-"
+
+        table.add_row(
+            str(row.get("date", "")),
+            vendor_name,
+            str(row.get("model_requested", "")),
+            model_served,
+            str(row.get("total_requests", 0)),
+            _format_tokens(total_input),
+            _format_tokens(total_output),
+            _format_tokens(total_cache_creation),
+            _format_tokens(total_cache_read),
+            _format_tokens(total_tokens),
+            cost_str,
+            str(int(row.get("avg_duration_ms", 0) or 0)),
+        )
+
+    console.print(table)
+
+    # 故障转移来源汇总
+    failover_stats = await logger.query_failover_stats(days=days)
+    if failover_stats:
+        console.print()
+        ft_table = Table(title="故障转移来源明细")
+        ft_table.add_column("来源", style="yellow")
+        ft_table.add_column("目标", style="green")
+        ft_table.add_column("次数", justify="right", style="red")
+        for stat in failover_stats:
+            source = stat.get("failover_from") or "unknown"
+            target = stat.get("vendor", "")
+            count = stat.get("count", 0)
+            ft_table.add_row(source, target, str(count))
+        console.print(ft_table)

coding/proxy/model/__init__.py

@@ -0,0 +1,93 @@
+"""集中化数据模型 — coding-proxy 所有共享类型的单一事实源.
+
+本模块将分散在各处的类型定义（供应商类型、兼容层抽象、认证凭证、
+Token 管理、定价模型、共享常量）统一收归于此，遵循正交分解原则
+按职责域划分子模块。
+
+使用者可直接从本包导入::
+
+    from coding.proxy.model import UsageInfo, VendorResponse, CanonicalRequest
+
+也可从具体子模块导入以获得更细粒度的依赖控制::
+
+    from coding.proxy.model.vendor import UsageInfo, VendorResponse
+    from coding.proxy.model.compat import CanonicalRequest, CompatibilityProfile
+"""
+
+# ── 供应商核心类型 ──────────────────────────────────────────
+from .vendor import (  # noqa: F401
+    VendorCapabilities,
+    VendorResponse,
+    CapabilityLossReason,
+    CopilotExchangeDiagnostics,
+    CopilotMisdirectedRequest,
+    CopilotModelCatalog,
+    NoCompatibleVendorError,
+    RequestCapabilities,
+    UsageInfo,
+    decode_json_body,
+    extract_error_message,
+    sanitize_headers_for_synthetic_response,
+)
+
+# ── 向后兼容别名（v2 移除）────────────────────────────────────
+BackendCapabilities = VendorCapabilities  # noqa: F401
+BackendResponse = VendorResponse  # noqa: F401
+NoCompatibleBackendError = NoCompatibleVendorError  # noqa: F401
+
+# ── 兼容层抽象类型 ────────────────────────────────────────
+from .compat import (  # noqa: F401
+    CanonicalMessagePart,
+    CanonicalPartType,
+    CanonicalRequest,
+    CanonicalThinking,
+    CanonicalToolCall,
+    CompatSessionRecord,
+    CompatibilityDecision,
+    CompatibilityProfile,
+    CompatibilityStatus,
+    CompatibilityTrace,
+)
+
+# ── 认证凭证模型 ──────────────────────────────────────────
+from .auth import ProviderTokens  # noqa: F401
+
+# ── Token 管理类型 ──────────────────────────────────────────
+from .token import (  # noqa: F401
+    TokenAcquireError,
+    TokenErrorKind,
+    TokenManagerDiagnostics,
+)
+
+# ── 定价模型 ────────────────────────────────────────────────
+from .pricing import CostValue, Currency, ModelPricing  # noqa: F401
+
+# ── 共享常量 ────────────────────────────────────────────────
+from .constants import (  # noqa: F401
+    PROXY_SKIP_HEADERS,
+    RESPONSE_SANITIZE_SKIP_HEADERS,
+)
+
+__all__ = [
+    # vendor（新命名）
+    "VendorCapabilities", "VendorResponse", "NoCompatibleVendorError",
+    # 向后兼容别名
+    "BackendCapabilities", "BackendResponse", "NoCompatibleBackendError",
+    # 通用类型
+    "CapabilityLossReason", "CopilotExchangeDiagnostics",
+    "CopilotMisdirectedRequest", "CopilotModelCatalog",
+    "RequestCapabilities", "UsageInfo",
+    "decode_json_body", "extract_error_message", "sanitize_headers_for_synthetic_response",
+    # compat
+    "CanonicalMessagePart", "CanonicalPartType", "CanonicalRequest",
+    "CanonicalThinking", "CanonicalToolCall", "CompatSessionRecord",
+    "CompatibilityDecision", "CompatibilityProfile", "CompatibilityStatus", "CompatibilityTrace",
+    # auth
+    "ProviderTokens",
+    # token
+    "TokenAcquireError", "TokenErrorKind", "TokenManagerDiagnostics",
+    # pricing
+    "CostValue", "Currency", "ModelPricing",
+    # constants
+    "PROXY_SKIP_HEADERS", "RESPONSE_SANITIZE_SKIP_HEADERS",
+]