coding-proxy 0.1.0__py3-none-any.whl

coding/proxy/routing/tier.py

@@ -0,0 +1,171 @@
+"""供应商层级 — 将供应商实例与弹性设施（熔断器 + 配额守卫）聚合为路由单元."""
+
+from __future__ import annotations
+
+import logging
+import time
+
+from dataclasses import dataclass, field
+
+from ..vendors.base import BaseVendor
+from .circuit_breaker import CircuitBreaker, CircuitState
+from .quota_guard import QuotaGuard, QuotaState
+from .retry import RetryConfig
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class VendorTier:
+    """一个路由层级：供应商实例 + 关联的熔断器和配额守卫."""
+
+    vendor: BaseVendor
+    circuit_breaker: CircuitBreaker | None = field(default=None)
+    quota_guard: QuotaGuard | None = field(default=None)
+    weekly_quota_guard: QuotaGuard | None = field(default=None)
+    retry_config: RetryConfig | None = field(default=None)
+
+    # Rate Limit 精确截止时间（monotonic timestamp），0 表示无限制
+    _rate_limit_deadline: float = field(default=0.0, repr=False)
+
+    @property
+    def name(self) -> str:
+        return self.vendor.get_name()
+
+    @property
+    def is_terminal(self) -> bool:
+        """终端层无熔断器，不触发故障转移."""
+        return self.circuit_breaker is None
+
+    @property
+    def rate_limit_remaining_seconds(self) -> float:
+        """Rate limit 剩余等待秒数（<= 0 表示已到期）."""
+        return max(0.0, self._rate_limit_deadline - time.monotonic())
+
+    @property
+    def is_rate_limited(self) -> bool:
+        """是否处于 rate limit 冷却期."""
+        return self._rate_limit_deadline > time.monotonic()
+
+    def can_execute(self) -> bool:
+        """综合判断此层是否可用."""
+        if self.circuit_breaker and not self.circuit_breaker.can_execute():
+            return False
+        if self.quota_guard and not self.quota_guard.can_use_primary():
+            return False
+        if self.weekly_quota_guard and not self.weekly_quota_guard.can_use_primary():
+            return False
+        return True
+
+    def record_success(self, usage_tokens: int = 0) -> None:
+        """记录成功：通知熔断器和配额守卫，清除 rate limit deadline."""
+        if self.circuit_breaker:
+            self.circuit_breaker.record_success()
+        if self.quota_guard:
+            self.quota_guard.record_primary_success()
+            if usage_tokens > 0:
+                self.quota_guard.record_usage(usage_tokens)
+        if self.weekly_quota_guard:
+            self.weekly_quota_guard.record_primary_success()
+            if usage_tokens > 0:
+                self.weekly_quota_guard.record_usage(usage_tokens)
+        self._rate_limit_deadline = 0.0
+
+    def record_failure(
+        self,
+        *,
+        is_cap_error: bool = False,
+        retry_after_seconds: float | None = None,
+        rate_limit_deadline: float | None = None,
+    ) -> None:
+        """记录失败：通知熔断器；如为 cap 错误则通知配额守卫.
+
+        Args:
+            is_cap_error: 是否为配额上限错误
+            retry_after_seconds: 从响应头解析的建议恢复时间
+            rate_limit_deadline: 精确的 rate limit 截止 monotonic 时间戳
+        """
+        if self.circuit_breaker:
+            self.circuit_breaker.record_failure(retry_after_seconds=retry_after_seconds)
+        if self.quota_guard and is_cap_error:
+            self.quota_guard.notify_cap_error(retry_after_seconds=retry_after_seconds)
+        if self.weekly_quota_guard and is_cap_error:
+            self.weekly_quota_guard.notify_cap_error(retry_after_seconds=retry_after_seconds)
+
+        if rate_limit_deadline is not None and rate_limit_deadline > self._rate_limit_deadline:
+            self._rate_limit_deadline = rate_limit_deadline
+            logger.info(
+                "Tier %s: rate limit deadline updated, %.1fs remaining",
+                self.name,
+                rate_limit_deadline - time.monotonic(),
+            )
+
+    async def can_execute_with_health_check(self) -> bool:
+        """带健康检查的可用性判断（异步，慢路径）.
+
+        三层恢复门控:
+        1. Rate Limit Deadline — 截止时间未到，直接拒绝
+        2. Health Check — 轻量级供应商健康探测
+        3. Cautious Probe — 通过前两层后，允许真实请求作为探针
+        """
+        # ── 第一层: Rate Limit Deadline 门控 ──
+        if self.is_rate_limited:
+            remaining = self.rate_limit_remaining_seconds
+            logger.debug(
+                "Tier %s: rate limit deadline active, %.1fs remaining, blocking",
+                self.name,
+                remaining,
+            )
+            return False
+
+        cb_allows = self.circuit_breaker.can_execute() if self.circuit_breaker else True
+        qg_allows = self.quota_guard.can_use_primary() if self.quota_guard else True
+        wqg_allows = self.weekly_quota_guard.can_use_primary() if self.weekly_quota_guard else True
+
+        if not cb_allows and not qg_allows and not wqg_allows:
+            return False
+
+        # 检测是否为探测场景
+        is_probe_scenario = False
+        if self.circuit_breaker:
+            if self.circuit_breaker.state == CircuitState.HALF_OPEN:
+                is_probe_scenario = True
+        if self.quota_guard:
+            # QG 允许探测（在 QUOTA_EXCEEDED 状态下但返回 True）
+            if self.quota_guard._state == QuotaState.QUOTA_EXCEEDED and qg_allows:
+                is_probe_scenario = True
+        if self.weekly_quota_guard:
+            if self.weekly_quota_guard._state == QuotaState.QUOTA_EXCEEDED and wqg_allows:
+                is_probe_scenario = True
+
+        if not is_probe_scenario:
+            return cb_allows and qg_allows and wqg_allows
+
+        # ── 第二层: Health Check 门控 ──
+        logger.info("Tier %s: probe scenario, running health check", self.name)
+        healthy = await self.vendor.check_health()
+        if not healthy:
+            logger.warning("Tier %s: health check failed, staying degraded", self.name)
+            self.record_failure()
+            return False
+
+        # ── 第三层: Cautious Probe（允许真实请求通过）──
+        logger.info("Tier %s: health check passed, allowing cautious probe", self.name)
+        return True
+
+    def reset_rate_limit(self) -> None:
+        """手动清除 rate limit deadline."""
+        self._rate_limit_deadline = 0.0
+
+    def get_rate_limit_info(self) -> dict:
+        """获取 rate limit deadline 状态信息."""
+        now = time.monotonic()
+        remaining = max(0.0, self._rate_limit_deadline - now)
+        return {
+            "is_rate_limited": self._rate_limit_deadline > now,
+            "remaining_seconds": round(remaining, 1),
+        }
+
+
+# 向后兼容别名
+BackendTier = VendorTier

coding/proxy/routing/usage_parser.py

@@ -0,0 +1,193 @@
+"""SSE 流式响应用量解析工具.
+
+从 Anthropic / OpenAI / Zhipu 兼容格式的 SSE chunk 中提取 token 用量信息，
+支持多源归一化与 evidence 追踪。
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any
+
+from ..vendors.base import UsageInfo
+
+logger = logging.getLogger(__name__)
+
+
+def _set_if_nonzero(usage: dict, key: str, value: int) -> None:
+    """仅在 value 非零时设置，避免后续 chunk 的 0 值覆盖已提取的非零值.
+
+    同时处理 None 值，确保数据类型正确性。
+    """
+    if value is not None and value != 0:
+        usage[key] = value
+
+
+def _append_usage_evidence(
+    usage: dict[str, Any],
+    *,
+    evidence_kind: str,
+    raw_usage: dict[str, Any],
+    request_id: str | None = None,
+    model_served: str | None = None,
+) -> None:
+    entries = usage.setdefault("_usage_evidence", [])
+    if not isinstance(entries, list):
+        return
+    entries.append({
+        "evidence_kind": evidence_kind,
+        "raw_usage": raw_usage,
+        "request_id": request_id or "",
+        "model_served": model_served or "",
+        "source_field_map": {
+            "input_tokens": next(
+                (key for key in ("input_tokens", "prompt_tokens") if key in raw_usage),
+                "",
+            ),
+            "output_tokens": next(
+                (key for key in ("output_tokens", "completion_tokens") if key in raw_usage),
+                "",
+            ),
+            "cache_creation_tokens": next(
+                (key for key in ("cache_creation_input_tokens",) if key in raw_usage),
+                "",
+            ),
+            "cache_read_tokens": next(
+                (
+                    key for key in (
+                        "cache_read_input_tokens",
+                        "cached_tokens",
+                    ) if key in raw_usage
+                ),
+                "",
+            ),
+        },
+        "cache_signal_present": any(
+            key in raw_usage
+            for key in ("cache_creation_input_tokens", "cache_read_input_tokens", "cached_tokens")
+        ),
+    })
+
+
+def build_usage_evidence_records(
+    usage: dict[str, Any],
+    *,
+    vendor: str,
+    model_served: str,
+    request_id: str,
+) -> list[dict[str, Any]]:
+    records: list[dict[str, Any]] = []
+    entries = usage.get("_usage_evidence", [])
+    if not isinstance(entries, list):
+        return records
+
+    for entry in entries:
+        if not isinstance(entry, dict):
+            continue
+        raw_usage = entry.get("raw_usage")
+        if not isinstance(raw_usage, dict):
+            continue
+        source_field_map = entry.get("source_field_map")
+        if not isinstance(source_field_map, dict):
+            source_field_map = {}
+        records.append({
+            "vendor": vendor,
+            "request_id": str(entry.get("request_id") or request_id or ""),
+            "model_served": str(entry.get("model_served") or model_served or ""),
+            "evidence_kind": str(entry.get("evidence_kind") or "stream_usage"),
+            "raw_usage_json": json.dumps(raw_usage, ensure_ascii=False, sort_keys=True),
+            "parsed_input_tokens": usage.get("input_tokens", 0),
+            "parsed_output_tokens": usage.get("output_tokens", 0),
+            "parsed_cache_creation_tokens": usage.get("cache_creation_tokens", 0),
+            "parsed_cache_read_tokens": usage.get("cache_read_tokens", 0),
+            "cache_signal_present": bool(entry.get("cache_signal_present")),
+            "source_field_map_json": json.dumps(source_field_map, ensure_ascii=False, sort_keys=True),
+        })
+    return records
+
+
+def parse_usage_from_chunk(chunk: bytes, usage: dict, *, vendor_label: str | None = None) -> None:
+    """从 SSE chunk 提取 token 用量.
+
+    同时支持 Anthropic 原生格式和 OpenAI/Zhipu 兼容格式：
+    - Anthropic: data.message.usage.input_tokens / data.usage.output_tokens
+    - OpenAI/Zhipu: 顶层 data.usage.prompt_tokens / data.usage.completion_tokens
+
+    :param vendor_label: 上游 Vendor 标签（如 "Anthropic"、"OpenAI"、"Gemini"），
+                          用于日志标注实际来源协议，由调用方根据 tier.name 传入。
+    """
+    text = chunk.decode("utf-8", errors="ignore")
+    for line in text.split("\n"):
+        if not line.startswith("data: "):
+            continue
+        payload = line[6:].strip()
+        if not payload or payload == "[DONE]":
+            continue
+        try:
+            data = json.loads(payload)
+        except json.JSONDecodeError:
+            continue
+
+        # Anthropic 格式: message_start 事件 (data.message.usage)
+        msg = data.get("message", {})
+        if isinstance(msg, dict) and "usage" in msg:
+            u = msg["usage"]
+            input_tokens = u.get("input_tokens", 0) or u.get("prompt_tokens", 0)
+            if input_tokens > 0:
+                logger.debug("Extracted input tokens from message.usage: %d", input_tokens)
+            _set_if_nonzero(usage, "input_tokens", input_tokens)
+            _set_if_nonzero(usage, "cache_creation_tokens", u.get("cache_creation_input_tokens", 0))
+            _set_if_nonzero(usage, "cache_read_tokens", u.get("cache_read_input_tokens", 0))
+            if "id" in msg:
+                usage["request_id"] = msg["id"]
+            if "model" in msg:
+                usage["model_served"] = msg["model"]
+            if isinstance(u, dict):
+                _append_usage_evidence(
+                    usage,
+                    evidence_kind="message_usage",
+                    raw_usage=dict(u),
+                    request_id=msg.get("id"),
+                    model_served=msg.get("model"),
+                )
+
+        # Anthropic message_delta / OpenAI 最后一个 chunk (data.usage)
+        if "usage" in data:
+            u = data["usage"]
+            output_tokens = u.get("output_tokens", 0) or u.get("completion_tokens", 0)
+            input_tokens = u.get("input_tokens", 0) or u.get("prompt_tokens", 0)
+            cache_creation_tokens = u.get("cache_creation_input_tokens", 0)
+            cache_read_tokens = u.get("cache_read_input_tokens", 0)
+
+            _label = f" ({vendor_label})" if vendor_label else ""
+            if output_tokens > 0:
+                logger.debug("Extracted output tokens from data.usage: %d%s", output_tokens, _label)
+            if input_tokens > 0:
+                logger.debug("Extracted input tokens from data.usage: %d%s", input_tokens, _label)
+
+            _set_if_nonzero(usage, "output_tokens", output_tokens)
+            _set_if_nonzero(usage, "input_tokens", input_tokens)
+            _set_if_nonzero(usage, "cache_creation_tokens", cache_creation_tokens)
+            _set_if_nonzero(usage, "cache_read_tokens", cache_read_tokens)
+            if isinstance(u, dict):
+                _append_usage_evidence(
+                    usage,
+                    evidence_kind="data_usage",
+                    raw_usage=dict(u),
+                    request_id=data.get("id"),
+                    model_served=data.get("model"),
+                )
+
+        # request_id fallback (OpenAI 格式下 id 在顶层)
+        if "id" in data and not usage.get("request_id"):
+            usage["request_id"] = data["id"]
+
+
+def has_missing_input_usage_signals(info: UsageInfo) -> bool:
+    """判断流式请求是否缺失可解释的输入 usage 信号."""
+    if info.output_tokens <= 0:
+        return False
+    if info.input_tokens > 0:
+        return False
+    return info.cache_creation_tokens <= 0 and info.cache_read_tokens <= 0

coding/proxy/routing/usage_recorder.py

@@ -0,0 +1,131 @@
+"""用量记录器 — 封装 token 用量日志、定价计算与证据构建."""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from ..pricing import PricingTable
+    from ..logging.db import TokenLogger
+    from .usage_parser import UsageInfo
+
+logger = logging.getLogger(__name__)
+
+
+class UsageRecorder:
+    """封装路由层的用量记录、定价日志与证据构建逻辑."""
+
+    def __init__(
+        self,
+        token_logger: TokenLogger | None = None,
+        pricing_table: PricingTable | None = None,
+    ) -> None:
+        self._token_logger = token_logger
+        self._pricing_table = pricing_table
+
+    def set_pricing_table(self, table: PricingTable) -> None:
+        self._pricing_table = table
+
+    # ── 用量信息构建 ──────────────────────────────────────
+
+    @staticmethod
+    def build_usage_info(usage: dict[str, Any]) -> UsageInfo:
+        from .usage_parser import UsageInfo
+
+        return UsageInfo(
+            input_tokens=usage.get("input_tokens", 0),
+            output_tokens=usage.get("output_tokens", 0),
+            cache_creation_tokens=usage.get("cache_creation_tokens", 0),
+            cache_read_tokens=usage.get("cache_read_tokens", 0),
+            request_id=usage.get("request_id", ""),
+        )
+
+    # ── 模型调用日志 ──────────────────────────────────────
+
+    def log_model_call(
+        self,
+        *,
+        vendor: str,
+        model_requested: str,
+        model_served: str,
+        duration_ms: int,
+        usage: UsageInfo,
+    ) -> None:
+        """打印模型调用级别的详细 Access Log."""
+        cost_str = "-"
+        if self._pricing_table is not None:
+            cost_value = self._pricing_table.compute_cost(
+                vendor=vendor,
+                model_served=model_served,
+                input_tokens=usage.input_tokens,
+                output_tokens=usage.output_tokens,
+                cache_creation_tokens=usage.cache_creation_tokens,
+                cache_read_tokens=usage.cache_read_tokens,
+            )
+            if cost_value is not None:
+                cost_str = cost_value.format()
+        logger.info(
+            "ModelCall: vendor=%s model_requested=%s model_served=%s "
+            "duration=%dms tokens=[in:%d out:%d cache_create:%d cache_read:%d] cost=%s",
+            vendor, model_requested, model_served, duration_ms,
+            usage.input_tokens, usage.output_tokens,
+            usage.cache_creation_tokens, usage.cache_read_tokens, cost_str,
+        )
+
+    # ── 持久化记录 ────────────────────────────────────────
+
+    async def record(
+        self,
+        vendor: str,
+        model_requested: str,
+        model_served: str,
+        usage: UsageInfo,
+        duration_ms: int,
+        success: bool,
+        failover: bool,
+        failover_from: str | None = None,
+        evidence_records: list[dict[str, Any]] | None = None,
+    ) -> None:
+        if not self._token_logger:
+            return
+        await self._token_logger.log(
+            vendor=vendor, model_requested=model_requested, model_served=model_served,
+            input_tokens=usage.input_tokens, output_tokens=usage.output_tokens,
+            cache_creation_tokens=usage.cache_creation_tokens, cache_read_tokens=usage.cache_read_tokens,
+            duration_ms=duration_ms, success=success, failover=failover, failover_from=failover_from,
+            request_id=usage.request_id,
+        )
+        if not evidence_records or vendor != "copilot":
+            return
+        if not hasattr(self._token_logger, "log_evidence"):
+            return
+        for record in evidence_records:
+            await self._token_logger.log_evidence(**record)
+
+    # ── 证据记录构建 ──────────────────────────────────────
+
+    @staticmethod
+    def build_nonstream_evidence_records(*, vendor: str, model_served: str, usage: UsageInfo) -> list[dict[str, Any]]:
+        if vendor != "copilot":
+            return []
+        raw_usage: dict[str, Any] = {"input_tokens": usage.input_tokens, "output_tokens": usage.output_tokens}
+        if usage.cache_creation_tokens > 0:
+            raw_usage["cache_creation_input_tokens"] = usage.cache_creation_tokens
+        if usage.cache_read_tokens > 0:
+            raw_usage["cache_read_input_tokens"] = usage.cache_read_tokens
+        return [{
+            "vendor": vendor, "request_id": usage.request_id, "model_served": model_served,
+            "evidence_kind": "nonstream_usage_summary",
+            "raw_usage_json": json.dumps(raw_usage, ensure_ascii=False, sort_keys=True),
+            "parsed_input_tokens": usage.input_tokens, "parsed_output_tokens": usage.output_tokens,
+            "parsed_cache_creation_tokens": usage.cache_creation_tokens, "parsed_cache_read_tokens": usage.cache_read_tokens,
+            "cache_signal_present": usage.cache_creation_tokens > 0 or usage.cache_read_tokens > 0,
+            "source_field_map_json": json.dumps({
+                "input_tokens": "input_tokens", "output_tokens": "output_tokens",
+                "cache_creation_tokens": "cache_creation_input_tokens" if usage.cache_creation_tokens > 0 else "",
+                "cache_read_tokens": "cache_read_input_tokens" if usage.cache_read_tokens > 0 else "",
+            }, ensure_ascii=False, sort_keys=True),
+        }]

coding/proxy/server/__init__.py

@@ -0,0 +1 @@
+"""服务模块."""

coding/proxy/server/app.py

@@ -0,0 +1,142 @@
+"""FastAPI 应用工厂与生命周期管理.
+
+路由端点注册已正交分解至 :mod:`.routes`.
+"""
+
+from __future__ import annotations
+
+import logging
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Any
+
+from fastapi import FastAPI
+
+from ..auth.providers.github import GitHubDeviceFlowProvider
+from ..auth.providers.google import GoogleOAuthProvider
+from ..auth.runtime import RuntimeReauthCoordinator
+from ..auth.store import TokenStoreManager
+from ..vendors.antigravity import AntigravityVendor
+from ..vendors.copilot import CopilotVendor
+from ..config.loader import load_config
+from ..compat.session_store import CompatSessionStore
+from ..config.schema import ProxyConfig
+from ..logging.db import TokenLogger
+from ..routing.router import RequestRouter
+from ..routing.tier import VendorTier
+from .factory import (  # noqa: F401
+    _build_circuit_breaker,
+    _build_quota_guard,
+    _create_vendor_from_config,
+)
+from .routes import register_all_routes
+
+logger = logging.getLogger(__name__)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """应用生命周期管理（启动 / 关闭）."""
+    router: RequestRouter = app.state.router
+    token_logger: TokenLogger = app.state.token_logger
+    compat_session_store: CompatSessionStore = app.state.compat_session_store
+    config: ProxyConfig = app.state.config
+
+    await token_logger.init()
+    await compat_session_store.init()
+
+    # 从配置加载模型定价表
+    from ..pricing import PricingTable  # noqa: F401
+
+    pricing_table = PricingTable(config.pricing)
+    app.state.pricing_table = pricing_table
+    router.set_pricing_table(pricing_table)
+
+    # 为每个有 QuotaGuard 的 tier 加载基线
+    for tier in router.tiers:
+        if tier.quota_guard and tier.quota_guard.enabled:
+            total = await token_logger.query_window_total(
+                tier.quota_guard.window_hours,
+                vendor=tier.name,
+            )
+            tier.quota_guard.load_baseline(total)
+        if tier.weekly_quota_guard and tier.weekly_quota_guard.enabled:
+            total = await token_logger.query_window_total(
+                tier.weekly_quota_guard.window_hours,
+                vendor=tier.name,
+            )
+            tier.weekly_quota_guard.load_baseline(total)
+
+    logger.info("coding-proxy started: host=%s port=%d", config.server.host, config.server.port)
+    yield
+    await router.close()
+    await compat_session_store.close()
+    await token_logger.close()
+    logger.info("coding-proxy stopped")
+
+
+def create_app(config: ProxyConfig | None = None) -> FastAPI:
+    """创建 FastAPI 应用实例."""
+    if config is None:
+        config = load_config()
+
+    token_logger = TokenLogger(config.db_path)
+    compat_session_store = CompatSessionStore(
+        config.compat_state_path,
+        ttl_seconds=config.database.compat_state_ttl_seconds,
+    )
+    from ..routing.model_mapper import ModelMapper  # noqa: E402
+
+    mapper = ModelMapper(config.model_mapping)
+
+    # 加载 Token Store 用于凭证合并
+    token_store = TokenStoreManager(
+        store_path=Path(config.auth.token_store_path) if config.auth.token_store_path else None
+    )
+    token_store.load()
+
+    # 阶段一：构建 vendor_name → VendorTier 映射表（与顺序无关）
+    _vendor_map: dict[str, Any] = {}
+    for vendor_cfg in config.vendors:
+        if not vendor_cfg.enabled:
+            continue
+        vendor = _create_vendor_from_config(vendor_cfg, config.failover, mapper, token_store)
+        cb = _build_circuit_breaker(vendor_cfg.circuit_breaker) if vendor_cfg.circuit_breaker else None
+        qg = _build_quota_guard(vendor_cfg.quota_guard)
+        wqg = _build_quota_guard(vendor_cfg.weekly_quota_guard)
+        _vendor_map[vendor_cfg.vendor] = VendorTier(vendor=vendor, circuit_breaker=cb, quota_guard=qg, weekly_quota_guard=wqg)
+
+    # 阶段二：按 tiers 指定的顺序组装最终链路（或回退到 vendors 原始顺序）
+    if config.tiers is not None:
+        tiers = [_vendor_map[name] for name in config.tiers if name in _vendor_map]
+    else:
+        tiers = [_vendor_map[v.vendor] for v in config.vendors if v.enabled]
+
+    # 构建运行时重认证协调器
+    reauth_providers: dict[str, Any] = {}
+    token_updaters: dict[str, Any] = {}
+    for tier in tiers:
+        if isinstance(tier.vendor, CopilotVendor):
+            reauth_providers["github"] = GitHubDeviceFlowProvider()
+            token_updaters["github"] = tier.vendor._token_manager.update_github_token
+        elif isinstance(tier.vendor, AntigravityVendor):
+            reauth_providers["google"] = GoogleOAuthProvider()
+            token_updaters["google"] = tier.vendor._token_manager.update_refresh_token
+
+    reauth_coordinator: RuntimeReauthCoordinator | None = None
+    if reauth_providers:
+        reauth_coordinator = RuntimeReauthCoordinator(token_store, reauth_providers, token_updaters)
+
+    router = RequestRouter(tiers, token_logger, reauth_coordinator, compat_session_store)
+
+    app = FastAPI(title="coding-proxy", version="0.1.0", lifespan=lifespan)
+    app.state.router = router
+    app.state.token_logger = token_logger
+    app.state.compat_session_store = compat_session_store
+    app.state.config = config
+    app.state.reauth_coordinator = reauth_coordinator
+
+    # 注册所有路由端点
+    register_all_routes(app, router, reauth_coordinator)
+
+    return app