ccproxy-api 0.1.6__py3-none-any.whl → 0.2.0__py3-none-any.whl

ccproxy/plugins/codex/models.py

@@ -0,0 +1,263 @@
+"""Codex plugin local CLI health models and detection models."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from enum import Enum
+from typing import Annotated, Any, Literal, TypedDict
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    field_serializer,
+    field_validator,
+    model_validator,
+)
+
+from ccproxy.llms.models import anthropic as anthropic_models
+from ccproxy.models.detection import DetectedHeaders, DetectedPrompts
+
+
+class CodexCliStatus(str, Enum):
+    AVAILABLE = "available"
+    NOT_INSTALLED = "not_installed"
+    BINARY_FOUND_BUT_ERRORS = "binary_found_but_errors"
+    TIMEOUT = "timeout"
+    ERROR = "error"
+
+
+class CodexCliInfo(BaseModel):
+    status: CodexCliStatus
+    version: str | None = None
+    binary_path: str | None = None
+    version_output: str | None = None
+    error: str | None = None
+    return_code: str | None = None
+
+
+class CodexHeaders(BaseModel):
+    """Pydantic model for Codex CLI headers extraction with field aliases."""
+
+    session_id: str = Field(
+        alias="session_id",
+        description="Codex session identifier",
+        default="",
+    )
+    originator: str = Field(
+        description="Codex originator identifier",
+        default="codex_cli_rs",
+    )
+    openai_beta: str = Field(
+        alias="openai-beta",
+        description="OpenAI beta features",
+        default="responses=experimental",
+    )
+    version: str = Field(
+        description="Codex CLI version",
+        default="0.21.0",
+    )
+    chatgpt_account_id: str = Field(
+        alias="chatgpt-account-id",
+        description="ChatGPT account identifier",
+        default="",
+    )
+
+    model_config = ConfigDict(extra="ignore", populate_by_name=True)
+
+    def to_headers_dict(self) -> dict[str, str]:
+        """Convert to headers dictionary for HTTP forwarding with proper case."""
+        headers = {}
+
+        # Map field names to proper HTTP header names
+        header_mapping = {
+            "session_id": "session_id",
+            "originator": "originator",
+            "openai_beta": "openai-beta",
+            "version": "version",
+            "chatgpt_account_id": "chatgpt-account-id",
+        }
+
+        for field_name, header_name in header_mapping.items():
+            value = getattr(self, field_name, None)
+            if value is not None and value != "":
+                headers[header_name] = value
+
+        return headers
+
+
+class CodexInstructionsData(BaseModel):
+    """Extracted Codex instructions information."""
+
+    instructions_field: Annotated[
+        str,
+        Field(
+            description="Complete instructions field as detected from Codex CLI, preserving exact text content"
+        ),
+    ]
+
+    model_config = ConfigDict(extra="allow")
+
+
+class CodexCacheData(BaseModel):
+    """Cached Codex CLI detection data with version tracking."""
+
+    codex_version: Annotated[str, Field(description="Codex CLI version")]
+    headers: Annotated[
+        DetectedHeaders,
+        Field(
+            description="Captured headers (lowercase keys) in insertion order",
+            default_factory=DetectedHeaders,
+        ),
+    ]
+    prompts: Annotated[
+        DetectedPrompts,
+        Field(description="Captured prompt metadata", default_factory=DetectedPrompts),
+    ]
+    body_json: Annotated[
+        dict[str, Any] | None,
+        Field(
+            description="Legacy captured request body (deprecated)",
+            default=None,
+            exclude=True,
+        ),
+    ] = None
+    method: Annotated[
+        str | None, Field(description="Captured HTTP method", default=None)
+    ] = None
+    url: Annotated[str | None, Field(description="Captured full URL", default=None)] = (
+        None
+    )
+    path: Annotated[
+        str | None, Field(description="Captured request path", default=None)
+    ] = None
+    query_params: Annotated[
+        dict[str, str] | None,
+        Field(description="Captured query parameters", default=None),
+    ] = None
+    cached_at: datetime = Field(
+        description="Cache timestamp",
+        default_factory=lambda: datetime.now(UTC),
+    )
+
+    model_config = ConfigDict(extra="forbid")
+
+    @model_validator(mode="before")
+    @classmethod
+    def _coerce_legacy_format(cls, values: dict[str, Any]) -> dict[str, Any]:
+        if not isinstance(values, dict):
+            return values
+
+        if "prompts" not in values:
+            legacy_body = values.get("body_json")
+            if legacy_body is not None:
+                values["prompts"] = DetectedPrompts.from_body(legacy_body)
+                cls._log_legacy_usage("body_json")
+
+        return values
+
+    @field_validator("headers", mode="before")
+    @classmethod
+    def _validate_headers(cls, value: Any) -> DetectedHeaders:
+        if isinstance(value, DetectedHeaders):
+            return value
+        if isinstance(value, dict):
+            return DetectedHeaders(value)
+        if value is None:
+            cls._log_legacy_usage("missing_headers")
+            return DetectedHeaders()
+        raise TypeError("headers must be a mapping of strings")
+
+    @field_validator("prompts", mode="before")
+    @classmethod
+    def _validate_prompts(cls, value: Any) -> DetectedPrompts:
+        if isinstance(value, DetectedPrompts):
+            return value
+        if isinstance(value, dict):
+            return DetectedPrompts.from_body(value)
+        if value is None:
+            return DetectedPrompts()
+        raise TypeError("prompts must be derived from a mapping")
+
+    @field_serializer("headers")
+    def _serialize_headers(self, headers: DetectedHeaders) -> dict[str, str]:
+        return headers.as_dict()
+
+    @field_serializer("prompts")
+    def _serialize_prompts(self, prompts: DetectedPrompts) -> dict[str, Any]:
+        raw = prompts.raw or {}
+        if not isinstance(raw, dict):
+            raw = {}
+        if prompts.instructions and "instructions" not in raw:
+            raw = dict(raw)
+            raw["instructions"] = prompts.instructions
+        if prompts.system is not None and "system" not in raw:
+            raw = dict(raw)
+            raw["system"] = prompts.system
+        return raw
+
+    @staticmethod
+    def _log_legacy_usage(reason: str) -> None:
+        try:
+            from ccproxy.core.logging import get_plugin_logger
+
+            logger = get_plugin_logger()
+            logger.debug(
+                "legacy_detection_cache_format",
+                plugin="codex",
+                reason=reason,
+            )
+        except Exception:  # pragma: no cover - logging best-effort only
+            pass
+
+
+class CodexMessage(BaseModel):
+    """Message format for Codex requests."""
+
+    role: Annotated[Literal["user", "assistant"], Field(description="Message role")]
+    content: Annotated[str, Field(description="Message content")]
+
+
+class CodexRequest(BaseModel):
+    """OpenAI Codex completion request model."""
+
+    model: Annotated[str, Field(description="Model name (e.g., gpt-5)")] = "gpt-5"
+    instructions: Annotated[
+        str | None, Field(description="System instructions for the model")
+    ] = None
+    messages: Annotated[list[CodexMessage], Field(description="Conversation messages")]
+    stream: Annotated[bool, Field(description="Whether to stream the response")] = True
+
+    model_config = ConfigDict(
+        extra="allow"
+    )  # Allow additional fields for compatibility
+
+
+class CodexResponse(BaseModel):
+    """OpenAI Codex completion response model."""
+
+    id: Annotated[str, Field(description="Response ID")]
+    model: Annotated[str, Field(description="Model used for completion")]
+    content: Annotated[str, Field(description="Generated content")]
+    finish_reason: Annotated[
+        str | None, Field(description="Reason the response finished")
+    ] = None
+    usage: Annotated[
+        anthropic_models.Usage | None, Field(description="Token usage information")
+    ] = None
+
+    model_config = ConfigDict(
+        extra="allow"
+    )  # Allow additional fields for compatibility
+
+
+class CodexAuthData(TypedDict, total=False):
+    """Authentication data for Codex/OpenAI provider.
+
+    Attributes:
+        access_token: Bearer token for OpenAI API authentication
+        chatgpt_account_id: Account ID for ChatGPT session-based requests
+    """
+
+    access_token: str | None
+    chatgpt_account_id: str | None

ccproxy/plugins/codex/plugin.py

@@ -0,0 +1,275 @@
+"""Codex provider plugin v2 implementation."""
+
+from typing import TYPE_CHECKING, Any
+
+from ccproxy.core.constants import (
+    FORMAT_OPENAI_CHAT,
+    FORMAT_OPENAI_RESPONSES,
+)
+from ccproxy.core.logging import get_plugin_logger
+from ccproxy.core.plugins import (
+    BaseProviderPluginFactory,
+    FormatAdapterSpec,
+    FormatPair,
+    PluginContext,
+    PluginManifest,
+    ProviderPluginRuntime,
+)
+from ccproxy.core.plugins.declaration import RouterSpec
+from ccproxy.llms.streaming.accumulators import OpenAIAccumulator
+from ccproxy.plugins.oauth_codex.manager import CodexTokenManager
+
+from .adapter import CodexAdapter
+from .config import CodexSettings
+from .detection_service import CodexDetectionService
+from .routes import router as codex_router
+
+
+if TYPE_CHECKING:
+    pass
+
+
+logger = get_plugin_logger()
+
+
+class CodexRuntime(ProviderPluginRuntime):
+    """Runtime for Codex provider plugin."""
+
+    def __init__(self, manifest: PluginManifest):
+        """Initialize runtime."""
+        super().__init__(manifest)
+        self.config: CodexSettings | None = None
+        self.credential_manager: CodexTokenManager | None = None
+
+    async def _on_initialize(self) -> None:
+        """Initialize the Codex provider plugin."""
+        if not self.context:
+            raise RuntimeError("Context not set")
+
+        # Get configuration
+        try:
+            config = self.context.get(CodexSettings)
+        except ValueError:
+            logger.debug("plugin_no_config")
+            # Use default config if none provided
+            config = CodexSettings()
+            logger.debug("plugin_using_default_config")
+        self.config = config
+
+        # Get auth manager from context
+        try:
+            self.credential_manager = self.context.get(CodexTokenManager)
+        except ValueError:
+            self.credential_manager = None
+
+        # Call parent to initialize adapter and detection service
+        await super()._on_initialize()
+
+        # Register streaming metrics hook
+        await self._register_streaming_metrics_hook()
+
+        # Check CLI status
+        if self.detection_service:
+            version = self.detection_service.get_version()
+            cli_path = self.detection_service.get_cli_path()
+
+            if not cli_path:
+                logger.warning(
+                    "cli_detection_completed",
+                    cli_available=False,
+                    version=None,
+                    cli_path=None,
+                    source="unknown",
+                )
+
+        # Get CLI info for consolidated logging (only for successful detection)
+        cli_info = {}
+        if self.detection_service and self.detection_service.get_cli_path():
+            cli_info.update(
+                {
+                    "cli_available": True,
+                    "cli_version": self.detection_service.get_version(),
+                    "cli_path": self.detection_service.get_cli_path(),
+                    "cli_source": "package_manager",
+                }
+            )
+
+        logger.debug(
+            "plugin_initialized",
+            plugin="codex",
+            version=self.manifest.version,
+            status="initialized",
+            has_credentials=self.credential_manager is not None,
+            has_adapter=self.adapter is not None,
+            has_detection=self.detection_service is not None,
+            **cli_info,
+        )
+
+    async def _get_health_details(self) -> dict[str, Any]:
+        """Get health check details."""
+        details = await super()._get_health_details()
+
+        # Add Codex-specific details
+        if self.config:
+            details.update(
+                {
+                    "base_url": self.config.base_url,
+                    "supports_streaming": self.config.supports_streaming,
+                    "models": [card.id for card in self.config.models_endpoint],
+                }
+            )
+
+        # Add authentication status
+        if self.credential_manager:
+            try:
+                auth_status = await self.credential_manager.get_auth_status()
+                details["auth_configured"] = auth_status.get("auth_configured", False)
+                details["token_available"] = auth_status.get("token_available", False)
+            except Exception as e:
+                details["auth_error"] = str(e)
+
+        # Include standardized provider health check details
+        try:
+            from .health import codex_health_check
+
+            if self.config and self.detection_service:
+                health_result = await codex_health_check(
+                    self.config,
+                    self.detection_service,
+                    self.credential_manager,
+                    version=self.manifest.version,
+                )
+                details.update(
+                    {
+                        "health_check_status": health_result.status,
+                        "health_check_detail": health_result.details,
+                    }
+                )
+        except Exception as e:
+            details["health_check_error"] = str(e)
+
+        return details
+
+    async def _register_streaming_metrics_hook(self) -> None:
+        """Register the streaming metrics extraction hook."""
+        try:
+            if not self.context:
+                logger.warning(
+                    "streaming_metrics_hook_not_registered",
+                    reason="no_context",
+                    plugin="codex",
+                )
+                return
+            # Get hook registry from context
+            from ccproxy.core.plugins.hooks.registry import HookRegistry
+
+            try:
+                hook_registry = self.context.get(HookRegistry)
+            except ValueError:
+                logger.warning(
+                    "streaming_metrics_hook_not_registered",
+                    reason="no_hook_registry",
+                    plugin="codex",
+                    context_keys=list(self.context.keys()) if self.context else [],
+                )
+                return
+
+            # Get pricing service from plugin registry if available
+            pricing_service = None
+            if "plugin_registry" in self.context:
+                try:
+                    from ccproxy.plugins.pricing.service import PricingService
+
+                    plugin_registry = self.context["plugin_registry"]
+                    pricing_service = plugin_registry.get_service(
+                        "pricing", PricingService
+                    )
+                except Exception as e:
+                    logger.debug(
+                        "pricing_service_not_available_for_hook",
+                        plugin="codex",
+                        error=str(e),
+                    )
+
+            # Create and register the hook
+            from .hooks import CodexStreamingMetricsHook
+
+            # Pass both pricing_service (if available now) and plugin_registry (for lazy loading)
+            metrics_hook = CodexStreamingMetricsHook(
+                pricing_service=pricing_service,
+                plugin_registry=self.context.get("plugin_registry"),
+            )
+            hook_registry.register(metrics_hook)
+
+            logger.debug(
+                "streaming_metrics_hook_registered",
+                plugin="codex",
+                hook_name=metrics_hook.name,
+                priority=metrics_hook.priority,
+                has_pricing=pricing_service is not None,
+            )
+
+        except Exception as e:
+            logger.error(
+                "streaming_metrics_hook_registration_failed",
+                plugin="codex",
+                error=str(e),
+                exc_info=e,
+            )
+
+
+class CodexFactory(BaseProviderPluginFactory):
+    """Factory for Codex provider plugin."""
+
+    cli_safe = False  # Heavy provider plugin - not safe for CLI
+
+    # Plugin configuration via class attributes
+    plugin_name = "codex"
+    plugin_description = (
+        "OpenAI Codex provider plugin with OAuth authentication and format conversion"
+    )
+    runtime_class = CodexRuntime
+    adapter_class = CodexAdapter
+    detection_service_class = CodexDetectionService
+    config_class = CodexSettings
+    # String-based auth manager reference
+    auth_manager_name = "oauth_codex"
+    credentials_manager_class = CodexTokenManager
+    routers = [
+        RouterSpec(router=codex_router, prefix="/codex"),
+    ]
+    dependencies = ["oauth_codex"]
+    optional_requires = ["pricing"]
+
+    # No format adapters needed - core provides all required conversions
+    format_adapters: list[FormatAdapterSpec] = []
+
+    # Define requirements for adapters this plugin needs
+    requires_format_adapters: list[FormatPair] = [
+        # Codex can leverage core-provided OpenAI chat ↔ responses conversion
+        (FORMAT_OPENAI_CHAT, FORMAT_OPENAI_RESPONSES),
+    ]
+    tool_accumulator_class = OpenAIAccumulator
+
+    def create_detection_service(self, context: PluginContext) -> CodexDetectionService:
+        """Create the Codex detection service with validation."""
+        from ccproxy.config.settings import Settings
+        from ccproxy.services.cli_detection import CLIDetectionService
+
+        settings = context.get(Settings)
+        try:
+            cli_service = context.get(CLIDetectionService)
+        except ValueError:
+            cli_service = None
+
+        # Get codex-specific settings
+        try:
+            codex_settings = context.get(CodexSettings)
+        except ValueError:
+            codex_settings = None
+
+        return CodexDetectionService(settings, cli_service, codex_settings)
+
+
+# Export the factory instance
+factory = CodexFactory()

ccproxy/plugins/codex/routes.py

@@ -0,0 +1,129 @@
+"""Codex plugin routes."""
+
+from typing import TYPE_CHECKING, Annotated, Any, cast
+
+from fastapi import APIRouter, Depends, Request
+from starlette.responses import Response, StreamingResponse
+
+from ccproxy.api.decorators import with_format_chain
+from ccproxy.api.dependencies import (
+    get_plugin_adapter,
+    get_provider_config_dependency,
+)
+from ccproxy.auth.dependencies import ConditionalAuthDep
+from ccproxy.core.constants import (
+    FORMAT_ANTHROPIC_MESSAGES,
+    FORMAT_OPENAI_CHAT,
+    FORMAT_OPENAI_RESPONSES,
+    UPSTREAM_ENDPOINT_ANTHROPIC_MESSAGES,
+    UPSTREAM_ENDPOINT_OPENAI_CHAT_COMPLETIONS,
+    UPSTREAM_ENDPOINT_OPENAI_RESPONSES,
+)
+from ccproxy.streaming import DeferredStreaming
+
+from .config import CodexSettings
+
+
+if TYPE_CHECKING:
+    pass
+
+CodexAdapterDep = Annotated[Any, Depends(get_plugin_adapter("codex"))]
+CodexConfigDep = Annotated[
+    CodexSettings,
+    Depends(get_provider_config_dependency("codex", CodexSettings)),
+]
+router = APIRouter()
+
+
+# Helper to handle adapter requests
+async def handle_codex_request(
+    request: Request,
+    adapter: Any,
+) -> StreamingResponse | Response | DeferredStreaming:
+    result = await adapter.handle_request(request)
+    return cast(StreamingResponse | Response | DeferredStreaming, result)
+
+
+# Route definitions
+async def _codex_responses_handler(
+    request: Request,
+    adapter: CodexAdapterDep,
+) -> StreamingResponse | Response | DeferredStreaming:
+    """Shared handler for Codex responses endpoints."""
+
+    return await handle_codex_request(request, adapter)
+
+
+@router.post("/v1/responses", response_model=None)
+@with_format_chain(
+    [FORMAT_OPENAI_RESPONSES], endpoint=UPSTREAM_ENDPOINT_OPENAI_RESPONSES
+)
+async def codex_responses(
+    request: Request,
+    auth: ConditionalAuthDep,
+    adapter: CodexAdapterDep,
+) -> StreamingResponse | Response | DeferredStreaming:
+    return await _codex_responses_handler(request, adapter)
+
+
+@router.post("/responses", response_model=None, include_in_schema=False)
+@with_format_chain(
+    [FORMAT_OPENAI_RESPONSES], endpoint=UPSTREAM_ENDPOINT_OPENAI_RESPONSES
+)
+async def codex_responses_legacy(
+    request: Request,
+    auth: ConditionalAuthDep,
+    adapter: CodexAdapterDep,
+) -> StreamingResponse | Response | DeferredStreaming:
+    return await _codex_responses_handler(request, adapter)
+
+
+@router.post("/v1/chat/completions", response_model=None)
+@with_format_chain(
+    [FORMAT_OPENAI_CHAT, FORMAT_OPENAI_RESPONSES],
+    endpoint=UPSTREAM_ENDPOINT_OPENAI_CHAT_COMPLETIONS,
+)
+async def codex_chat_completions(
+    request: Request,
+    auth: ConditionalAuthDep,
+    adapter: CodexAdapterDep,
+) -> StreamingResponse | Response | DeferredStreaming:
+    return await handle_codex_request(request, adapter)
+
+
+@router.get("/v1/models", response_model=None)
+async def list_models(
+    request: Request,
+    auth: ConditionalAuthDep,
+    config: CodexConfigDep,
+) -> dict[str, Any]:
+    """List available Codex models."""
+    models = [card.model_dump(mode="json") for card in config.models_endpoint]
+    return {"object": "list", "data": models}
+
+
+@router.post("/v1/messages", response_model=None)
+@with_format_chain(
+    [FORMAT_ANTHROPIC_MESSAGES, FORMAT_OPENAI_RESPONSES],
+    endpoint=UPSTREAM_ENDPOINT_ANTHROPIC_MESSAGES,
+)
+async def codex_v1_messages(
+    request: Request,
+    auth: ConditionalAuthDep,
+    adapter: CodexAdapterDep,
+) -> StreamingResponse | Response | DeferredStreaming:
+    return await handle_codex_request(request, adapter)
+
+
+@router.post("/{session_id}/v1/messages", response_model=None)
+@with_format_chain(
+    [FORMAT_ANTHROPIC_MESSAGES, FORMAT_OPENAI_RESPONSES],
+    endpoint="/{session_id}/v1/messages",
+)
+async def codex_v1_messages_with_session(
+    session_id: str,
+    request: Request,
+    auth: ConditionalAuthDep,
+    adapter: CodexAdapterDep,
+) -> StreamingResponse | Response | DeferredStreaming:
+    return await handle_codex_request(request, adapter)