Aether/_deprecated_py_src/services/provider/adapters/codex/plugin.py

"""Codex provider plugin — 统一注册入口。

将 Codex 对各通用 registry / capability registry 的注册集中在一个文件中：
- Transport Hook (URL 构建)
- Auth Enricher (OAuth enrichment)
- Provider Format Capability（默认 body_rules）
- Model Fetcher (fixed catalog — Codex has no /v1/models endpoint)

新增 provider 时参照此文件创建对应的 plugin.py 即可。
"""

from __future__ import annotations

import hashlib
from collections.abc import Mapping
from typing import Any
from urllib.parse import urlencode

from src.core.logger import logger

# ---------------------------------------------------------------------------
# Preset model catalog
# ---------------------------------------------------------------------------
# Codex upstream (chatgpt.com/backend-api/codex) has no /v1/models endpoint.
# We use the unified preset models registry from preset_models.py.
from src.services.provider.preset_models import create_preset_models_fetcher

fetch_models_codex = create_preset_models_fetcher("codex")


# ---------------------------------------------------------------------------
# Transport Hook
# ---------------------------------------------------------------------------


def _get_header_value(headers: Mapping[str, Any] | None, header_name: str) -> str | None:
    if not isinstance(headers, Mapping):
        return None

    target = str(header_name or "").strip().lower()
    if not target:
        return None

    for name, value in headers.items():
        if str(name or "").strip().lower() != target:
            continue
        normalized = str(value or "").strip()
        return normalized or None
    return None


def _build_short_header_id(seed: str) -> str:
    return hashlib.sha256(seed.encode()).hexdigest()[:16]


def _normalize_codex_debug_organizations(value: Any) -> list[dict[str, Any]]:
    if not isinstance(value, list):
        return []

    items: list[dict[str, Any]] = []
    for raw in value:
        if not isinstance(raw, Mapping):
            continue

        normalized: dict[str, Any] = {}
        org_id = str(raw.get("id") or "").strip()
        if org_id:
            normalized["id"] = org_id

        title = str(raw.get("title") or "").strip()
        if title:
            normalized["title"] = title

        role = str(raw.get("role") or "").strip()
        if role:
            normalized["role"] = role

        if "is_default" in raw:
            normalized["is_default"] = bool(raw.get("is_default"))

        if normalized:
            items.append(normalized)

    return items


def _build_safe_codex_debug_snapshot(values: Mapping[str, Any] | None) -> dict[str, Any]:
    if not isinstance(values, Mapping):
        return {}

    snapshot: dict[str, Any] = {}
    for field in (
        "email",
        "account_id",
        "account_user_id",
        "plan_type",
        "user_id",
        "account_name",
    ):
        raw = values.get(field)
        if isinstance(raw, str):
            normalized = raw.strip()
            if normalized:
                snapshot[field] = normalized
        elif raw is not None:
            snapshot[field] = raw

    organizations = _normalize_codex_debug_organizations(values.get("organizations"))
    if organizations:
        snapshot["organizations"] = organizations

    return snapshot


def _build_codex_headers(
    request_body: Any,
    original_headers: Mapping[str, Any] | None,
    *,
    include_conversation_id: bool,
    decrypted_auth_config: dict[str, Any] | None = None,
) -> dict[str, str]:
    """Codex upstream: chatgpt-account-id + session_id + conversation_id."""
    headers: dict[str, str] = {}

    if decrypted_auth_config:
        account_id = str(decrypted_auth_config.get("account_id") or "").strip()
        if account_id:
            headers["chatgpt-account-id"] = account_id

    if isinstance(request_body, dict):
        cache_key = str(request_body.get("prompt_cache_key") or "").strip()
        if cache_key:
            short_id = _build_short_header_id(cache_key)
            if not _get_header_value(original_headers, "session_id"):
                headers["session_id"] = short_id
            if include_conversation_id and not _get_header_value(
                original_headers, "conversation_id"
            ):
                headers["conversation_id"] = short_id

    return headers


def build_codex_cli_headers(
    request_body: Any,
    original_headers: Mapping[str, Any] | None,
    *,
    decrypted_auth_config: dict[str, Any] | None = None,
) -> dict[str, str]:
    from src.services.provider.adapters.codex.context import is_codex_compact_request

    return _build_codex_headers(
        request_body,
        original_headers,
        include_conversation_id=not is_codex_compact_request(endpoint_sig="openai:cli"),
        decrypted_auth_config=decrypted_auth_config,
    )


def build_codex_compact_headers(
    request_body: Any,
    original_headers: Mapping[str, Any] | None,
    *,
    decrypted_auth_config: dict[str, Any] | None = None,
) -> dict[str, str]:
    return _build_codex_headers(
        request_body,
        original_headers,
        include_conversation_id=False,
        decrypted_auth_config=decrypted_auth_config,
    )


def build_codex_url(
    endpoint: Any,
    *,
    is_stream: bool,
    effective_query_params: dict[str, Any],
    **_kwargs: Any,
) -> str:
    """构建 Codex OAuth URL。

    Codex upstream (chatgpt.com/backend-api/codex) 使用 /responses
    而非标准 OpenAI 的 /v1/responses。compact 模式使用 /responses/compact。
    """
    _ = is_stream  # Codex 不需要根据 stream 切换路径

    endpoint_sig = str(getattr(endpoint, "api_format", "") or "").strip().lower()
    from src.services.provider.adapters.codex.context import is_codex_compact_request

    is_compact = is_codex_compact_request(endpoint_sig=endpoint_sig)

    base = str(endpoint.base_url).rstrip("/")
    # 如果用户已在 base_url 中包含了 /responses，不要重复追加
    if base.endswith("/responses"):
        url = f"{base}/compact" if is_compact else base
    elif base.endswith("/responses/compact"):
        url = base if is_compact else base.removesuffix("/compact")
    else:
        suffix = "/responses/compact" if is_compact else "/responses"
        url = f"{base}{suffix}"
    if effective_query_params:
        query_string = urlencode(effective_query_params, doseq=True)
        if query_string:
            url = f"{url}?{query_string}"
    return url


# ---------------------------------------------------------------------------
# Auth Enricher
# ---------------------------------------------------------------------------


async def enrich_codex(
    auth_config: dict[str, Any],
    token_response: dict[str, Any],
    access_token: str,
    proxy_config: dict[str, Any] | None,
) -> dict[str, Any]:
    """Codex auth_config enrichment: parse token claims -> account/team identity metadata."""
    from src.core.provider_oauth_utils import (
        fetch_openai_account_name,
        parse_codex_id_token,
    )

    def _read_non_empty_str(*values: Any) -> str | None:
        for value in values:
            if isinstance(value, str):
                normalized = value.strip()
                if normalized:
                    return normalized
        return None

    # Prefer explicit fields if token endpoint returns them directly.
    direct_account_id = _read_non_empty_str(
        token_response.get("account_id"),
        token_response.get("accountId"),
        token_response.get("chatgpt_account_id"),
        token_response.get("chatgptAccountId"),
    )
    if direct_account_id and not auth_config.get("account_id"):
        auth_config["account_id"] = direct_account_id

    direct_account_user_id = _read_non_empty_str(
        token_response.get("account_user_id"),
        token_response.get("accountUserId"),
        token_response.get("chatgpt_account_user_id"),
        token_response.get("chatgptAccountUserId"),
    )
    if direct_account_user_id and not auth_config.get("account_user_id"):
        auth_config["account_user_id"] = direct_account_user_id

    direct_plan_type = _read_non_empty_str(
        token_response.get("plan_type"),
        token_response.get("planType"),
        token_response.get("chatgpt_plan_type"),
        token_response.get("chatgptPlanType"),
    )
    if direct_plan_type and not auth_config.get("plan_type"):
        auth_config["plan_type"] = direct_plan_type

    direct_user_id = _read_non_empty_str(
        token_response.get("user_id"),
        token_response.get("userId"),
        token_response.get("chatgpt_user_id"),
        token_response.get("chatgptUserId"),
    )
    if direct_user_id and not auth_config.get("user_id"):
        auth_config["user_id"] = direct_user_id

    direct_email = _read_non_empty_str(token_response.get("email"))
    if direct_email and not auth_config.get("email"):
        auth_config["email"] = direct_email

    direct_snapshot = _build_safe_codex_debug_snapshot(
        {
            "email": direct_email,
            "account_id": direct_account_id,
            "account_user_id": direct_account_user_id,
            "plan_type": direct_plan_type,
            "user_id": direct_user_id,
        }
    )

    logger.debug(
        "Codex enrich_auth_config: id_token_present={} access_token_present={} token_keys={}",
        bool(token_response.get("id_token") or token_response.get("idToken")),
        bool(token_response.get("access_token") or token_response.get("accessToken")),
        list(token_response.keys()),
    )
    logger.debug("Codex direct token response values: {}", direct_snapshot)

    token_candidates = [
        ("id_token", token_response.get("id_token")),
        ("idToken", token_response.get("idToken")),
        ("access_token", token_response.get("access_token")),
        ("accessToken", token_response.get("accessToken")),
    ]
    for source_name, token_payload in token_candidates:
        codex_info = parse_codex_id_token(token_payload)
        if not codex_info:
            continue
        logger.debug(
            "Codex parsed token values: source={} fields={} values={}",
            source_name,
            list(codex_info.keys()),
            _build_safe_codex_debug_snapshot(codex_info),
        )
        for key, value in codex_info.items():
            if not auth_config.get(key):
                auth_config[key] = value

    account_id = _read_non_empty_str(auth_config.get("account_id"))
    if account_id:
        account_name = await fetch_openai_account_name(
            access_token,
            account_id,
            proxy_config=proxy_config,
            timeout_seconds=10.0,
        )
        logger.debug(
            "Codex account_name lookup: account_id={} resolved_account_name={}",
            account_id,
            account_name,
        )
        if account_name:
            auth_config["account_name"] = account_name

    logger.debug(
        "Codex enrich_auth_config final metadata: {}",
        _build_safe_codex_debug_snapshot(auth_config),
    )

    return auth_config


# ---------------------------------------------------------------------------
# Unified Registration
# ---------------------------------------------------------------------------


def register_all() -> None:
    """一次性注册 Codex 的所有 hooks 到各通用 registry。"""
    from src.core.api_format.capabilities import register_provider_default_body_rules
    from src.core.provider_oauth_utils import register_auth_enricher
    from src.services.model.upstream_fetcher import UpstreamModelsFetcherRegistry
    from src.services.provider.transport import register_transport_hook
    from src.services.provider.upstream_headers import register_upstream_headers_hook

    # Transport
    register_transport_hook("codex", "openai:cli", build_codex_url)
    register_transport_hook("codex", "openai:compact", build_codex_url)
    register_upstream_headers_hook("codex", "openai:cli", build_codex_cli_headers)
    register_upstream_headers_hook("codex", "openai:compact", build_codex_compact_headers)

    # Auth
    register_auth_enricher("codex", enrich_codex)

    # Provider Format Capability：默认 body_rules
    from src.core.api_format.metadata import CODEX_DEFAULT_BODY_RULES

    register_provider_default_body_rules("codex", "openai:cli", CODEX_DEFAULT_BODY_RULES)

    # Export: Codex uses the default export builder (strip null + temp fields)
    # No need to register a custom one — the default in export.py suffices.

    # Model Fetcher
    UpstreamModelsFetcherRegistry.register(
        provider_types=["codex"],
        fetcher=fetch_models_codex,
    )