coding-proxy 0.1.0__py3-none-any.whl

coding/proxy/server/factory.py

@@ -0,0 +1,175 @@
+"""FastAPI 应用工厂函数 — 供应商实例化与凭证解析."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any
+
+from ..auth.providers.google import (
+    GoogleOAuthProvider,
+    _DEFAULT_CLIENT_ID as _GOOGLE_DEFAULT_CLIENT_ID,
+    _DEFAULT_CLIENT_SECRET as _GOOGLE_DEFAULT_CLIENT_SECRET,
+    _REQUIRED_SCOPE_SET as _GOOGLE_REQUIRED_SCOPE_SET,
+)
+from ..auth.runtime import RuntimeReauthCoordinator
+from ..auth.store import TokenStoreManager
+from ..vendors.antigravity import AntigravityVendor
+from ..vendors.anthropic import AnthropicVendor
+from ..vendors.copilot import CopilotVendor
+from ..vendors.zhipu import ZhipuVendor
+from ..config.schema import (
+    AntigravityConfig,
+    AnthropicConfig,
+    CircuitBreakerConfig,
+    CopilotConfig,
+    FailoverConfig,
+    QuotaGuardConfig,
+    TierConfig,
+    ZhipuConfig,
+)
+from ..routing.circuit_breaker import CircuitBreaker
+from ..routing.model_mapper import ModelMapper
+from ..routing.quota_guard import QuotaGuard
+from ..routing.tier import VendorTier
+# 向后兼容别名
+BackendTier = VendorTier  # noqa: F401  (deprecated)
+
+logger = logging.getLogger(__name__)
+
+
+def _find_anthropic_vendor(router: Any) -> AnthropicVendor | None:
+    """从路由链中查找 Anthropic 供应商实例（用于旁路透传）."""
+    for tier in router.tiers:
+        if isinstance(tier.vendor, AnthropicVendor):
+            return tier.vendor
+    return None
+
+
+def _find_copilot_vendor(router: Any) -> CopilotVendor | None:
+    """从路由链中查找 Copilot 供应商实例（用于诊断与模型探测）."""
+    for tier in router.tiers:
+        if isinstance(tier.vendor, CopilotVendor):
+            return tier.vendor
+    return None
+
+
+def _build_circuit_breaker(cfg: CircuitBreakerConfig) -> CircuitBreaker:
+    """从配置构建熔断器实例."""
+    return CircuitBreaker(
+        failure_threshold=cfg.failure_threshold,
+        recovery_timeout_seconds=cfg.recovery_timeout_seconds,
+        success_threshold=cfg.success_threshold,
+        max_recovery_seconds=cfg.max_recovery_seconds,
+    )
+
+
+def _build_quota_guard(cfg: QuotaGuardConfig) -> QuotaGuard:
+    """从配置构建配额守卫实例."""
+    return QuotaGuard(
+        enabled=cfg.enabled,
+        token_budget=cfg.token_budget,
+        window_seconds=int(cfg.window_hours * 3600),
+        threshold_percent=cfg.threshold_percent,
+        probe_interval_seconds=cfg.probe_interval_seconds,
+    )
+
+
+def _create_vendor_from_config(
+    vendor_cfg: TierConfig,
+    failover_cfg: FailoverConfig,
+    mapper: ModelMapper,
+    token_store: TokenStoreManager,
+) -> Any:
+    """根据 vendor_cfg.vendor 创建对应供应商实例（Strategy + Factory 模式）."""
+    match vendor_cfg.vendor:
+        case "anthropic":
+            cfg = AnthropicConfig(
+                enabled=vendor_cfg.enabled,
+                base_url=vendor_cfg.base_url or "https://api.anthropic.com",
+                timeout_ms=vendor_cfg.timeout_ms,
+            )
+            return AnthropicVendor(cfg, failover_cfg)
+        case "copilot":
+            cfg = CopilotConfig(
+                enabled=vendor_cfg.enabled,
+                github_token=vendor_cfg.github_token,
+                account_type=vendor_cfg.account_type,
+                token_url=vendor_cfg.token_url,
+                base_url=vendor_cfg.base_url,
+                models_cache_ttl_seconds=vendor_cfg.models_cache_ttl_seconds,
+                timeout_ms=vendor_cfg.timeout_ms,
+            )
+            cfg = _resolve_copilot_credentials(cfg, token_store)
+            return CopilotVendor(cfg, failover_cfg, mapper)
+        case "antigravity":
+            cfg = AntigravityConfig(
+                enabled=vendor_cfg.enabled,
+                client_id=vendor_cfg.client_id,
+                client_secret=vendor_cfg.client_secret,
+                refresh_token=vendor_cfg.refresh_token,
+                base_url=vendor_cfg.base_url or "https://generativelanguage.googleapis.com/v1beta",
+                model_endpoint=vendor_cfg.model_endpoint,
+                timeout_ms=vendor_cfg.timeout_ms,
+            )
+            cfg = _resolve_antigravity_credentials(cfg, token_store)
+            return AntigravityVendor(cfg, failover_cfg, mapper)
+        case "zhipu":
+            cfg = ZhipuConfig(
+                enabled=vendor_cfg.enabled,
+                base_url=vendor_cfg.base_url or "https://open.bigmodel.cn/api/anthropic",
+                api_key=vendor_cfg.api_key,
+                timeout_ms=vendor_cfg.timeout_ms,
+            )
+            return ZhipuVendor(cfg, mapper)
+        case _:
+            raise ValueError(f"未知的 vendor 类型: {vendor_cfg.vendor!r}")
+
+
+def _resolve_copilot_credentials(cfg: CopilotConfig, token_store: TokenStoreManager) -> CopilotConfig:
+    """合并 Copilot 凭证: Token Store > Config YAML.
+
+    返回更新后的 CopilotConfig（github_token 已填充）。
+    """
+    if cfg.github_token:
+        return cfg  # config.yaml 已有凭证，直接使用
+
+    tokens = token_store.get("github")
+    if tokens.access_token:
+        cfg = cfg.model_copy(update={"github_token": tokens.access_token})
+        logger.info("Copilot: 使用 Token Store 中的 GitHub 凭证")
+
+    return cfg
+
+
+def _resolve_antigravity_credentials(cfg: AntigravityConfig, token_store: TokenStoreManager) -> AntigravityConfig:
+    """合并 Antigravity 凭证: Token Store > Config YAML.
+
+    优先使用 Token Store 中的 refresh_token；
+    若 config.yaml 已有完整凭证（client_id + client_secret + refresh_token），则直接使用。
+    """
+    if cfg.refresh_token:
+        return cfg  # config.yaml 已有凭证，直接使用
+
+    tokens = token_store.get("google")
+    if tokens.refresh_token:
+        updates: dict[str, str] = {"refresh_token": tokens.refresh_token}
+        # 若 config.yaml 缺少 OAuth 凭据，使用默认公开凭据
+        if not cfg.client_id:
+            updates["client_id"] = _GOOGLE_DEFAULT_CLIENT_ID
+        if not cfg.client_secret:
+            updates["client_secret"] = _GOOGLE_DEFAULT_CLIENT_SECRET
+        cfg = cfg.model_copy(update=updates)
+        logger.info("Antigravity: 使用 Token Store 中的 Google 凭证")
+        if tokens.scope and not GoogleOAuthProvider.has_required_scopes(tokens.scope):
+            missing = sorted(_GOOGLE_REQUIRED_SCOPE_SET.difference(tokens.scope.split()))
+            logger.warning("Antigravity: Token Store 中的 Google scope 不完整，缺少: %s", ", ".join(missing))
+
+    return cfg
+
+
+# ── 向后兼容别名 (deprecated) ──────────────────────────────
+
+_find_anthropic_backend = _find_anthropic_vendor  # noqa: F401
+_find_copilot_backend = _find_copilot_vendor  # noqa: F401
+_create_backend_from_tier = _create_vendor_from_config  # noqa: F401

coding/proxy/server/request_normalizer.py

@@ -0,0 +1,139 @@
+"""入站 Anthropic Messages 请求规范化."""
+
+from __future__ import annotations
+
+import copy
+import re
+from dataclasses import dataclass, field
+from typing import Any
+
+
+_ANTHROPIC_TOOL_USE_ID_RE = re.compile(r"^toolu_[A-Za-z0-9_]+$")
+_ANTHROPIC_SERVER_TOOL_USE_ID_RE = re.compile(r"^srvtoolu_[A-Za-z0-9_]+$")
+_VENDOR_TOOL_BLOCK_TYPES = {
+    "server_tool_use_delta",
+}
+
+
+@dataclass
+class NormalizationResult:
+    """请求规范化结果."""
+
+    body: dict[str, Any]
+    adaptations: list[str] = field(default_factory=list)
+    fatal_reasons: list[str] = field(default_factory=list)
+
+    @property
+    def recoverable(self) -> bool:
+        return not self.fatal_reasons
+
+
+def normalize_anthropic_request(body: dict[str, Any]) -> NormalizationResult:
+    """清洗供应商私有块，尽量恢复为合法 Anthropic Messages 请求."""
+    normalized = copy.deepcopy(body)
+    adaptations: list[str] = []
+    fatal_reasons: list[str] = []
+    tool_id_map: dict[str, str] = {}
+    normalized_counter = 0
+
+    def next_tool_id() -> str:
+        nonlocal normalized_counter
+        normalized_counter += 1
+        return f"toolu_normalized_{normalized_counter}"
+
+    def normalize_content_block(
+        block: Any,
+        *,
+        message_role: str,
+        message_index: int,
+        block_index: int,
+    ) -> dict[str, Any] | None:
+        if not isinstance(block, dict):
+            return None
+
+        block_type = block.get("type")
+        if block_type in _VENDOR_TOOL_BLOCK_TYPES:
+            adaptations.append(f"vendor_block_removed:{block_type}")
+            return None
+
+        if message_role == "assistant" and block_type in {"tool_use", "server_tool_use"}:
+            normalized_block = dict(block)
+            tool_id = normalized_block.get("id")
+            if isinstance(tool_id, str) and _ANTHROPIC_SERVER_TOOL_USE_ID_RE.match(tool_id):
+                new_id = next_tool_id()
+                tool_id_map[tool_id] = new_id
+                normalized_block["id"] = new_id
+                normalized_block["type"] = "tool_use"
+                adaptations.append("server_tool_use_id_rewritten_for_anthropic")
+            elif isinstance(tool_id, str) and _ANTHROPIC_TOOL_USE_ID_RE.match(tool_id):
+                normalized_block["type"] = "tool_use"
+            elif isinstance(tool_id, str) and tool_id:
+                if "name" in normalized_block:
+                    new_id = next_tool_id()
+                    tool_id_map[tool_id] = new_id
+                    normalized_block["id"] = new_id
+                    normalized_block["type"] = "tool_use"
+                    adaptations.append("invalid_tool_use_id_rewritten_for_anthropic")
+                else:
+                    fatal_reasons.append(
+                        f"messages.{message_index}.content.{block_index}: tool block missing name for id rewrite"
+                    )
+                    return None
+            else:
+                fatal_reasons.append(
+                    f"messages.{message_index}.content.{block_index}: tool block missing id"
+                )
+                return None
+            return normalized_block
+
+        if message_role == "user" and block_type == "tool_result":
+            normalized_block = dict(block)
+            tool_use_id = normalized_block.get("tool_use_id")
+            if isinstance(tool_use_id, str) and tool_use_id in tool_id_map:
+                normalized_block["tool_use_id"] = tool_id_map[tool_use_id]
+                adaptations.append("tool_result_tool_use_id_rewritten")
+            elif isinstance(tool_use_id, str) and (
+                _ANTHROPIC_TOOL_USE_ID_RE.match(tool_use_id)
+                or _ANTHROPIC_SERVER_TOOL_USE_ID_RE.match(tool_use_id)
+            ):
+                # 保持原样。对 server_tool_use_id 的用户结果，若未在当前请求体中出现，
+                # 交由上游决定是否接受，避免错误猜测跨轮次关联。
+                return normalized_block
+            elif isinstance(tool_use_id, str) and tool_use_id:
+                fatal_reasons.append(
+                    f"messages.{message_index}.content.{block_index}: tool_result references unknown tool_use_id"
+                )
+                return None
+            else:
+                fatal_reasons.append(
+                    f"messages.{message_index}.content.{block_index}: tool_result missing tool_use_id"
+                )
+                return None
+            return normalized_block
+
+        return dict(block)
+
+    for message_index, message in enumerate(normalized.get("messages", [])):
+        if not isinstance(message, dict):
+            continue
+        content = message.get("content")
+        if not isinstance(content, list):
+            continue
+        role = str(message.get("role") or "")
+        new_content: list[Any] = []
+        for block_index, block in enumerate(content):
+            normalized_block = normalize_content_block(
+                block,
+                message_role=role,
+                message_index=message_index,
+                block_index=block_index,
+            )
+            if normalized_block is not None:
+                new_content.append(normalized_block)
+        message["content"] = new_content
+
+    return NormalizationResult(
+        body=normalized,
+        adaptations=sorted(set(adaptations)),
+        fatal_reasons=fatal_reasons,
+    )

coding/proxy/server/responses.py

@@ -0,0 +1,74 @@
+"""HTTP 错误响应构造工具."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import httpx
+from fastapi import Response
+
+
+def json_error_response(
+    status_code: int,
+    *,
+    error_type: str,
+    message: str,
+    details: list[str] | None = None,
+) -> Response:
+    """构造 JSON 格式的错误响应."""
+    payload: dict[str, Any] = {
+        "error": {
+            "type": error_type,
+            "message": message,
+        }
+    }
+    if details:
+        payload["error"]["details"] = details
+    return Response(
+        content=json.dumps(payload, ensure_ascii=False).encode(),
+        status_code=status_code,
+        media_type="application/json",
+    )
+
+
+def stream_error_event(error_type: str, message: str, details: list[str] | None = None) -> bytes:
+    """构造 SSE 格式的错误事件."""
+    payload: dict[str, Any] = {
+        "type": "error",
+        "error": {
+            "type": error_type,
+            "message": message,
+        },
+    }
+    if details:
+        payload["error"]["details"] = details
+    return f"event: error\ndata: {json.dumps(payload, ensure_ascii=False)}\n\n".encode()
+
+
+def extract_stream_http_error(exc: httpx.HTTPStatusError) -> tuple[str, str]:
+    """从 HTTPStatusError 中提取错误类型和消息."""
+    response = exc.response
+    if response is None:
+        return "api_error", str(exc)
+
+    try:
+        payload = response.json() if response.content else None
+    except (json.JSONDecodeError, UnicodeDecodeError, TypeError, ValueError):
+        payload = None
+
+    if isinstance(payload, dict):
+        error = payload.get("error")
+        if isinstance(error, dict):
+            error_type = error.get("type")
+            message = error.get("message")
+            if isinstance(error_type, str) and isinstance(message, str) and message:
+                return error_type, message
+        message = payload.get("message")
+        if isinstance(message, str) and message:
+            return "api_error", message
+
+    text = response.text.strip() if response.content else ""
+    if text:
+        return "api_error", text[:500]
+    return "api_error", str(exc)

coding/proxy/server/routes.py

@@ -0,0 +1,264 @@
+"""路由注册 — 将 FastAPI 路由端点按职责分组注册到 app 实例."""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any
+
+import httpx
+from fastapi import Request, Response
+from fastapi.responses import StreamingResponse
+
+from ..vendors.base import NoCompatibleVendorError
+# 向后兼容别名
+NoCompatibleBackendError = NoCompatibleVendorError  # noqa: F401  (deprecated)
+from ..vendors.token_manager import TokenAcquireError
+from .responses import (
+    extract_stream_http_error,
+    json_error_response,
+    stream_error_event,
+)
+
+logger = logging.getLogger(__name__)
+
+
+async def _stream_proxy(router: Any, body: dict, headers: dict) -> Any:
+    """流式代理生成器."""
+    try:
+        async for chunk, vendor_name in router.route_stream(body, headers):
+            yield chunk
+    except NoCompatibleVendorError as exc:
+        yield (
+            "event: error\n"
+            f"data: {json.dumps({'type': 'error', 'error': {'type': 'invalid_request_error', 'message': str(exc), 'details': exc.reasons}}, ensure_ascii=False)}\n\n"
+        ).encode()
+    except TokenAcquireError as exc:
+        yield (
+            "event: error\n"
+            f"data: {json.dumps({'type': 'error', 'error': {'type': 'authentication_error', 'message': str(exc)}}, ensure_ascii=False)}\n\n"
+        ).encode()
+    except (httpx.TimeoutException, httpx.ConnectError, httpx.ReadError) as exc:
+        yield stream_error_event("api_error", f"上游不可达: {exc}")
+    except httpx.HTTPStatusError as exc:
+        error_type, message = extract_stream_http_error(exc)
+        yield stream_error_event(error_type, message)
+    except Exception as exc:
+        logger.error(
+            "_stream_proxy 未预期异常: %s: %s",
+            type(exc).__name__, exc,
+            exc_info=True,
+        )
+        yield stream_error_event(
+            "api_error",
+            f"内部错误: {type(exc).__name__}: {exc}",
+        )
+
+
+def register_core_routes(app: Any, router: Any) -> None:
+    """注册核心 API 路由：消息代理与 Token 计数."""
+    from .request_normalizer import normalize_anthropic_request
+
+    @app.post("/v1/messages")
+    async def messages(request: Request) -> Response:
+        """Anthropic Messages API 代理端点."""
+        body = await request.json()
+        headers = dict(request.headers)
+        normalization = normalize_anthropic_request(body)
+        body = normalization.body
+        is_streaming = body.get("stream", False)
+
+        if normalization.adaptations:
+            logger.debug("Request normalized before routing: %s", ", ".join(normalization.adaptations))
+
+        if is_streaming:
+            return StreamingResponse(
+                _stream_proxy(router, body, headers),
+                media_type="text/event-stream",
+                headers={"Cache-Control": "no-cache", "Connection": "keep-alive"},
+            )
+
+        try:
+            resp = await router.route_message(body, headers)
+        except NoCompatibleVendorError as exc:
+            return json_error_response(400, error_type="invalid_request_error", message=str(exc), details=exc.reasons)
+        except TokenAcquireError as exc:
+            return json_error_response(503, error_type="authentication_error", message=str(exc))
+        except (httpx.TimeoutException, httpx.ConnectError, httpx.ReadError) as exc:
+            return json_error_response(502, error_type="api_error", message=f"上游不可达: {exc}")
+        except Exception as exc:
+            logger.error(
+                "messages() 非流式路径未预期异常: %s: %s",
+                type(exc).__name__, exc,
+                exc_info=True,
+            )
+            return json_error_response(500, error_type="api_error", message=f"内部错误: {type(exc).__name__}")
+
+        # 对上游返回的非标准错误格式输出诊断日志（如 Zhipu 使用 code 而非 type）
+        if resp.status_code >= 500 and resp.raw_body:
+            try:
+                payload = json.loads(resp.raw_body)
+                if isinstance(payload, dict) and "error" in payload:
+                    err = payload["error"]
+                    if isinstance(err, dict) and "type" not in err and "code" in err:
+                        logger.debug(
+                            "检测到非标准上游错误格式（含 code 非 type）: vendor_error=%s",
+                            json.dumps(err, ensure_ascii=False)[:200],
+                        )
+            except (json.JSONDecodeError, UnicodeDecodeError):
+                pass
+
+        return Response(content=resp.raw_body or b"{}", status_code=resp.status_code, media_type="application/json")
+
+    @app.post("/v1/messages/count_tokens")
+    async def count_tokens(request: Request) -> Response:
+        """Token 计数 API 透传 — 旁路直通 Anthropic，不经过路由链.
+
+        仅当 Anthropic 主供应商启用时可用；其他供应商不支持此协议。
+        """
+        from .factory import _find_anthropic_vendor
+
+        anthropic_vendor = _find_anthropic_vendor(router)
+        if anthropic_vendor is None:
+            return Response(
+                content=b'{"error":{"type":"not_found","message":"count_tokens requires anthropic vendor"}}',
+                status_code=404,
+                media_type="application/json",
+            )
+
+        body = await request.json()
+        headers = dict(request.headers)
+        prepared_body, prepared_headers = await anthropic_vendor._prepare_request(body, headers)
+
+        client = anthropic_vendor._get_client()
+        url = "/v1/messages/count_tokens"
+        if request.query_params:
+            url = f"{url}?{request.query_params}"
+
+        try:
+            response = await client.post(url, json=prepared_body, headers=prepared_headers)
+            return Response(content=response.content, status_code=response.status_code, media_type="application/json")
+        except (httpx.TimeoutException, httpx.ConnectError, httpx.ReadError) as exc:
+            logger.warning("count_tokens proxy failed: %s", exc)
+            return Response(
+                content=b'{"error":{"type":"api_error","message":"count_tokens upstream unreachable"}}',
+                status_code=502,
+                media_type="application/json",
+            )
+
+
+def register_health_routes(app: Any) -> None:
+    """注册健康检查与连通性探测路由."""
+
+    @app.get("/health")
+    async def health() -> dict:
+        return {"status": "ok"}
+
+    @app.head("/")
+    @app.get("/")
+    async def root() -> Response:
+        """根路径连通性探测 — Claude Code 在建连前发送 HEAD / 作为 health probe."""
+        return Response(status_code=200)
+
+
+def register_status_route(app: Any, router: Any) -> None:
+    """注册状态查询路由."""
+
+    @app.get("/api/status")
+    async def status() -> dict:
+        result: dict[str, Any] = {"tiers": []}
+        for tier in router.tiers:
+            info: dict[str, Any] = {"name": tier.name}
+            if tier.circuit_breaker:
+                info["circuit_breaker"] = tier.circuit_breaker.get_info()
+            if tier.quota_guard and tier.quota_guard.enabled:
+                info["quota_guard"] = tier.quota_guard.get_info()
+            if tier.weekly_quota_guard and tier.weekly_quota_guard.enabled:
+                info["weekly_quota_guard"] = tier.weekly_quota_guard.get_info()
+            info["rate_limit"] = tier.get_rate_limit_info()
+            diagnostics = tier.vendor.get_diagnostics()
+            if diagnostics:
+                info["diagnostics"] = diagnostics
+            result["tiers"].append(info)
+        return result
+
+
+def register_copilot_routes(app: Any, router: Any) -> None:
+    """注册 Copilot 诊断与模型探测路由."""
+    from .factory import _find_copilot_vendor
+
+    @app.get("/api/copilot/diagnostics")
+    async def copilot_diagnostics() -> Response:
+        """返回 Copilot 认证与交换链路的脱敏诊断信息."""
+        vendor = _find_copilot_vendor(router)
+        if vendor is None:
+            return json_error_response(404, error_type="not_found", message="copilot vendor not enabled")
+        return Response(
+            content=json.dumps(vendor.get_diagnostics(), ensure_ascii=False).encode(),
+            status_code=200,
+            media_type="application/json",
+        )
+
+    @app.get("/api/copilot/models")
+    async def copilot_models() -> Response:
+        """按需探测当前 Copilot 会话可见模型列表."""
+        vendor = _find_copilot_vendor(router)
+        if vendor is None:
+            return json_error_response(404, error_type="not_found", message="copilot vendor not enabled")
+        try:
+            probe = await vendor.probe_models()
+        except TokenAcquireError as exc:
+            return json_error_response(503, error_type="authentication_error", message=str(exc))
+        except (httpx.TimeoutException, httpx.ConnectError) as exc:
+            return json_error_response(502, error_type="api_error", message=f"copilot models probe failed: {exc}")
+        return Response(
+            content=json.dumps(probe, ensure_ascii=False).encode(),
+            status_code=200 if probe.get("probe_status") == "ok" else 502,
+            media_type="application/json",
+        )
+
+
+def register_admin_routes(app: Any, router: Any) -> None:
+    """注册管理操作路由（重置等）."""
+
+    @app.post("/api/reset")
+    async def reset_circuit() -> dict:
+        for tier in router.tiers:
+            if tier.circuit_breaker:
+                tier.circuit_breaker.reset()
+            if tier.quota_guard:
+                tier.quota_guard.reset()
+            if tier.weekly_quota_guard:
+                tier.weekly_quota_guard.reset()
+            tier.reset_rate_limit()
+        return {"status": "ok"}
+
+
+def register_reauth_routes(app: Any, reauth_coordinator: Any) -> None:
+    """注册重认证路由."""
+
+    @app.get("/api/reauth/status")
+    async def reauth_status() -> dict:
+        """查询运行时重认证状态."""
+        if not reauth_coordinator:
+            return {"providers": {}}
+        return {"providers": reauth_coordinator.get_status()}
+
+    @app.post("/api/reauth/{provider}")
+    async def trigger_reauth(provider: str) -> Response:
+        """手动触发指定 provider 的运行时重认证."""
+        if not reauth_coordinator:
+            return Response(content=b'{"error":"reauth not available"}', status_code=404, media_type="application/json")
+        await reauth_coordinator.request_reauth(provider)
+        return Response(content=b'{"status":"reauth requested"}', status_code=202, media_type="application/json")
+
+
+def register_all_routes(app: Any, router: Any, reauth_coordinator: Any | None = None) -> None:
+    """一次性注册所有路由分组."""
+    register_core_routes(app, router)
+    register_health_routes(app)
+    register_status_route(app, router)
+    register_copilot_routes(app, router)
+    register_admin_routes(app, router)
+    if reauth_coordinator:
+        register_reauth_routes(app, reauth_coordinator)

coding/proxy/streaming/__init__.py

@@ -0,0 +1 @@
+"""流处理模块."""