ccproxy-api 0.1.4__py3-none-any.whl → 0.1.5__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
@@ -29,6 +28,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 +83,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 +94,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,6 +102,7 @@ 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()
@@ -122,10 +125,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 +238,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 +345,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 +404,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,27 +411,7 @@ class ProxyService:
                 )
 
             except Exception as e:
-                # Record error metrics via access logger
-                error_type = type(e).__name__
-
-                # 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,
-                )
-
-                logger.exception(
-                    "proxy_request_failed",
-                    method=method,
-                    path=path,
-                    error=str(e),
-                    exc_info=True,
-                )
-                # Re-raise the exception without transformation
-                # Let higher layers handle specific error types
+                ctx.add_metadata(error=e)
                 raise
 
     async def _get_access_token(self) -> str:
@@ -491,120 +474,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 {
@@ -810,18 +679,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 +712,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 +896,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 +942,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 +955,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 +1216,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,

ccproxy/utils/__init__.py

@@ -1,6 +1,14 @@
 """Utility modules for shared functionality across the application."""
 
 from .cost_calculator import calculate_cost_breakdown, calculate_token_cost
+from .disconnection_monitor import monitor_disconnection, monitor_stuck_stream
+from .id_generator import generate_client_id
 
 
-__all__ = ["calculate_token_cost", "calculate_cost_breakdown"]
+__all__ = [
+    "calculate_token_cost",
+    "calculate_cost_breakdown",
+    "monitor_disconnection",
+    "monitor_stuck_stream",
+    "generate_client_id",
+]

ccproxy/utils/disconnection_monitor.py

@@ -0,0 +1,83 @@
+"""Utility functions for monitoring client disconnection and stuck streams during streaming responses."""
+
+import asyncio
+from typing import TYPE_CHECKING
+
+import structlog
+from starlette.requests import Request
+
+
+if TYPE_CHECKING:
+    from ccproxy.services.claude_sdk_service import ClaudeSDKService
+
+logger = structlog.get_logger(__name__)
+
+
+async def monitor_disconnection(
+    request: Request, session_id: str, claude_service: "ClaudeSDKService"
+) -> None:
+    """Monitor for client disconnection and interrupt session if detected.
+
+    Args:
+        request: The incoming HTTP request
+        session_id: The Claude SDK session ID to interrupt if disconnected
+        claude_service: The Claude SDK service instance
+    """
+    try:
+        while True:
+            await asyncio.sleep(1.0)  # Check every second
+            if await request.is_disconnected():
+                logger.info(
+                    "client_disconnected_interrupting_session", session_id=session_id
+                )
+                try:
+                    await claude_service.sdk_client.interrupt_session(session_id)
+                except Exception as e:
+                    logger.error(
+                        "failed_to_interrupt_session",
+                        session_id=session_id,
+                        error=str(e),
+                    )
+                return
+    except asyncio.CancelledError:
+        # Task was cancelled, which is expected when streaming completes normally
+        logger.debug("disconnection_monitor_cancelled", session_id=session_id)
+        raise
+
+
+async def monitor_stuck_stream(
+    session_id: str,
+    claude_service: "ClaudeSDKService",
+    first_chunk_event: asyncio.Event,
+    timeout: float = 10.0,
+) -> None:
+    """Monitor for stuck streams that don't produce a first chunk (SystemMessage).
+
+    Args:
+        session_id: The Claude SDK session ID to monitor
+        claude_service: The Claude SDK service instance
+        first_chunk_event: Event that will be set when first chunk is received
+        timeout: Seconds to wait for first chunk before considering stream stuck
+    """
+    try:
+        # Wait for first chunk with timeout
+        await asyncio.wait_for(first_chunk_event.wait(), timeout=timeout)
+        logger.debug("stuck_stream_first_chunk_received", session_id=session_id)
+    except TimeoutError:
+        logger.error(
+            "streaming_system_message_timeout",
+            session_id=session_id,
+            timeout=timeout,
+            message=f"No SystemMessage received within {timeout}s, interrupting session",
+        )
+        try:
+            await claude_service.sdk_client.interrupt_session(session_id)
+            logger.info("stuck_session_interrupted_successfully", session_id=session_id)
+        except Exception as e:
+            logger.error(
+                "failed_to_interrupt_stuck_session", session_id=session_id, error=str(e)
+            )
+    except asyncio.CancelledError:
+        # Task was cancelled, which is expected when streaming completes normally
+        logger.debug("stuck_stream_monitor_cancelled", session_id=session_id)
+        raise

ccproxy/utils/id_generator.py

@@ -0,0 +1,12 @@
+"""Utility functions for generating consistent IDs across the application."""
+
+import uuid
+
+
+def generate_client_id() -> str:
+    """Generate a consistent client ID for SDK connections.
+
+    Returns:
+        str: First part of a UUID4 (8 characters)
+    """
+    return str(uuid.uuid4()).split("-")[0]