coding-proxy 0.1.0__py3-none-any.whl

coding/proxy/model/auth.py

@@ -0,0 +1,32 @@
+"""认证凭证数据模型.
+
+从 :mod:`coding.proxy.auth.store` 正交提取 ``ProviderTokens`` Pydantic model。
+``TokenStoreManager`` 持久化管理器保留在原模块。
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class ProviderTokens(BaseModel):
+    """单个 Provider 的 Token 凭证."""
+
+    access_token: str = ""
+    refresh_token: str = ""
+    expires_at: float = 0.0  # Unix timestamp
+    scope: str = ""
+    token_type: str = "bearer"
+    extra: dict[str, Any] = {}
+
+    @property
+    def is_expired(self) -> bool:
+        """检查 access_token 是否已过期（含 60 秒余量）."""
+        return self.expires_at > 0 and __import__("time").time() > self.expires_at - 60
+
+    @property
+    def has_credentials(self) -> bool:
+        """是否有可用凭证（access_token 或 refresh_token）."""
+        return bool(self.access_token or self.refresh_token)

coding/proxy/model/compat.py

@@ -0,0 +1,153 @@
+"""兼容层抽象类型 — 供应商无关的 Claude/Anthropic 语义模型.
+
+从 :mod:`coding.proxy.compat.canonical` 和
+:mod:`coding.proxy.compat.session_store` 正交提取纯声明式类型定义。
+构建逻辑（如 ``build_canonical_request()``）和持久化管理器（如
+``CompatSessionStore``）保留在原模块。
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any
+
+
+# ═══════════════════════════════════════════════════════════════
+# 消息部分类型体系
+# ═══════════════════════════════════════════════════════════════
+
+
+class CanonicalPartType(str, Enum):
+    """规范消息部分的类型枚举."""
+
+    TEXT = "text"
+    THINKING = "thinking"
+    IMAGE = "image"
+    TOOL_USE = "tool_use"
+    TOOL_RESULT = "tool_result"
+    UNKNOWN = "unknown"
+
+
+@dataclass(frozen=True)
+class CanonicalThinking:
+    """思考（extended thinking）能力参数."""
+
+    enabled: bool = False
+    budget_tokens: int | None = None
+    effort: str | None = None
+    source_field: str | None = None
+
+
+@dataclass(frozen=True)
+class CanonicalToolCall:
+    """工具调用记录."""
+
+    tool_id: str
+    name: str
+    arguments: dict[str, Any] = field(default_factory=dict)
+    provider_tool_id: str | None = None
+    provider_kind: str = "function"
+
+
+@dataclass(frozen=True)
+class CanonicalMessagePart:
+    """规范化的消息内容块."""
+
+    type: CanonicalPartType
+    role: str
+    text: str = ""
+    tool_call: CanonicalToolCall | None = None
+    tool_result_id: str | None = None
+    raw_block: dict[str, Any] | None = None
+
+
+@dataclass(frozen=True)
+class CanonicalRequest:
+    """规范化的完整请求抽象."""
+
+    session_key: str
+    trace_id: str
+    request_id: str
+    model: str
+    messages: list[CanonicalMessagePart]
+    thinking: CanonicalThinking
+    metadata: dict[str, Any]
+    tool_names: list[str]
+    supports_json_output: bool
+
+
+# ═══════════════════════════════════════════════════════════════
+# 兼容性评估类型体系
+# ═══════════════════════════════════════════════════════════════
+
+
+class CompatibilityStatus(str, Enum):
+    """供应商对某语义特性的兼容状态."""
+
+    NATIVE = "native"
+    SIMULATED = "simulated"
+    UNSAFE = "unsafe"
+    UNKNOWN = "unknown"
+
+
+@dataclass(frozen=True)
+class CompatibilityProfile:
+    """供应商各维度的兼容性画像."""
+
+    thinking: CompatibilityStatus = CompatibilityStatus.UNKNOWN
+    tool_calling: CompatibilityStatus = CompatibilityStatus.UNKNOWN
+    tool_streaming: CompatibilityStatus = CompatibilityStatus.UNKNOWN
+    mcp_tools: CompatibilityStatus = CompatibilityStatus.UNKNOWN
+    images: CompatibilityStatus = CompatibilityStatus.UNKNOWN
+    metadata: CompatibilityStatus = CompatibilityStatus.UNKNOWN
+    json_output: CompatibilityStatus = CompatibilityStatus.UNKNOWN
+    usage_tokens: CompatibilityStatus = CompatibilityStatus.UNKNOWN
+
+
+@dataclass(frozen=True)
+class CompatibilityDecision:
+    """单次请求的兼容性决策结果."""
+
+    status: CompatibilityStatus
+    simulation_actions: list[str] = field(default_factory=list)
+    unsupported_semantics: list[str] = field(default_factory=list)
+
+
+@dataclass
+class CompatibilityTrace:
+    """兼容性处理链路追踪记录."""
+
+    trace_id: str
+    vendor: str
+    session_key: str
+    provider_protocol: str
+    compat_mode: str
+    simulation_actions: list[str] = field(default_factory=list)
+    unsupported_semantics: list[str] = field(default_factory=list)
+    session_state_hits: int = 0
+    request_adaptations: list[str] = field(default_factory=list)
+    generated_at_unix: int = field(default_factory=lambda: int(__import__("time").time()))
+
+    def to_dict(self) -> dict[str, Any]:
+        from dataclasses import asdict
+
+        return asdict(self)
+
+
+# ═══════════════════════════════════════════════════════════════
+# 会话状态记录
+# ═══════════════════════════════════════════════════════════════
+
+
+@dataclass
+class CompatSessionRecord:
+    """兼容层会话持久化记录."""
+
+    session_key: str
+    trace_id: str = ""
+    tool_call_map: dict[str, str] = field(default_factory=dict)
+    thought_signature_map: dict[str, str] = field(default_factory=dict)
+    provider_state: dict[str, Any] = field(default_factory=dict)
+    state_version: int = 1
+    updated_at_unix: int = 0

coding/proxy/model/constants.py

@@ -0,0 +1,21 @@
+"""跨模块共享常量 — 协议级头部过滤规则与 Copilot 元数据."""
+
+# ── 代理转发头过滤规则 ─────────────────────────────────────
+
+# 代理转发时应跳过的 hop-by-hop 请求头
+PROXY_SKIP_HEADERS: frozenset[str] = frozenset({
+    "host", "content-length", "transfer-encoding", "connection",
+})
+
+# 构造合成 Response 时需移除的头部（避免 httpx 二次解压已解压内容）
+RESPONSE_SANITIZE_SKIP_HEADERS: frozenset[str] = frozenset({
+    "content-encoding", "content-length", "transfer-encoding",
+})
+
+# ── Copilot URL / 版本常量 ─────────────────────────────────
+
+_COPILOT_VERSION = "0.26.7"
+_EDITOR_VERSION = "vscode/1.98.0"
+_EDITOR_PLUGIN_VERSION = f"copilot-chat/{_COPILOT_VERSION}"
+_USER_AGENT = f"GitHubCopilotChat/{_COPILOT_VERSION}"
+_GITHUB_API_VERSION = "2025-04-01"

coding/proxy/model/pricing.py

@@ -0,0 +1,70 @@
+"""定价数据模型.
+
+从 :mod:`coding.proxy.pricing` 正交提取 ``ModelPricing`` dataclass。
+``PricingTable`` 查询与计算逻辑保留在原模块。
+
+本模块同时定义 ``Currency`` 枚举和 ``CostValue`` 值对象，
+支撑双币种（USD/CNY）计费能力。
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import StrEnum
+
+
+class Currency(StrEnum):
+    """支持的币种."""
+
+    USD = "USD"
+    CNY = "CNY"
+
+    @property
+    def symbol(self) -> str:
+        """货币显示符号."""
+        if self is Currency.USD:
+            return "$"
+        # CNY 及未来扩展币种
+        return "\u00a5"   # ¥ (U+00A5)
+
+    @classmethod
+    def default(cls) -> "Currency":
+        """默认币种（向后兼容：无前缀视为 USD）."""
+        return cls.USD
+
+
+# 模块级常量：币种 → 符号映射（供外部查询使用）
+_CURRENCY_SYMBOL_MAP: dict[Currency, str] = {
+    Currency.USD: "$",
+    Currency.CNY: "\u00a5",
+}
+
+
+@dataclass(frozen=True)
+class CostValue:
+    """带币种标注的费用值（Value Object，不可变）.
+
+    遵循 Value Object 模式：通过 ``(amount, currency)`` 判等，不可变。
+    """
+
+    amount: float
+    currency: Currency = Currency.default()
+
+    def format(self, precision: int = 4) -> str:
+        """格式化为 ``$0.1234`` 或 ``¥0.1234``."""
+        return f"{self.currency.symbol}{self.amount:.{precision}f}"
+
+    @property
+    def symbol(self) -> str:
+        return self.currency.symbol
+
+
+@dataclass
+class ModelPricing:
+    """单个模型的 Token 单价（含币种信息）."""
+
+    currency: Currency = Currency.default()
+    input_cost_per_token: float = 0.0
+    output_cost_per_token: float = 0.0
+    cache_creation_input_token_cost: float = 0.0
+    cache_read_input_token_cost: float = 0.0

coding/proxy/model/token.py

@@ -0,0 +1,64 @@
+"""Token 管理相关类型 — 枚举、异常与诊断数据类.
+
+从 :mod:`coding.proxy.vendors.token_manager` 正交提取纯声明式类型定义。
+``BaseTokenManager`` 抽象基类保留在原模块。
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+
+class TokenErrorKind(Enum):
+    """Token 获取失败分类."""
+
+    TEMPORARY = "temporary"
+    INVALID_CREDENTIALS = "invalid_credentials"
+    PERMISSION_UPGRADE_REQUIRED = "permission_upgrade_required"
+    INSUFFICIENT_SCOPE = "insufficient_scope"
+
+
+class TokenAcquireError(Exception):
+    """Token 获取失败.
+
+    needs_reauth=True 表示长期凭证已失效，需要重新执行浏览器 OAuth 登录。
+    needs_reauth=False 表示临时性故障（网络超时等），可自动恢复。
+    """
+
+    def __init__(self, message: str, *, needs_reauth: bool = False) -> None:
+        super().__init__(message)
+        self.needs_reauth = needs_reauth
+        self.kind = TokenErrorKind.TEMPORARY
+
+    @classmethod
+    def with_kind(
+        cls,
+        message: str,
+        *,
+        kind: TokenErrorKind,
+        needs_reauth: bool = False,
+    ) -> "TokenAcquireError":
+        err = cls(message, needs_reauth=needs_reauth)
+        err.kind = kind
+        return err
+
+
+@dataclass
+class TokenManagerDiagnostics:
+    """TokenManager 最近一次失败诊断信息."""
+
+    last_error: str = ""
+    needs_reauth: bool = False
+    error_kind: str = ""
+    updated_at: float = 0.0
+
+    def to_dict(self) -> dict[str, str | bool]:
+        if not self.last_error:
+            return {}
+        return {
+            "last_error": self.last_error,
+            "needs_reauth": self.needs_reauth,
+            "error_kind": self.error_kind,
+            "updated_at_unix": round(self.updated_at, 3),
+        }

coding/proxy/model/vendor.py

@@ -0,0 +1,218 @@
+"""供应商核心数据模型 — 类型定义、常量引用与工具函数.
+
+从本模块正交提取，遵循单一职责原则：
+- 数据类型：UsageInfo / CapabilityLossReason / RequestCapabilities /
+           VendorCapabilities / VendorResponse / NoCompatibleVendorError
+- Copilot 诊断数据类：CopilotMisdirectedRequest / CopilotExchangeDiagnostics /
+                      CopilotModelCatalog
+- 工具函数：JSON 解析、错误消息提取、响应头清洗
+- 常量引用：自 :mod:`coding.proxy.model.constants` 重导出
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any
+
+import httpx
+
+from .constants import PROXY_SKIP_HEADERS, RESPONSE_SANITIZE_SKIP_HEADERS
+
+
+# ═══════════════════════════════════════════════════════════════
+# 工具函数（公开 API，去除原 _ 前缀）
+# ═══════════════════════════════════════════════════════════════
+
+
+def sanitize_headers_for_synthetic_response(headers: httpx.Headers) -> dict[str, str]:
+    """移除 content-encoding 等头部，避免合成 httpx.Response 时触发二次解压."""
+    return {k: v for k, v in headers.items() if k.lower() not in RESPONSE_SANITIZE_SKIP_HEADERS}
+
+
+def decode_json_body(response: httpx.Response) -> dict[str, Any] | list[Any] | None:
+    """安全解析 JSON 响应.
+
+    若 content-type 未声明 JSON 或内容非法，返回 None，而不是抛 JSONDecodeError。
+    """
+    if not response.content:
+        return None
+
+    content_type = response.headers.get("content-type", "").lower()
+    if "json" not in content_type:
+        try:
+            return json.loads(response.content)
+        except (json.JSONDecodeError, UnicodeDecodeError, TypeError):
+            return None
+
+    try:
+        return response.json()
+    except (json.JSONDecodeError, UnicodeDecodeError, TypeError):
+        return None
+
+
+def extract_error_message(response: httpx.Response, resp_body: dict[str, Any] | list[Any] | None) -> str | None:
+    """从 HTTP 响应中提取可读错误消息."""
+    if isinstance(resp_body, dict):
+        error = resp_body.get("error")
+        if isinstance(error, dict):
+            return error.get("message")
+        if isinstance(error, str):
+            return error
+        message = resp_body.get("message")
+        if isinstance(message, str):
+            return message
+
+    if not response.content:
+        return None
+    text = response.text.strip()
+    return text[:500] if text else None
+
+
+# ═══════════════════════════════════════════════════════════════
+# 供应商核心数据类型
+# ═══════════════════════════════════════════════════════════════
+
+
+@dataclass
+class UsageInfo:
+    """一次调用的 Token 用量."""
+
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cache_creation_tokens: int = 0
+    cache_read_tokens: int = 0
+    request_id: str = ""
+
+
+class CapabilityLossReason(Enum):
+    """请求语义与供应商能力不匹配的原因."""
+
+    TOOLS = "tools"
+    THINKING = "thinking"
+    IMAGES = "images"
+    VENDOR_TOOLS = "vendor_tools"
+    METADATA = "metadata"
+
+
+@dataclass(frozen=True)
+class RequestCapabilities:
+    """一次请求实际使用到的能力画像."""
+
+    has_tools: bool = False
+    has_thinking: bool = False
+    has_images: bool = False
+    has_metadata: bool = False
+
+
+@dataclass(frozen=True)
+class VendorCapabilities:
+    """供应商能力声明."""
+
+    supports_tools: bool = True
+    supports_thinking: bool = True
+    supports_images: bool = True
+    emits_vendor_tool_events: bool = False
+    supports_metadata: bool = True
+
+
+@dataclass
+class VendorResponse:
+    """供应商响应结果."""
+
+    status_code: int = 200
+    usage: UsageInfo = field(default_factory=UsageInfo)
+    is_streaming: bool = False
+    raw_body: bytes = b"{}"
+    error_type: str | None = None
+    error_message: str | None = None
+    model_served: str | None = None
+    response_headers: dict[str, str] = field(default_factory=dict)
+
+
+class NoCompatibleVendorError(RuntimeError):
+    """当前请求没有可安全承接的供应商."""
+
+    def __init__(self, message: str, *, reasons: list[str] | None = None) -> None:
+        super().__init__(message)
+        self.reasons = reasons or []
+
+
+# ═══════════════════════════════════════════════════════════════
+# Copilot 诊断数据类
+# ═══════════════════════════════════════════════════════════════
+
+
+@dataclass
+class CopilotMisdirectedRequest:
+    """Copilot 421 Misdirected 请求诊断载体."""
+
+    base_url: str
+    status_code: int
+    request: Any  # httpx.Request (avoid circular import at module level)
+    headers: Any  # httpx.Headers
+    body: bytes
+
+
+@dataclass
+class CopilotExchangeDiagnostics:
+    """最近一次 Copilot token 交换的运行时诊断."""
+
+    raw_shape: str = ""
+    token_field: str = ""
+    expires_in_seconds: int = 0
+    expires_at_unix: int = 0
+    capabilities: dict[str, Any] = field(default_factory=dict)
+    updated_at_unix: int = 0
+
+    def to_dict(self) -> dict[str, Any]:
+        data: dict[str, Any] = {}
+        if self.raw_shape:
+            data["raw_shape"] = self.raw_shape
+        if self.token_field:
+            data["token_field"] = self.token_field
+        if self.expires_in_seconds:
+            data["expires_in_seconds"] = self.expires_in_seconds
+        if self.expires_at_unix:
+            data["ttl_seconds"] = max(self.expires_at_unix - int(__import__("time").time()), 0)
+        if self.capabilities:
+            data["capabilities"] = self.capabilities
+        if self.updated_at_unix:
+            data["updated_at"] = self.updated_at_unix
+        return data
+
+
+@dataclass
+class CopilotModelCatalog:
+    """Copilot 模型目录缓存."""
+
+    available_models: list[str] = field(default_factory=list)
+    fetched_at_unix: int = 0
+
+    def age_seconds(self) -> int | None:
+        if not self.fetched_at_unix:
+            return None
+        return max(int(__import__("time").time()) - self.fetched_at_unix, 0)
+
+
+# ═══════════════════════════════════════════════════════════════
+# 向后兼容别名（v2 移除）
+# ═══════════════════════════════════════════════════════════════
+
+BackendCapabilities = VendorCapabilities
+BackendResponse = VendorResponse
+NoCompatibleBackendError = NoCompatibleVendorError
+
+__all__ = [
+    # 新命名
+    "VendorCapabilities", "VendorResponse", "NoCompatibleVendorError",
+    # 向后兼容别名
+    "BackendCapabilities", "BackendResponse", "NoCompatibleBackendError",
+    # 通用类型（不变）
+    "UsageInfo", "CapabilityLossReason", "RequestCapabilities",
+    # Copilot 诊断类
+    "CopilotExchangeDiagnostics", "CopilotMisdirectedRequest", "CopilotModelCatalog",
+    # 工具函数
+    "decode_json_body", "extract_error_message", "sanitize_headers_for_synthetic_response",
+]

coding/proxy/pricing.py

@@ -0,0 +1,100 @@
+"""模型定价表.
+
+基于配置文件中的手动定价条目，按 (vendor, model_served) 计算 Cost。
+
+``ModelPricing`` / ``Currency`` / ``CostValue`` 数据模型已迁移至 :mod:`coding.proxy.model.pricing`。
+本文件保留 ``PricingTable`` 查询与计算逻辑，类型通过 re-export 提供。
+
+.. deprecated::
+    未来版本将移除类型 re-export，请直接从 :mod:`coding.proxy.model.pricing` 导入。
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import TYPE_CHECKING
+
+# noqa: F401
+from .model.pricing import CostValue, Currency, ModelPricing
+
+if TYPE_CHECKING:
+    from .config.schema import ModelPricingEntry
+
+logger = logging.getLogger(__name__)
+
+
+def _normalize(name: str) -> str:
+    """规范化模型名称以提升匹配成功率.
+
+    规则：
+    - 去除 @版本后缀（如 @20241022）
+    - 将 `.` 替换为 `-`
+    - 转小写
+    """
+    name = re.sub(r"@[\w.]+$", "", name)
+    return name.replace(".", "-").lower()
+
+
+class PricingTable:
+    """基于配置文件的本地定价表，支持按 (vendor, model_served) 查询单价."""
+
+    def __init__(self, entries: list[ModelPricingEntry]) -> None:
+        self._index: dict[tuple[str, str], ModelPricing] = {}
+        for entry in entries:
+            pricing = ModelPricing(
+                currency=Currency(entry.currency),
+                input_cost_per_token=entry.input_cost_per_mtok / 1e6,
+                output_cost_per_token=entry.output_cost_per_mtok / 1e6,
+                cache_creation_input_token_cost=entry.cache_write_cost_per_mtok / 1e6,
+                cache_read_input_token_cost=entry.cache_read_cost_per_mtok / 1e6,
+            )
+            # 精确匹配
+            self._index[(entry.vendor, entry.model)] = pricing
+            # 规范化匹配（如 "glm-4.5-air" → "glm-4-5-air"）
+            norm = _normalize(entry.model)
+            if norm != entry.model:
+                self._index.setdefault((entry.vendor, norm), pricing)
+
+        if entries:
+            logger.info("定价表加载成功，共 %d 条模型配置", len(entries))
+
+    # ── 单价查询 ──────────────────────────────────────────────
+
+    def get_pricing(self, vendor: str, model_served: str) -> ModelPricing | None:
+        """获取 (vendor, model_served) 对应的 ModelPricing.
+
+        查找顺序：
+        1. 精确匹配：(vendor, model_served)
+        2. 规范化匹配：(vendor, normalized(model_served))
+        """
+        hit = self._index.get((vendor, model_served))
+        if hit is not None:
+            return hit
+        return self._index.get((vendor, _normalize(model_served)))
+
+    # ── 费用计算 ──────────────────────────────────────────────
+
+    def compute_cost(
+        self,
+        vendor: str,
+        model_served: str,
+        input_tokens: int,
+        output_tokens: int,
+        cache_creation_tokens: int,
+        cache_read_tokens: int,
+    ) -> CostValue | None:
+        """按单价计算总费用（含币种信息）.
+
+        返回 :class:`CostValue`（携带币种），若无匹配定价返回 None。
+        """
+        pricing = self.get_pricing(vendor, model_served)
+        if pricing is None:
+            return None
+        amount = (
+            input_tokens * pricing.input_cost_per_token
+            + output_tokens * pricing.output_cost_per_token
+            + cache_creation_tokens * pricing.cache_creation_input_token_cost
+            + cache_read_tokens * pricing.cache_read_input_token_cost
+        )
+        return CostValue(amount=amount, currency=pricing.currency)