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

ccproxy/services/proxy_service.py

@@ -5,7 +5,6 @@ import json
 import os
 import random
 import time
-import urllib.parse
 from collections.abc import AsyncGenerator
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
@@ -14,9 +13,11 @@ import httpx
 import structlog
 from fastapi import HTTPException, Request
 from fastapi.responses import StreamingResponse
+from starlette.responses import Response
 from typing_extensions import TypedDict
 
 from ccproxy.config.settings import Settings
+from ccproxy.core.codex_transformers import CodexRequestTransformer
 from ccproxy.core.http import BaseProxyClient
 from ccproxy.core.http_transformers import (
     HTTPRequestTransformer,
@@ -29,6 +30,7 @@ from ccproxy.observability import (
     timed_operation,
 )
 from ccproxy.observability.access_logger import log_request_access
+from ccproxy.observability.streaming_response import StreamingResponseWithLogging
 from ccproxy.services.credentials.manager import CredentialsManager
 from ccproxy.testing import RealisticMockResponseGenerator
 from ccproxy.utils.simple_request_logger import (
@@ -83,6 +85,7 @@ class ProxyService:
         proxy_mode: str = "full",
         target_base_url: str = "https://api.anthropic.com",
         metrics: PrometheusMetrics | None = None,
+        app_state: Any = None,
     ) -> None:
         """Initialize the proxy service.
 
@@ -93,6 +96,7 @@ class ProxyService:
             proxy_mode: Transformation mode - "minimal" or "full"
             target_base_url: Base URL for the target API
             metrics: Prometheus metrics collector (optional)
+            app_state: FastAPI app state for accessing detection data
         """
         self.proxy_client = proxy_client
         self.credentials_manager = credentials_manager
@@ -100,10 +104,12 @@ class ProxyService:
         self.proxy_mode = proxy_mode
         self.target_base_url = target_base_url.rstrip("/")
         self.metrics = metrics or get_metrics()
+        self.app_state = app_state
 
         # Create concrete transformers
         self.request_transformer = HTTPRequestTransformer()
         self.response_transformer = HTTPResponseTransformer()
+        self.codex_transformer = CodexRequestTransformer()
 
         # Create OpenAI adapter for stream transformation
         from ccproxy.adapters.openai.adapter import OpenAIAdapter
@@ -122,10 +128,6 @@ class ProxyService:
         self._verbose_api = (
             os.environ.get("CCPROXY_VERBOSE_API", "false").lower() == "true"
         )
-        # Note: Request logging is now handled by simple_request_logger utility
-        # which checks CCPROXY_LOG_REQUESTS and CCPROXY_REQUEST_LOG_DIR independently
-
-        # Request context is now passed as parameters to methods
 
     def _init_proxy_url(self) -> str | None:
         """Initialize proxy URL from environment variables."""
@@ -239,9 +241,25 @@ class ProxyService:
 
                 # 2. Request transformation
                 async with timed_operation("request_transform", ctx.request_id):
-                    logger.debug("request_transform_start")
-                    transformed_request = await self._transform_request(
-                        method, path, headers, body, query_params, access_token
+                    injection_mode = (
+                        self.settings.claude.system_prompt_injection_mode.value
+                    )
+                    logger.debug(
+                        "request_transform_start",
+                        system_prompt_injection_mode=injection_mode,
+                    )
+                    transformed_request = (
+                        await self.request_transformer.transform_proxy_request(
+                            method,
+                            path,
+                            headers,
+                            body,
+                            query_params,
+                            access_token,
+                            self.target_base_url,
+                            self.app_state,
+                            injection_mode,
+                        )
                     )
 
                 # 3. Check for bypass header to skip upstream forwarding
@@ -330,29 +348,25 @@ class ProxyService:
                             content_length=len(response_body) if response_body else 0,
                         )
 
-                        # Transform error to OpenAI format if this is an OpenAI endpoint
-                        transformed_error_body = response_body
-                        if self.response_transformer._is_openai_request(path):
-                            try:
-                                error_data = json.loads(response_body.decode("utf-8"))
-                                openai_error = self.openai_adapter.adapt_error(
-                                    error_data
-                                )
-                                transformed_error_body = json.dumps(
-                                    openai_error
-                                ).encode("utf-8")
-                            except (json.JSONDecodeError, UnicodeDecodeError):
-                                # Keep original error if parsing fails
-                                pass
-
-                        transformed_response = ResponseData(
-                            status_code=status_code,
-                            headers=response_headers,
-                            body=transformed_error_body,
+                        # Use transformer to handle error transformation (including OpenAI format)
+                        transformed_response = (
+                            await self.response_transformer.transform_proxy_response(
+                                status_code,
+                                response_headers,
+                                response_body,
+                                path,
+                                self.proxy_mode,
+                            )
                         )
                     else:
-                        transformed_response = await self._transform_response(
-                            status_code, response_headers, response_body, path
+                        transformed_response = (
+                            await self.response_transformer.transform_proxy_response(
+                                status_code,
+                                response_headers,
+                                response_body,
+                                path,
+                                self.proxy_mode,
+                            )
                         )
 
                 # 5. Extract response metrics using direct JSON parsing
@@ -393,14 +407,6 @@ class ProxyService:
                     cost_usd=cost_usd,
                 )
 
-                # 7. Log comprehensive access log (includes Prometheus metrics)
-                await log_request_access(
-                    context=ctx,
-                    status_code=status_code,
-                    method=method,
-                    metrics=self.metrics,
-                )
-
                 return (
                     transformed_response["status_code"],
                     transformed_response["headers"],
@@ -408,28 +414,386 @@ class ProxyService:
                 )
 
             except Exception as e:
-                # Record error metrics via access logger
-                error_type = type(e).__name__
+                ctx.add_metadata(error=e)
+                raise
 
-                # Log the error with access logger (includes metrics)
-                await log_request_access(
-                    context=ctx,
-                    method=method,
-                    error_message=str(e),
-                    metrics=self.metrics,
-                    error_type=error_type,
-                )
+    async def handle_codex_request(
+        self,
+        method: str,
+        path: str,
+        session_id: str,
+        access_token: str,
+        request: Request,
+        settings: Settings,
+    ) -> StreamingResponse | Response:
+        """Handle OpenAI Codex proxy request with request/response capture.
+
+        Args:
+            method: HTTP method
+            path: Request path (e.g., "/responses" or "/{session_id}/responses")
+            session_id: Resolved session ID
+            access_token: OpenAI access token
+            request: FastAPI request object
+            settings: Application settings
 
-                logger.exception(
-                    "proxy_request_failed",
-                    method=method,
-                    path=path,
+        Returns:
+            StreamingResponse or regular Response
+        """
+        try:
+            # Read request body - check if already stored by middleware
+            if hasattr(request.state, "body"):
+                body = request.state.body
+            else:
+                body = await request.body()
+
+            # Parse request data to capture the instructions field and other metadata
+            request_data = None
+            try:
+                request_data = json.loads(body.decode("utf-8")) if body else {}
+            except (json.JSONDecodeError, UnicodeDecodeError) as e:
+                request_data = {}
+                logger.warning(
+                    "codex_json_decode_failed",
                     error=str(e),
-                    exc_info=True,
+                    body_preview=body[:100].decode("utf-8", errors="replace")
+                    if body
+                    else None,
+                    body_length=len(body) if body else 0,
                 )
-                # Re-raise the exception without transformation
-                # Let higher layers handle specific error types
-                raise
+
+            # Parse request to extract account_id from token if available
+            import jwt
+
+            account_id = "unknown"
+            try:
+                decoded = jwt.decode(access_token, options={"verify_signature": False})
+                account_id = decoded.get(
+                    "org_id", decoded.get("sub", decoded.get("account_id", "unknown"))
+                )
+            except Exception:
+                pass
+
+            # Get Codex detection data from app state
+            codex_detection_data = None
+            if self.app_state and hasattr(self.app_state, "codex_detection_data"):
+                codex_detection_data = self.app_state.codex_detection_data
+
+            # Use CodexRequestTransformer to build request
+            original_headers = dict(request.headers)
+            transformed_request = await self.codex_transformer.transform_codex_request(
+                method=method,
+                path=path,
+                headers=original_headers,
+                body=body,
+                access_token=access_token,
+                session_id=session_id,
+                account_id=account_id,
+                codex_detection_data=codex_detection_data,
+                target_base_url=settings.codex.base_url,
+            )
+
+            target_url = transformed_request["url"]
+            headers = transformed_request["headers"]
+            transformed_body = transformed_request["body"] or body
+
+            # Parse transformed body for logging
+            transformed_request_data = request_data
+            if transformed_body and transformed_body != body:
+                try:
+                    transformed_request_data = json.loads(
+                        transformed_body.decode("utf-8")
+                    )
+                except (json.JSONDecodeError, UnicodeDecodeError):
+                    transformed_request_data = request_data
+
+            # Generate request ID for logging
+            from uuid import uuid4
+
+            request_id = f"codex_{uuid4().hex[:8]}"
+
+            # Log Codex request (including instructions field and headers)
+            await self._log_codex_request(
+                request_id=request_id,
+                method=method,
+                url=target_url,
+                headers=headers,
+                body_data=transformed_request_data,
+                session_id=session_id,
+            )
+
+            # Check if user explicitly requested streaming (from original request)
+            user_requested_streaming = self.codex_transformer._is_streaming_request(
+                body
+            )
+
+            # Forward request to ChatGPT backend
+            if user_requested_streaming:
+                # Handle streaming request with proper context management
+                # First, collect the response to check for errors
+                collected_chunks = []
+                chunk_count = 0
+                total_bytes = 0
+                response_status_code = 200
+                response_headers = {}
+
+                async def stream_codex_response() -> AsyncGenerator[bytes, None]:
+                    nonlocal \
+                        collected_chunks, \
+                        chunk_count, \
+                        total_bytes, \
+                        response_status_code, \
+                        response_headers
+
+                    logger.debug(
+                        "proxy_service_streaming_started",
+                        request_id=request_id,
+                        session_id=session_id,
+                    )
+
+                    async with (
+                        httpx.AsyncClient(timeout=240.0) as client,
+                        client.stream(
+                            method=method,
+                            url=target_url,
+                            headers=headers,
+                            content=transformed_body,
+                        ) as response,
+                    ):
+                        # Capture response info for error checking
+                        response_status_code = response.status_code
+                        response_headers = dict(response.headers)
+
+                        # Log response headers for streaming
+                        await self._log_codex_response_headers(
+                            request_id=request_id,
+                            status_code=response.status_code,
+                            headers=dict(response.headers),
+                            stream_type="codex_sse",
+                        )
+
+                        # Check if upstream actually returned streaming
+                        content_type = response.headers.get("content-type", "")
+                        is_streaming = "text/event-stream" in content_type
+
+                        if not is_streaming:
+                            logger.warning(
+                                "codex_expected_streaming_but_got_regular",
+                                content_type=content_type,
+                                status_code=response.status_code,
+                            )
+
+                        async for chunk in response.aiter_bytes():
+                            chunk_count += 1
+                            chunk_size = len(chunk)
+                            total_bytes += chunk_size
+                            collected_chunks.append(chunk)
+
+                            logger.debug(
+                                "proxy_service_streaming_chunk",
+                                request_id=request_id,
+                                chunk_number=chunk_count,
+                                chunk_size=chunk_size,
+                                total_bytes=total_bytes,
+                            )
+
+                            yield chunk
+
+                    logger.debug(
+                        "proxy_service_streaming_complete",
+                        request_id=request_id,
+                        total_chunks=chunk_count,
+                        total_bytes=total_bytes,
+                    )
+
+                    # Log the complete stream data after streaming finishes
+                    await self._log_codex_streaming_complete(
+                        request_id=request_id,
+                        chunks=collected_chunks,
+                    )
+
+                # Execute the stream generator to collect the response
+                generator_chunks = []
+                async for chunk in stream_codex_response():
+                    generator_chunks.append(chunk)
+
+                # Now check if this should be an error response
+                content_type = response_headers.get("content-type", "")
+                if (
+                    response_status_code >= 400
+                    and "text/event-stream" not in content_type
+                ):
+                    # Return error as regular Response with proper status code
+                    error_content = b"".join(collected_chunks)
+                    logger.warning(
+                        "codex_returning_error_as_regular_response",
+                        status_code=response_status_code,
+                        content_type=content_type,
+                        content_preview=error_content[:200].decode(
+                            "utf-8", errors="replace"
+                        ),
+                    )
+                    return Response(
+                        content=error_content,
+                        status_code=response_status_code,
+                        headers=response_headers,
+                    )
+
+                # Return normal streaming response
+                async def replay_stream() -> AsyncGenerator[bytes, None]:
+                    for chunk in generator_chunks:
+                        yield 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",
+                    }
+                )
+
+                return StreamingResponse(
+                    replay_stream(),
+                    media_type="text/event-stream",
+                    headers=streaming_headers,
+                )
+            else:
+                # Handle non-streaming request
+                async with httpx.AsyncClient(timeout=240.0) as client:
+                    response = await client.request(
+                        method=method,
+                        url=target_url,
+                        headers=headers,
+                        content=transformed_body,
+                    )
+
+                    # Check if upstream response is streaming (shouldn't happen)
+                    content_type = response.headers.get("content-type", "")
+                    transfer_encoding = response.headers.get("transfer-encoding", "")
+                    upstream_is_streaming = "text/event-stream" in content_type or (
+                        transfer_encoding == "chunked" and content_type == ""
+                    )
+
+                    logger.debug(
+                        "codex_response_non_streaming",
+                        content_type=content_type,
+                        user_requested_streaming=user_requested_streaming,
+                        upstream_is_streaming=upstream_is_streaming,
+                        transfer_encoding=transfer_encoding,
+                    )
+
+                    if upstream_is_streaming:
+                        # Upstream is streaming but user didn't request streaming
+                        # Collect all streaming data and return as JSON
+                        logger.debug(
+                            "converting_upstream_stream_to_json", request_id=request_id
+                        )
+
+                        collected_chunks = []
+                        async for chunk in response.aiter_bytes():
+                            collected_chunks.append(chunk)
+
+                        # Combine all chunks
+                        full_content = b"".join(collected_chunks)
+
+                        # Try to parse the streaming data and extract the final response
+                        try:
+                            # Parse SSE data to extract JSON response
+                            content_str = full_content.decode("utf-8")
+                            lines = content_str.strip().split("\n")
+
+                            # Look for the last data line with JSON content
+                            final_json = None
+                            for line in reversed(lines):
+                                if line.startswith("data: ") and not line.endswith(
+                                    "[DONE]"
+                                ):
+                                    try:
+                                        json_str = line[6:]  # Remove "data: " prefix
+                                        final_json = json.loads(json_str)
+                                        break
+                                    except json.JSONDecodeError:
+                                        continue
+
+                            if final_json:
+                                response_content = json.dumps(final_json).encode(
+                                    "utf-8"
+                                )
+                            else:
+                                # Fallback: return the raw content
+                                response_content = full_content
+
+                        except (UnicodeDecodeError, json.JSONDecodeError):
+                            # Fallback: return raw content
+                            response_content = full_content
+
+                        # Log the complete response
+                        try:
+                            response_data = json.loads(response_content.decode("utf-8"))
+                        except (json.JSONDecodeError, UnicodeDecodeError):
+                            response_data = {
+                                "raw_content": response_content.decode(
+                                    "utf-8", errors="replace"
+                                )
+                            }
+
+                        await self._log_codex_response(
+                            request_id=request_id,
+                            status_code=response.status_code,
+                            headers=dict(response.headers),
+                            body_data=response_data,
+                        )
+
+                        # Return as JSON response
+                        return Response(
+                            content=response_content,
+                            status_code=response.status_code,
+                            headers={
+                                "content-type": "application/json",
+                                "content-length": str(len(response_content)),
+                            },
+                            media_type="application/json",
+                        )
+                    else:
+                        # For regular non-streaming responses
+                        response_data = None
+                        try:
+                            response_data = (
+                                json.loads(response.content.decode("utf-8"))
+                                if response.content
+                                else {}
+                            )
+                        except (json.JSONDecodeError, UnicodeDecodeError):
+                            response_data = {
+                                "raw_content": response.content.decode(
+                                    "utf-8", errors="replace"
+                                )
+                            }
+
+                        await self._log_codex_response(
+                            request_id=request_id,
+                            status_code=response.status_code,
+                            headers=dict(response.headers),
+                            body_data=response_data,
+                        )
+
+                        # Return regular response
+                        return Response(
+                            content=response.content,
+                            status_code=response.status_code,
+                            headers=dict(response.headers),
+                            media_type=response.headers.get("content-type"),
+                        )
+
+        except Exception as e:
+            logger.error("Codex request failed", error=str(e), session_id=session_id)
+            raise
 
     async def _get_access_token(self) -> str:
         """Get access token for upstream authentication.
@@ -491,120 +855,6 @@ class ProxyService:
                 detail="Authentication failed",
             ) from e
 
-    async def _transform_request(
-        self,
-        method: str,
-        path: str,
-        headers: dict[str, str],
-        body: bytes | None,
-        query_params: dict[str, str | list[str]] | None,
-        access_token: str,
-    ) -> RequestData:
-        """Transform request using the transformer pipeline.
-
-        Args:
-            method: HTTP method
-            path: Request path
-            headers: Request headers
-            body: Request body
-            query_params: Query parameters
-            access_token: OAuth access token
-
-        Returns:
-            Transformed request data
-        """
-        # Transform path
-        transformed_path = self.request_transformer.transform_path(
-            path, self.proxy_mode
-        )
-        target_url = f"{self.target_base_url}{transformed_path}"
-
-        # Add beta=true query parameter for /v1/messages requests if not already present
-        if transformed_path == "/v1/messages":
-            if query_params is None:
-                query_params = {}
-            elif "beta" not in query_params:
-                query_params = dict(query_params)  # Make a copy
-
-            if "beta" not in query_params:
-                query_params["beta"] = "true"
-                logger.debug("beta_parameter_added")
-
-        # Transform body first (as it might change size)
-        proxy_body = None
-        if body:
-            proxy_body = self.request_transformer.transform_request_body(
-                body, path, self.proxy_mode
-            )
-
-        # Transform headers (and update Content-Length if body changed)
-        proxy_headers = self.request_transformer.create_proxy_headers(
-            headers, access_token, self.proxy_mode
-        )
-
-        # Update Content-Length if body was transformed and size changed
-        if proxy_body and body and len(proxy_body) != len(body):
-            # Remove any existing content-length headers (case-insensitive)
-            proxy_headers = {
-                k: v for k, v in proxy_headers.items() if k.lower() != "content-length"
-            }
-            proxy_headers["Content-Length"] = str(len(proxy_body))
-        elif proxy_body and not body:
-            # New body was created where none existed
-            proxy_headers["Content-Length"] = str(len(proxy_body))
-
-        # Add query parameters to URL if present
-        if query_params:
-            query_string = urllib.parse.urlencode(query_params)
-            target_url = f"{target_url}?{query_string}"
-
-        return {
-            "method": method,
-            "url": target_url,
-            "headers": proxy_headers,
-            "body": proxy_body,
-        }
-
-    async def _transform_response(
-        self,
-        status_code: int,
-        headers: dict[str, str],
-        body: bytes,
-        original_path: str,
-    ) -> ResponseData:
-        """Transform response using the transformer pipeline.
-
-        Args:
-            status_code: HTTP status code
-            headers: Response headers
-            body: Response body
-            original_path: Original request path for context
-
-        Returns:
-            Transformed response data
-        """
-        # For error responses, pass through without transformation
-        if status_code >= 400:
-            return {
-                "status_code": status_code,
-                "headers": headers,
-                "body": body,
-            }
-
-        transformed_body = self.response_transformer.transform_response_body(
-            body, original_path, self.proxy_mode
-        )
-
-        transformed_headers = self.response_transformer.transform_response_headers(
-            headers, original_path, len(transformed_body), self.proxy_mode
-        )
-
-        return {
-            "status_code": status_code,
-            "headers": transformed_headers,
-            "body": transformed_body,
-        }
-
     def _redact_headers(self, headers: dict[str, str]) -> dict[str, str]:
         """Redact sensitive information from headers for safe logging."""
         return {
@@ -715,6 +965,155 @@ class ProxyService:
             timestamp=timestamp,
         )
 
+    async def _log_codex_request(
+        self,
+        request_id: str,
+        method: str,
+        url: str,
+        headers: dict[str, str],
+        body_data: dict[str, Any] | None,
+        session_id: str,
+    ) -> None:
+        """Log outgoing Codex request preserving instructions field exactly."""
+        if not self._verbose_api:
+            return
+
+        # Log to console with redacted headers
+        logger.info(
+            "verbose_codex_request",
+            request_id=request_id,
+            method=method,
+            url=url,
+            headers=self._redact_headers(headers),
+            session_id=session_id,
+            instructions_preview=(
+                body_data.get("instructions", "")[:100] + "..."
+                if body_data and body_data.get("instructions")
+                else None
+            ),
+        )
+
+        # Save complete request to file (without redaction)
+        timestamp = time.strftime("%Y%m%d_%H%M%S")
+        await write_request_log(
+            request_id=request_id,
+            log_type="codex_request",
+            data={
+                "method": method,
+                "url": url,
+                "headers": dict(headers),
+                "body": body_data,
+                "session_id": session_id,
+            },
+            timestamp=timestamp,
+        )
+
+    async def _log_codex_response(
+        self,
+        request_id: str,
+        status_code: int,
+        headers: dict[str, str],
+        body_data: dict[str, Any] | None,
+    ) -> None:
+        """Log complete non-streaming Codex response."""
+        if not self._verbose_api:
+            return
+
+        # Log to console with redacted headers
+        logger.info(
+            "verbose_codex_response",
+            request_id=request_id,
+            status_code=status_code,
+            headers=self._redact_headers(headers),
+            response_type="non_streaming",
+        )
+
+        # Save complete response to file
+        timestamp = time.strftime("%Y%m%d_%H%M%S")
+        await write_request_log(
+            request_id=request_id,
+            log_type="codex_response",
+            data={
+                "status_code": status_code,
+                "headers": dict(headers),
+                "body": body_data,
+            },
+            timestamp=timestamp,
+        )
+
+    async def _log_codex_response_headers(
+        self,
+        request_id: str,
+        status_code: int,
+        headers: dict[str, str],
+        stream_type: str,
+    ) -> None:
+        """Log streaming Codex response headers."""
+        if not self._verbose_api:
+            return
+
+        # Log to console with redacted headers
+        logger.info(
+            "verbose_codex_response_headers",
+            request_id=request_id,
+            status_code=status_code,
+            headers=self._redact_headers(headers),
+            stream_type=stream_type,
+        )
+
+        # Save response headers to file
+        timestamp = time.strftime("%Y%m%d_%H%M%S")
+        await write_request_log(
+            request_id=request_id,
+            log_type="codex_response_headers",
+            data={
+                "status_code": status_code,
+                "headers": dict(headers),
+                "stream_type": stream_type,
+            },
+            timestamp=timestamp,
+        )
+
+    async def _log_codex_streaming_complete(
+        self,
+        request_id: str,
+        chunks: list[bytes],
+    ) -> None:
+        """Log complete streaming data after stream finishes."""
+        if not self._verbose_api:
+            return
+
+        # Combine chunks and decode for analysis
+        complete_data = b"".join(chunks)
+        try:
+            decoded_data = complete_data.decode("utf-8", errors="replace")
+        except Exception:
+            decoded_data = f"<binary data of length {len(complete_data)}>"
+
+        # Log to console with preview
+        logger.info(
+            "verbose_codex_streaming_complete",
+            request_id=request_id,
+            total_bytes=len(complete_data),
+            chunk_count=len(chunks),
+            data_preview=decoded_data[:200] + "..."
+            if len(decoded_data) > 200
+            else decoded_data,
+        )
+
+        # Save complete streaming data to file
+        timestamp = time.strftime("%Y%m%d_%H%M%S")
+        await write_request_log(
+            request_id=request_id,
+            log_type="codex_streaming_complete",
+            data={
+                "total_bytes": len(complete_data),
+                "chunk_count": len(chunks),
+                "complete_data": decoded_data,
+            },
+            timestamp=timestamp,
+        )
+
     def _should_stream_response(self, headers: dict[str, str]) -> bool:
         """Check if response should be streamed based on request headers.
 
@@ -810,18 +1209,17 @@ class ProxyService:
                     error_detail=error_content.decode("utf-8", errors="replace"),
                 )
 
-                # Transform error to OpenAI format if this is an OpenAI endpoint
-                transformed_error_body = error_content
-                if self.response_transformer._is_openai_request(original_path):
-                    try:
-                        error_data = json.loads(error_content.decode("utf-8"))
-                        openai_error = self.openai_adapter.adapt_error(error_data)
-                        transformed_error_body = json.dumps(openai_error).encode(
-                            "utf-8"
-                        )
-                    except (json.JSONDecodeError, UnicodeDecodeError):
-                        # Keep original error if parsing fails
-                        pass
+                # Use transformer to handle error transformation (including OpenAI format)
+                transformed_error_response = (
+                    await self.response_transformer.transform_proxy_response(
+                        response.status_code,
+                        dict(response.headers),
+                        error_content,
+                        original_path,
+                        self.proxy_mode,
+                    )
+                )
+                transformed_error_body = transformed_error_response["body"]
 
                 # Update context with error status
                 ctx.add_metadata(status_code=response.status_code)
@@ -844,10 +1242,32 @@ class ProxyService:
                 )
 
         # If no error, proceed with streaming
-        # Store response headers to preserve for streaming
+        # Make initial request to get headers
+        proxy_url = self._proxy_url
+        verify = self._ssl_context
+
         response_headers = {}
         response_status = 200
 
+        async with httpx.AsyncClient(
+            timeout=timeout, proxy=proxy_url, verify=verify
+        ) as client:
+            # Make initial request to capture headers
+            initial_response = await client.send(
+                client.build_request(
+                    method=request_data["method"],
+                    url=request_data["url"],
+                    headers=request_data["headers"],
+                    content=request_data["body"],
+                ),
+                stream=True,
+            )
+            response_status = initial_response.status_code
+            response_headers = dict(initial_response.headers)
+
+            # Close the initial response since we'll make a new one in the generator
+            await initial_response.aclose()
+
         # Initialize streaming metrics collector
         from ccproxy.utils.streaming_metrics import StreamingMetricsCollector
 
@@ -1006,18 +1426,7 @@ class ProxyService:
                                         cost_usd=cost_usd,
                                     )
 
-                                    # Log comprehensive access log for streaming completion
-                                    from ccproxy.observability.access_logger import (
-                                        log_request_access,
-                                    )
-
-                                    await log_request_access(
-                                        context=ctx,
-                                        status_code=response_status,
-                                        metrics=self.metrics,
-                                        # Additional metadata for streaming completion
-                                        event_type="streaming_complete",
-                                    )
+                                    # Access logging is now handled by StreamingResponseWithLogging
 
                                 if (
                                     "content_block_delta" in chunk_str
@@ -1063,6 +1472,11 @@ class ProxyService:
         # Always use upstream headers as base
         final_headers = response_headers.copy()
 
+        # Remove headers that can cause conflicts
+        final_headers.pop(
+            "date", None
+        )  # Remove upstream date header to avoid conflicts
+
         # Ensure critical headers for streaming
         final_headers["Cache-Control"] = "no-cache"
         final_headers["Connection"] = "keep-alive"
@@ -1071,8 +1485,10 @@ class ProxyService:
         if "content-type" not in final_headers:
             final_headers["content-type"] = "text/event-stream"
 
-        return StreamingResponse(
-            stream_generator(),
+        return StreamingResponseWithLogging(
+            content=stream_generator(),
+            request_context=ctx,
+            metrics=self.metrics,
             status_code=response_status,
             headers=final_headers,
         )
@@ -1330,7 +1746,12 @@ class ProxyService:
             cost_usd=cost_usd,
         )
 
-        return StreamingResponse(realistic_mock_stream_generator(), headers=headers)
+        return StreamingResponseWithLogging(
+            content=realistic_mock_stream_generator(),
+            request_context=ctx,
+            metrics=self.metrics,
+            headers=headers,
+        )
 
     async def _generate_realistic_openai_stream(
         self,