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

ccproxy/api/routes/codex.py

@@ -1,1251 +0,0 @@
-"""OpenAI Codex API routes."""
-
-import json
-import time
-import uuid
-from collections.abc import AsyncIterator
-
-import httpx
-import structlog
-from fastapi import APIRouter, Depends, HTTPException, Request
-from fastapi.responses import StreamingResponse
-from starlette.responses import Response
-
-from ccproxy.adapters.openai.models import (
-    OpenAIChatCompletionRequest,
-    OpenAIChatCompletionResponse,
-)
-from ccproxy.adapters.openai.response_adapter import ResponseAdapter
-from ccproxy.api.dependencies import ProxyServiceDep
-from ccproxy.auth.openai import OpenAITokenManager
-from ccproxy.config.settings import Settings, get_settings
-from ccproxy.core.errors import AuthenticationError, ProxyError
-from ccproxy.observability.streaming_response import StreamingResponseWithLogging
-
-
-logger = structlog.get_logger(__name__)
-
-# Create router
-router = APIRouter(prefix="/codex", tags=["codex"])
-
-
-def get_token_manager() -> OpenAITokenManager:
-    """Get OpenAI token manager dependency."""
-    return OpenAITokenManager()
-
-
-def resolve_session_id(
-    path_session: str | None = None,
-    header_session: str | None = None,
-) -> str:
-    """Resolve session ID with priority: path > header > generated."""
-    return path_session or header_session or str(uuid.uuid4())
-
-
-async def check_codex_enabled(settings: Settings = Depends(get_settings)) -> None:
-    """Check if Codex is enabled."""
-    if not settings.codex.enabled:
-        raise HTTPException(
-            status_code=503, detail="OpenAI Codex provider is not enabled"
-        )
-
-
-@router.post("/responses", response_model=None)
-async def codex_responses(
-    request: Request,
-    proxy_service: ProxyServiceDep,
-    settings: Settings = Depends(get_settings),
-    token_manager: OpenAITokenManager = Depends(get_token_manager),
-    _: None = Depends(check_codex_enabled),
-) -> StreamingResponse | Response:
-    """Create completion with auto-generated session_id.
-
-    This endpoint creates a new completion request with an automatically
-    generated session_id. Each request gets a unique session.
-    """
-    # Get session_id from header if provided
-    header_session_id = request.headers.get("session_id")
-    session_id = resolve_session_id(header_session=header_session_id)
-
-    # Get and validate access token
-    try:
-        access_token = await token_manager.get_valid_token()
-        if not access_token:
-            raise HTTPException(
-                status_code=401,
-                detail="No valid OpenAI credentials found. Please authenticate first.",
-            )
-    except HTTPException:
-        # Re-raise HTTPExceptions without chaining to avoid stack traces
-        raise
-    except Exception as e:
-        logger.debug(
-            "Failed to get OpenAI access token",
-            error=str(e),
-            error_type=type(e).__name__,
-        )
-        raise HTTPException(
-            status_code=401, detail="Failed to retrieve valid credentials"
-        ) from None
-
-    try:
-        # Handle the Codex request
-        response = await proxy_service.handle_codex_request(
-            method="POST",
-            path="/responses",
-            session_id=session_id,
-            access_token=access_token,
-            request=request,
-            settings=settings,
-        )
-        return response
-    except AuthenticationError as e:
-        raise HTTPException(status_code=401, detail=str(e)) from None
-    except ProxyError as e:
-        raise HTTPException(status_code=502, detail=str(e)) from None
-    except Exception as e:
-        logger.error("Unexpected error in codex_responses", error=str(e))
-        raise HTTPException(status_code=500, detail="Internal server error") from None
-
-
-@router.post("/{session_id}/responses", response_model=None)
-async def codex_responses_with_session(
-    session_id: str,
-    request: Request,
-    proxy_service: ProxyServiceDep,
-    settings: Settings = Depends(get_settings),
-    token_manager: OpenAITokenManager = Depends(get_token_manager),
-    _: None = Depends(check_codex_enabled),
-) -> StreamingResponse | Response:
-    """Create completion with specific session_id.
-
-    This endpoint creates a completion request using the provided session_id
-    from the URL path. This allows for session-specific conversations.
-    """
-    # Get and validate access token
-    try:
-        access_token = await token_manager.get_valid_token()
-        if not access_token:
-            raise HTTPException(
-                status_code=401,
-                detail="No valid OpenAI credentials found. Please authenticate first.",
-            )
-    except HTTPException:
-        # Re-raise HTTPExceptions without chaining to avoid stack traces
-        raise
-    except Exception as e:
-        logger.debug(
-            "Failed to get OpenAI access token",
-            error=str(e),
-            error_type=type(e).__name__,
-        )
-        raise HTTPException(
-            status_code=401, detail="Failed to retrieve valid credentials"
-        ) from None
-
-    try:
-        # Handle the Codex request with specific session_id
-        response = await proxy_service.handle_codex_request(
-            method="POST",
-            path=f"/{session_id}/responses",
-            session_id=session_id,
-            access_token=access_token,
-            request=request,
-            settings=settings,
-        )
-        return response
-    except AuthenticationError as e:
-        raise HTTPException(status_code=401, detail=str(e)) from None
-    except ProxyError as e:
-        raise HTTPException(status_code=502, detail=str(e)) from None
-    except Exception as e:
-        logger.error("Unexpected error in codex_responses_with_session", error=str(e))
-        raise HTTPException(status_code=500, detail="Internal server error") from None
-
-
-@router.post("/chat/completions", response_model=None)
-async def codex_chat_completions(
-    openai_request: OpenAIChatCompletionRequest,
-    request: Request,
-    proxy_service: ProxyServiceDep,
-    settings: Settings = Depends(get_settings),
-    token_manager: OpenAITokenManager = Depends(get_token_manager),
-    _: None = Depends(check_codex_enabled),
-) -> StreamingResponse | OpenAIChatCompletionResponse:
-    """OpenAI-compatible chat completions endpoint for Codex.
-
-    This endpoint accepts OpenAI chat/completions format and converts it
-    to OpenAI Response API format before forwarding to the ChatGPT backend.
-    """
-    # Get session_id from header if provided, otherwise generate
-    header_session_id = request.headers.get("session_id")
-    session_id = resolve_session_id(header_session=header_session_id)
-
-    # Get and validate access token
-    try:
-        access_token = await token_manager.get_valid_token()
-        if not access_token:
-            raise HTTPException(
-                status_code=401,
-                detail="No valid OpenAI credentials found. Please authenticate first.",
-            )
-    except HTTPException:
-        # Re-raise HTTPExceptions without chaining to avoid stack traces
-        raise
-    except Exception as e:
-        logger.debug(
-            "Failed to get OpenAI access token",
-            error=str(e),
-            error_type=type(e).__name__,
-        )
-        raise HTTPException(
-            status_code=401, detail="Failed to retrieve valid credentials"
-        ) from None
-
-    try:
-        # Create adapter for format conversion
-        adapter = ResponseAdapter()
-
-        # Convert OpenAI Chat Completions format to Response API format
-        response_request = adapter.chat_to_response_request(openai_request)
-
-        # Convert the transformed request to bytes
-        codex_body = response_request.model_dump_json().encode("utf-8")
-
-        # Get request context from middleware
-        request_context = getattr(request.state, "context", None)
-
-        # Create a mock request object with the converted body
-        class MockRequest:
-            def __init__(self, original_request: Request, new_body: bytes) -> None:
-                self.method = original_request.method
-                self.url = original_request.url
-                self.headers = dict(original_request.headers)
-                self.headers["content-length"] = str(len(new_body))
-                self.state = original_request.state
-                self._body = new_body
-
-            async def body(self) -> bytes:
-                return self._body
-
-        mock_request = MockRequest(request, codex_body)
-
-        # For streaming requests, handle the transformation directly
-        if openai_request.stream:
-            # Make the request directly to get the raw streaming response
-            from ccproxy.core.codex_transformers import CodexRequestTransformer
-
-            # Transform the request
-            transformer = CodexRequestTransformer()
-            transformed_request = await transformer.transform_codex_request(
-                method="POST",
-                path="/responses",
-                headers=dict(request.headers),
-                body=codex_body,
-                access_token=access_token,
-                session_id=session_id,
-                account_id="unknown",  # Will be extracted from token if needed
-                codex_detection_data=getattr(
-                    proxy_service.app_state, "codex_detection_data", None
-                )
-                if proxy_service.app_state
-                else None,
-                target_base_url=settings.codex.base_url,
-            )
-
-            # Convert Response API SSE stream to Chat Completions format
-            response_headers = {}
-            # Generate stream_id and timestamp outside the nested function to avoid closure issues
-            stream_id = f"chatcmpl_{uuid.uuid4().hex[:29]}"
-            created = int(time.time())
-
-            async def stream_codex_response() -> AsyncIterator[bytes]:
-                """Stream and convert Response API to Chat Completions format."""
-                async with (
-                    httpx.AsyncClient(timeout=240.0) as client,
-                    client.stream(
-                        method="POST",
-                        url=transformed_request["url"],
-                        headers=transformed_request["headers"],
-                        content=transformed_request["body"],
-                    ) as response,
-                ):
-                    # Check if we got a streaming response
-                    content_type = response.headers.get("content-type", "")
-                    transfer_encoding = response.headers.get("transfer-encoding", "")
-
-                    # Capture response headers for forwarding
-                    nonlocal response_headers
-                    response_headers = dict(response.headers)
-
-                    logger.debug(
-                        "codex_chat_response_headers",
-                        status_code=response.status_code,
-                        content_type=content_type,
-                        transfer_encoding=transfer_encoding,
-                        headers=response_headers,
-                        url=str(response.url),
-                    )
-
-                    # Check for error response first
-                    if response.status_code >= 400:
-                        # Handle error response - collect the response body
-                        error_body = b""
-                        async for chunk in response.aiter_bytes():
-                            error_body += chunk
-
-                        # Try to parse error message
-                        error_message = "Request failed"
-                        if error_body:
-                            try:
-                                error_data = json.loads(error_body.decode("utf-8"))
-                                if "detail" in error_data:
-                                    error_message = error_data["detail"]
-                                elif "error" in error_data and isinstance(
-                                    error_data["error"], dict
-                                ):
-                                    error_message = error_data["error"].get(
-                                        "message", "Request failed"
-                                    )
-                            except json.JSONDecodeError:
-                                pass
-
-                        logger.warning(
-                            "codex_chat_error_response",
-                            status_code=response.status_code,
-                            error_message=error_message,
-                        )
-
-                        # Return error in streaming format
-                        error_response = {
-                            "error": {
-                                "message": error_message,
-                                "type": "invalid_request_error",
-                                "code": response.status_code,
-                            }
-                        }
-                        yield f"data: {json.dumps(error_response)}\n\n".encode()
-                        return
-
-                    # Check if this is a streaming response
-                    # The backend may return chunked transfer encoding without content-type
-                    is_streaming = "text/event-stream" in content_type or (
-                        transfer_encoding == "chunked" and not content_type
-                    )
-
-                    if is_streaming:
-                        logger.debug(
-                            "codex_stream_conversion_started",
-                            session_id=session_id,
-                            request_id=getattr(request.state, "request_id", "unknown"),
-                        )
-
-                        chunk_count = 0
-                        total_bytes = 0
-
-                        # Process SSE events directly without buffering
-                        line_count = 0
-                        first_chunk_sent = False
-                        thinking_block_active = False
-                        try:
-                            async for line in response.aiter_lines():
-                                line_count += 1
-                                logger.debug(
-                                    "codex_stream_line",
-                                    line_number=line_count,
-                                    line_preview=line[:100] if line else "(empty)",
-                                )
-
-                                # Skip empty lines
-                                if not line or line.strip() == "":
-                                    continue
-
-                                if line.startswith("data:"):
-                                    data_str = line[5:].strip()
-                                    if data_str == "[DONE]":
-                                        continue
-
-                                    try:
-                                        event_data = json.loads(data_str)
-                                        event_type = event_data.get("type")
-
-                                        # Send initial role message if this is the first chunk
-                                        if not first_chunk_sent:
-                                            # Send an initial chunk to indicate streaming has started
-                                            initial_chunk = {
-                                                "id": stream_id,
-                                                "object": "chat.completion.chunk",
-                                                "created": created,
-                                                "model": "gpt-5",
-                                                "choices": [
-                                                    {
-                                                        "index": 0,
-                                                        "delta": {"role": "assistant"},
-                                                        "finish_reason": None,
-                                                    }
-                                                ],
-                                            }
-                                            yield f"data: {json.dumps(initial_chunk)}\n\n".encode()
-                                            first_chunk_sent = True
-                                            chunk_count += 1
-
-                                            logger.debug(
-                                                "codex_stream_initial_chunk_sent",
-                                                event_type=event_type,
-                                            )
-
-                                        # Handle reasoning blocks based on official OpenAI Response API
-                                        if event_type == "response.output_item.added":
-                                            # Check if this is a reasoning block
-                                            item = event_data.get("item", {})
-                                            item_type = item.get("type")
-
-                                            if (
-                                                item_type == "reasoning"
-                                                and not thinking_block_active
-                                            ):
-                                                # Only send opening tag if not already in a thinking block
-                                                thinking_block_active = True
-
-                                                logger.debug(
-                                                    "codex_reasoning_block_started",
-                                                    item_type=item_type,
-                                                    event_type=event_type,
-                                                )
-
-                                                # Send opening reasoning tag (no signature in official API)
-                                                openai_chunk = {
-                                                    "id": stream_id,
-                                                    "object": "chat.completion.chunk",
-                                                    "created": created,
-                                                    "model": "gpt-5",
-                                                    "choices": [
-                                                        {
-                                                            "index": 0,
-                                                            "delta": {
-                                                                "content": "<reasoning>"
-                                                            },
-                                                            "finish_reason": None,
-                                                        }
-                                                    ],
-                                                }
-                                                yield f"data: {json.dumps(openai_chunk)}\n\n".encode()
-                                                chunk_count += 1
-
-                                        # Handle content part deltas - various content types from API
-                                        elif (
-                                            event_type == "response.content_part.delta"
-                                        ):
-                                            delta = event_data.get("delta", {})
-                                            delta_type = delta.get("type")
-
-                                            if (
-                                                delta_type == "text"
-                                                and not thinking_block_active
-                                            ):
-                                                # Regular text content
-                                                text_content = delta.get("text", "")
-                                                if text_content:
-                                                    openai_chunk = {
-                                                        "id": stream_id,
-                                                        "object": "chat.completion.chunk",
-                                                        "created": created,
-                                                        "model": "gpt-5",
-                                                        "choices": [
-                                                            {
-                                                                "index": 0,
-                                                                "delta": {
-                                                                    "content": text_content
-                                                                },
-                                                                "finish_reason": None,
-                                                            }
-                                                        ],
-                                                    }
-                                                    yield f"data: {json.dumps(openai_chunk)}\n\n".encode()
-                                                    chunk_count += 1
-
-                                            elif (
-                                                delta_type == "reasoning"
-                                                and thinking_block_active
-                                            ):
-                                                # Reasoning content within reasoning block
-                                                reasoning_content = delta.get(
-                                                    "reasoning", ""
-                                                )
-                                                if reasoning_content:
-                                                    openai_chunk = {
-                                                        "id": stream_id,
-                                                        "object": "chat.completion.chunk",
-                                                        "created": created,
-                                                        "model": "gpt-5",
-                                                        "choices": [
-                                                            {
-                                                                "index": 0,
-                                                                "delta": {
-                                                                    "content": reasoning_content
-                                                                },
-                                                                "finish_reason": None,
-                                                            }
-                                                        ],
-                                                    }
-                                                    yield f"data: {json.dumps(openai_chunk)}\n\n".encode()
-                                                    chunk_count += 1
-
-                                        # Handle reasoning summary text - the actual reasoning content
-                                        elif (
-                                            event_type
-                                            == "response.reasoning_summary_text.delta"
-                                            and thinking_block_active
-                                        ):
-                                            # Extract reasoning text content from delta field
-                                            reasoning_text = event_data.get("delta", "")
-
-                                            if reasoning_text:
-                                                chunk_count += 1
-                                                openai_chunk = {
-                                                    "id": stream_id,
-                                                    "object": "chat.completion.chunk",
-                                                    "created": created,
-                                                    "model": "gpt-5",
-                                                    "choices": [
-                                                        {
-                                                            "index": 0,
-                                                            "delta": {
-                                                                "content": reasoning_text
-                                                            },
-                                                            "finish_reason": None,
-                                                        }
-                                                    ],
-                                                }
-                                                yield f"data: {json.dumps(openai_chunk)}\n\n".encode()
-
-                                        # Handle reasoning block completion - official API
-                                        elif (
-                                            event_type == "response.output_item.done"
-                                            and thinking_block_active
-                                        ):
-                                            # Check if this is the end of a reasoning block
-                                            item = event_data.get("item", {})
-                                            item_type = item.get("type")
-
-                                            if item_type == "reasoning":
-                                                thinking_block_active = False
-
-                                                # Send closing reasoning tag
-                                                openai_chunk = {
-                                                    "id": stream_id,
-                                                    "object": "chat.completion.chunk",
-                                                    "created": created,
-                                                    "model": "gpt-5",
-                                                    "choices": [
-                                                        {
-                                                            "index": 0,
-                                                            "delta": {
-                                                                "content": "</reasoning>\n"
-                                                            },
-                                                            "finish_reason": None,
-                                                        }
-                                                    ],
-                                                }
-                                                yield f"data: {json.dumps(openai_chunk)}\n\n".encode()
-                                                chunk_count += 1
-
-                                                logger.debug(
-                                                    "codex_reasoning_block_ended",
-                                                    item_type=item_type,
-                                                    event_type=event_type,
-                                                )
-
-                                        # Convert Response API events to OpenAI format
-                                        elif event_type == "response.output_text.delta":
-                                            # Direct text delta event (only if not in thinking block)
-                                            if not thinking_block_active:
-                                                delta_content = event_data.get(
-                                                    "delta", ""
-                                                )
-                                                if delta_content:
-                                                    chunk_count += 1
-                                                    openai_chunk = {
-                                                        "id": stream_id,
-                                                        "object": "chat.completion.chunk",
-                                                        "created": created,
-                                                        "model": event_data.get(
-                                                            "model", "gpt-5"
-                                                        ),
-                                                        "choices": [
-                                                            {
-                                                                "index": 0,
-                                                                "delta": {
-                                                                    "content": delta_content
-                                                                },
-                                                                "finish_reason": None,
-                                                            }
-                                                        ],
-                                                    }
-                                                    chunk_data = f"data: {json.dumps(openai_chunk)}\n\n".encode()
-                                                    total_bytes += len(chunk_data)
-
-                                                    logger.debug(
-                                                        "codex_stream_chunk_converted",
-                                                        chunk_number=chunk_count,
-                                                        chunk_size=len(chunk_data),
-                                                        event_type=event_type,
-                                                        content_length=len(
-                                                            delta_content
-                                                        ),
-                                                    )
-
-                                                    yield chunk_data
-
-                                        elif event_type == "response.output.delta":
-                                            # Standard output delta with nested structure
-                                            output = event_data.get("output", [])
-                                            for output_item in output:
-                                                if output_item.get("type") == "message":
-                                                    content_blocks = output_item.get(
-                                                        "content", []
-                                                    )
-                                                    for block in content_blocks:
-                                                        # Check if this is thinking content
-                                                        if (
-                                                            block.get("type")
-                                                            in [
-                                                                "thinking",
-                                                                "reasoning",
-                                                                "internal_monologue",
-                                                            ]
-                                                            and thinking_block_active
-                                                        ):
-                                                            thinking_content = (
-                                                                block.get("text", "")
-                                                            )
-                                                            if thinking_content:
-                                                                chunk_count += 1
-                                                                openai_chunk = {
-                                                                    "id": stream_id,
-                                                                    "object": "chat.completion.chunk",
-                                                                    "created": created,
-                                                                    "model": "gpt-5",
-                                                                    "choices": [
-                                                                        {
-                                                                            "index": 0,
-                                                                            "delta": {
-                                                                                "content": thinking_content
-                                                                            },
-                                                                            "finish_reason": None,
-                                                                        }
-                                                                    ],
-                                                                }
-                                                                yield f"data: {json.dumps(openai_chunk)}\n\n".encode()
-                                                        elif (
-                                                            block.get("type")
-                                                            in [
-                                                                "output_text",
-                                                                "text",
-                                                            ]
-                                                            and not thinking_block_active
-                                                        ):
-                                                            delta_content = block.get(
-                                                                "text", ""
-                                                            )
-                                                            if delta_content:
-                                                                chunk_count += 1
-                                                                openai_chunk = {
-                                                                    "id": stream_id,
-                                                                    "object": "chat.completion.chunk",
-                                                                    "created": created,
-                                                                    "model": event_data.get(
-                                                                        "model", "gpt-5"
-                                                                    ),
-                                                                    "choices": [
-                                                                        {
-                                                                            "index": 0,
-                                                                            "delta": {
-                                                                                "content": delta_content
-                                                                            },
-                                                                            "finish_reason": None,
-                                                                        }
-                                                                    ],
-                                                                }
-                                                                chunk_data = f"data: {json.dumps(openai_chunk)}\n\n".encode()
-                                                                total_bytes += len(
-                                                                    chunk_data
-                                                                )
-
-                                                                logger.debug(
-                                                                    "codex_stream_chunk_converted",
-                                                                    chunk_number=chunk_count,
-                                                                    chunk_size=len(
-                                                                        chunk_data
-                                                                    ),
-                                                                    event_type=event_type,
-                                                                    content_length=len(
-                                                                        delta_content
-                                                                    ),
-                                                                )
-
-                                                                yield chunk_data
-
-                                        # Handle additional official API event types
-                                        elif (
-                                            event_type
-                                            == "response.function_call_arguments.delta"
-                                        ):
-                                            # Function call arguments streaming - official API
-                                            if not thinking_block_active:
-                                                arguments = event_data.get(
-                                                    "arguments", ""
-                                                )
-                                                if arguments:
-                                                    chunk_count += 1
-                                                    openai_chunk = {
-                                                        "id": stream_id,
-                                                        "object": "chat.completion.chunk",
-                                                        "created": created,
-                                                        "model": "gpt-5",
-                                                        "choices": [
-                                                            {
-                                                                "index": 0,
-                                                                "delta": {
-                                                                    "content": arguments
-                                                                },
-                                                                "finish_reason": None,
-                                                            }
-                                                        ],
-                                                    }
-                                                    yield f"data: {json.dumps(openai_chunk)}\n\n".encode()
-
-                                        elif (
-                                            event_type
-                                            == "response.audio_transcript.delta"
-                                        ):
-                                            # Audio transcript streaming - official API
-                                            if not thinking_block_active:
-                                                transcript = event_data.get(
-                                                    "transcript", ""
-                                                )
-                                                if transcript:
-                                                    chunk_count += 1
-                                                    openai_chunk = {
-                                                        "id": stream_id,
-                                                        "object": "chat.completion.chunk",
-                                                        "created": created,
-                                                        "model": "gpt-5",
-                                                        "choices": [
-                                                            {
-                                                                "index": 0,
-                                                                "delta": {
-                                                                    "content": f"[Audio: {transcript}]"
-                                                                },
-                                                                "finish_reason": None,
-                                                            }
-                                                        ],
-                                                    }
-                                                    yield f"data: {json.dumps(openai_chunk)}\n\n".encode()
-
-                                        elif (
-                                            event_type
-                                            == "response.tool_calls.function.name"
-                                        ):
-                                            # Tool function name - official API
-                                            if not thinking_block_active:
-                                                function_name = event_data.get(
-                                                    "name", ""
-                                                )
-                                                if function_name:
-                                                    chunk_count += 1
-                                                    openai_chunk = {
-                                                        "id": stream_id,
-                                                        "object": "chat.completion.chunk",
-                                                        "created": created,
-                                                        "model": "gpt-5",
-                                                        "choices": [
-                                                            {
-                                                                "index": 0,
-                                                                "delta": {
-                                                                    "content": f"[Function: {function_name}]"
-                                                                },
-                                                                "finish_reason": None,
-                                                            }
-                                                        ],
-                                                    }
-                                                    yield f"data: {json.dumps(openai_chunk)}\n\n".encode()
-
-                                        elif event_type == "response.completed":
-                                            # Final chunk with usage info
-                                            response_obj = event_data.get(
-                                                "response", {}
-                                            )
-                                            usage = response_obj.get("usage")
-
-                                            openai_chunk = {
-                                                "id": stream_id,
-                                                "object": "chat.completion.chunk",
-                                                "created": created,
-                                                "model": response_obj.get(
-                                                    "model", "gpt-5"
-                                                ),
-                                                "choices": [
-                                                    {
-                                                        "index": 0,
-                                                        "delta": {},
-                                                        "finish_reason": "stop",
-                                                    }
-                                                ],
-                                            }
-
-                                            if usage:
-                                                openai_chunk["usage"] = {
-                                                    "prompt_tokens": usage.get(
-                                                        "input_tokens", 0
-                                                    ),
-                                                    "completion_tokens": usage.get(
-                                                        "output_tokens", 0
-                                                    ),
-                                                    "total_tokens": usage.get(
-                                                        "total_tokens", 0
-                                                    ),
-                                                }
-
-                                            chunk_data = f"data: {json.dumps(openai_chunk)}\n\n".encode()
-                                            yield chunk_data
-
-                                            logger.debug(
-                                                "codex_stream_completed",
-                                                total_chunks=chunk_count,
-                                                total_bytes=total_bytes,
-                                            )
-
-                                    except json.JSONDecodeError as e:
-                                        logger.debug(
-                                            "codex_sse_parse_failed",
-                                            data_preview=data_str[:100],
-                                            error=str(e),
-                                        )
-                                        continue
-
-                        except Exception as e:
-                            logger.error(
-                                "codex_stream_error",
-                                error=str(e),
-                                line_count=line_count,
-                            )
-                            raise
-
-                        # Send final [DONE] message
-                        logger.debug(
-                            "codex_stream_sending_done",
-                            total_chunks=chunk_count,
-                            total_bytes=total_bytes,
-                        )
-                        yield b"data: [DONE]\n\n"
-                    else:
-                        # Backend didn't return streaming or returned unexpected format
-                        # When using client.stream(), we need to collect the response differently
-                        chunks = []
-                        async for chunk in response.aiter_bytes():
-                            chunks.append(chunk)
-
-                        response_body = b"".join(chunks)
-
-                        logger.debug(
-                            "codex_chat_non_streaming_response",
-                            body_length=len(response_body),
-                            body_preview=response_body[:200].decode(
-                                "utf-8", errors="replace"
-                            )
-                            if response_body
-                            else "empty",
-                        )
-
-                        if response_body:
-                            # Check if it's actually SSE data that we missed
-                            body_str = response_body.decode("utf-8")
-                            if body_str.startswith("event:") or body_str.startswith(
-                                "data:"
-                            ):
-                                # It's SSE data, try to extract the final JSON
-                                logger.warning(
-                                    "Backend returned SSE data but content-type was not text/event-stream"
-                                )
-                                lines = body_str.strip().split("\n")
-                                for line in reversed(lines):
-                                    if line.startswith("data:") and not line.endswith(
-                                        "[DONE]"
-                                    ):
-                                        try:
-                                            json_str = line[5:].strip()
-                                            response_data = json.loads(json_str)
-                                            if "response" in response_data:
-                                                response_data = response_data[
-                                                    "response"
-                                                ]
-                                            # Convert to OpenAI format and yield as a single chunk
-                                            openai_response = (
-                                                adapter.response_to_chat_completion(
-                                                    response_data
-                                                )
-                                            )
-                                            yield f"data: {openai_response.model_dump_json()}\n\n".encode()
-                                            yield b"data: [DONE]\n\n"
-                                            return
-                                        except json.JSONDecodeError:
-                                            continue
-                                # Couldn't parse SSE data - yield error as SSE event
-                                error_response = {
-                                    "error": {
-                                        "message": "Failed to parse SSE response data",
-                                        "type": "invalid_response_error",
-                                        "code": 502,
-                                    }
-                                }
-                                yield f"data: {json.dumps(error_response)}\n\n".encode()
-                                yield b"data: [DONE]\n\n"
-                                return
-                            else:
-                                # Try to parse as regular JSON
-                                try:
-                                    response_data = json.loads(body_str)
-                                    # Convert to Chat Completions format and yield as single chunk
-                                    openai_response = (
-                                        adapter.response_to_chat_completion(
-                                            response_data
-                                        )
-                                    )
-                                    yield f"data: {openai_response.model_dump_json()}\n\n".encode()
-                                    yield b"data: [DONE]\n\n"
-                                    return
-                                except json.JSONDecodeError as e:
-                                    logger.error(
-                                        "Failed to parse non-streaming response",
-                                        error=str(e),
-                                        body_preview=body_str[:500],
-                                    )
-                                    error_response = {
-                                        "error": {
-                                            "message": "Invalid JSON response from backend",
-                                            "type": "invalid_response_error",
-                                            "code": 502,
-                                        }
-                                    }
-                                    yield f"data: {json.dumps(error_response)}\n\n".encode()
-                                    yield b"data: [DONE]\n\n"
-                                    return
-                        else:
-                            # Empty response - yield error
-                            error_response = {
-                                "error": {
-                                    "message": "Backend returned empty response",
-                                    "type": "empty_response_error",
-                                    "code": 502,
-                                }
-                            }
-                            yield f"data: {json.dumps(error_response)}\n\n".encode()
-                            yield b"data: [DONE]\n\n"
-                            return
-
-            # Execute the generator first to capture headers
-            generator_chunks = []
-            async for chunk in stream_codex_response():
-                generator_chunks.append(chunk)
-
-            # Forward upstream headers but filter out incompatible ones for streaming
-            streaming_headers = dict(response_headers)
-            # Remove headers that conflict with streaming responses
-            streaming_headers.pop("content-length", None)
-            streaming_headers.pop("content-encoding", None)
-            streaming_headers.pop("date", None)
-            # Set streaming-specific headers
-            streaming_headers.update(
-                {
-                    "content-type": "text/event-stream",
-                    "Cache-Control": "no-cache",
-                    "Connection": "keep-alive",
-                }
-            )
-
-            # Replay the collected chunks
-            async def replay_stream() -> AsyncIterator[bytes]:
-                for chunk in generator_chunks:
-                    yield chunk
-
-            # Return streaming response with proper headers - handle missing request_context
-            from ccproxy.observability.context import RequestContext
-
-            # Create a minimal request context if none exists
-            if request_context is None:
-                request_context = RequestContext(
-                    request_id=str(uuid.uuid4()),
-                    start_time=time.perf_counter(),
-                    logger=logger,
-                )
-
-            return StreamingResponseWithLogging(
-                content=replay_stream(),
-                request_context=request_context,
-                metrics=getattr(proxy_service, "metrics", None),
-                status_code=200,
-                media_type="text/event-stream",
-                headers=streaming_headers,
-            )
-        else:
-            # Handle non-streaming request using the proxy service
-            # Cast MockRequest to Request to satisfy type checker
-            mock_request_typed: Request = mock_request  # type: ignore[assignment]
-            response = await proxy_service.handle_codex_request(
-                method="POST",
-                path="/responses",
-                session_id=session_id,
-                access_token=access_token,
-                request=mock_request_typed,
-                settings=settings,
-            )
-
-            # Check if this is a streaming response (shouldn't happen for non-streaming requests)
-            is_streaming_response = isinstance(response, StreamingResponse)
-
-            if is_streaming_response and not openai_request.stream:
-                # User requested non-streaming but backend returned streaming
-                # Consume the stream and convert to non-streaming response
-                accumulated_content = ""
-                final_response = None
-
-                error_response = None
-                accumulated_chunks = ""
-
-                async for chunk in response.body_iterator:  # type: ignore
-                    chunk_str = chunk.decode("utf-8")
-                    accumulated_chunks += chunk_str
-
-                    # The Response API sends SSE events, but errors might be plain JSON
-                    lines = chunk_str.strip().split("\n")
-                    for line in lines:
-                        if line.startswith("data:") and "[DONE]" not in line:
-                            data_str = line[5:].strip()
-                            try:
-                                event_data = json.loads(data_str)
-                                # Look for the completed response
-                                if event_data.get("type") == "response.completed":
-                                    final_response = event_data
-                                # Also check if this is a direct error response (not SSE format)
-                                elif (
-                                    "detail" in event_data and "type" not in event_data
-                                ):
-                                    error_response = event_data
-                            except json.JSONDecodeError:
-                                continue
-
-                # If we didn't find SSE events, try parsing the entire accumulated content as JSON
-                if (
-                    not final_response
-                    and not error_response
-                    and accumulated_chunks.strip()
-                ):
-                    try:
-                        # Try to parse the entire content as JSON (for non-SSE error responses)
-                        json_response = json.loads(accumulated_chunks.strip())
-                        if (
-                            "detail" in json_response
-                            or "error" in json_response
-                            or "message" in json_response
-                        ):
-                            error_response = json_response
-                        else:
-                            # Might be a valid response without SSE formatting
-                            final_response = {"response": json_response}
-                    except json.JSONDecodeError:
-                        # Not valid JSON either
-                        pass
-
-                if final_response:
-                    # Convert to Chat Completions format
-                    return adapter.response_to_chat_completion(final_response)
-                elif error_response:
-                    # Handle error response
-                    error_message = "Request failed"
-                    if "detail" in error_response:
-                        error_message = error_response["detail"]
-                    elif "error" in error_response:
-                        if isinstance(error_response["error"], dict):
-                            error_message = error_response["error"].get(
-                                "message", "Request failed"
-                            )
-                        else:
-                            error_message = str(error_response["error"])
-                    elif "message" in error_response:
-                        error_message = error_response["message"]
-
-                    # Log the error for debugging
-                    logger.error(
-                        "codex_streaming_error_response",
-                        error_data=error_response,
-                        error_message=error_message,
-                    )
-
-                    raise HTTPException(status_code=400, detail=error_message)
-                else:
-                    raise HTTPException(
-                        status_code=502, detail="Failed to parse streaming response"
-                    )
-            else:
-                # Non-streaming response - parse and convert
-                if isinstance(response, Response):
-                    # Check if this is an error response
-                    if response.status_code >= 400:
-                        # Return the error response as-is
-                        error_body = response.body
-                        if error_body:
-                            try:
-                                # Handle bytes/memoryview union
-                                error_body_bytes = (
-                                    bytes(error_body)
-                                    if isinstance(error_body, memoryview)
-                                    else error_body
-                                )
-                                error_data = json.loads(
-                                    error_body_bytes.decode("utf-8")
-                                )
-                                # Log the actual error from backend
-                                logger.error(
-                                    "codex_backend_error",
-                                    status_code=response.status_code,
-                                    error_data=error_data,
-                                )
-                                # Pass through the error from backend
-                                # Handle different error formats from backend
-                                error_message = "Request failed"
-                                if "detail" in error_data:
-                                    error_message = error_data["detail"]
-                                elif "error" in error_data:
-                                    if isinstance(error_data["error"], dict):
-                                        error_message = error_data["error"].get(
-                                            "message", "Request failed"
-                                        )
-                                    else:
-                                        error_message = str(error_data["error"])
-                                elif "message" in error_data:
-                                    error_message = error_data["message"]
-
-                                raise HTTPException(
-                                    status_code=response.status_code,
-                                    detail=error_message,
-                                )
-                            except (json.JSONDecodeError, UnicodeDecodeError):
-                                # Handle bytes/memoryview union for logging
-                                error_body_bytes = (
-                                    bytes(error_body)
-                                    if isinstance(error_body, memoryview)
-                                    else error_body
-                                )
-                                logger.error(
-                                    "codex_backend_error_parse_failed",
-                                    status_code=response.status_code,
-                                    body=error_body_bytes[:500].decode(
-                                        "utf-8", errors="replace"
-                                    ),
-                                )
-                                pass
-                        raise HTTPException(
-                            status_code=response.status_code, detail="Request failed"
-                        )
-
-                    # Read the response body for successful responses
-                    response_body = response.body
-                    if response_body:
-                        try:
-                            # Handle bytes/memoryview union
-                            response_body_bytes = (
-                                bytes(response_body)
-                                if isinstance(response_body, memoryview)
-                                else response_body
-                            )
-                            response_data = json.loads(
-                                response_body_bytes.decode("utf-8")
-                            )
-                            # Convert Response API format to Chat Completions format
-                            return adapter.response_to_chat_completion(response_data)
-                        except (json.JSONDecodeError, UnicodeDecodeError) as e:
-                            logger.error("Failed to parse Codex response", error=str(e))
-                            raise HTTPException(
-                                status_code=502,
-                                detail="Invalid response from Codex API",
-                            ) from e
-
-                # If we can't convert, return error
-                raise HTTPException(
-                    status_code=502, detail="Unable to process Codex response"
-                )
-
-    except HTTPException:
-        raise
-    except AuthenticationError as e:
-        raise HTTPException(status_code=401, detail=str(e)) from None
-    except ProxyError as e:
-        raise HTTPException(status_code=502, detail=str(e)) from None
-    except Exception as e:
-        logger.error("Unexpected error in codex_chat_completions", error=str(e))
-        raise HTTPException(status_code=500, detail="Internal server error") from None
-
-
-# NOTE: Test endpoint commented out after exploration
-# Testing revealed that ChatGPT backend API only supports /responses endpoint
-# and does NOT support OpenAI-style /chat/completions or other endpoints.
-# See codex_endpoint_test_results.md for full findings.
-#
-# @router.api_route("/test/{path:path}", methods=["GET", "POST", "PUT", "DELETE"], response_model=None, include_in_schema=False)
-# async def codex_test_probe(
-#     path: str,
-#     request: Request,
-#     proxy_service: ProxyServiceDep,
-#     settings: Settings = Depends(get_settings),
-#     token_manager: OpenAITokenManager = Depends(get_token_manager),
-#     _: None = Depends(check_codex_enabled),
-# ) -> Response:
-#     """Test endpoint to probe upstream ChatGPT backend API paths.
-#
-#     WARNING: This is a test endpoint for exploration only.
-#     It forwards requests to any path on the ChatGPT backend API.
-#     Should be removed or protected after testing.
-#     """
-#     # Get and validate access token
-#     try:
-#         access_token = await token_manager.get_valid_token()
-#         if not access_token:
-#             raise HTTPException(
-#                 status_code=401,
-#                 detail="No valid OpenAI credentials found. Please authenticate first.",
-#             )
-#     except Exception as e:
-#         logger.error("Failed to get OpenAI access token", error=str(e))
-#         raise HTTPException(
-#             status_code=401, detail="Failed to retrieve valid credentials"
-#         ) from e
-#
-#     # Log the test request
-#     logger.info(f"Testing upstream path: /{path}", method=request.method)
-#
-#     try:
-#         # Use a simple session_id for testing
-#         session_id = "test-probe"
-#
-#         # Handle the test request - forward to the specified path
-#         response = await proxy_service.handle_codex_request(
-#             method=request.method,
-#             path=f"/{path}",
-#             session_id=session_id,
-#             access_token=access_token,
-#             request=request,
-#             settings=settings,
-#         )
-#
-#         logger.info(f"Test probe response for /{path}", status_code=getattr(response, "status_code", 200))
-#         return response
-#     except AuthenticationError as e:
-#         logger.warning(f"Auth error for path /{path}: {str(e)}")
-#         raise HTTPException(status_code=401, detail=str(e)) from None from e
-#     except ProxyError as e:
-#         logger.warning(f"Proxy error for path /{path}: {str(e)}")
-#         raise HTTPException(status_code=502, detail=str(e)) from None from e
-#     except Exception as e:
-#         logger.error(f"Unexpected error testing path /{path}", error=str(e))
-#         raise HTTPException(status_code=500, detail=f"Error testing path: {str(e)}") from e