ccproxy-api 0.1.0__py3-none-any.whl

ccproxy/api/middleware/headers.py

@@ -0,0 +1,51 @@
+"""Header preservation middleware to maintain proxy response headers."""
+
+from collections.abc import Callable
+
+from fastapi import Request, Response
+from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
+from starlette.types import ASGIApp
+
+
+class HeaderPreservationMiddleware(BaseHTTPMiddleware):
+    """Middleware to preserve certain headers from proxy responses.
+
+    This middleware ensures that headers like 'server' from the upstream
+    API are preserved and not overridden by Uvicorn/Starlette.
+    """
+
+    def __init__(self, app: ASGIApp):
+        """Initialize the header preservation middleware.
+
+        Args:
+            app: The ASGI application
+        """
+        super().__init__(app)
+
+    async def dispatch(
+        self, request: Request, call_next: RequestResponseEndpoint
+    ) -> Response:
+        """Process the request and preserve specific headers.
+
+        Args:
+            request: The incoming HTTP request
+            call_next: The next middleware/handler in the chain
+
+        Returns:
+            The HTTP response with preserved headers
+        """
+        # Process the request
+        response = await call_next(request)
+
+        # Check if we have a stored server header to preserve
+        # This would be set by the proxy service if we want to preserve it
+        if hasattr(request.state, "preserve_headers"):
+            for header_name, header_value in request.state.preserve_headers.items():
+                # Force set the header to override any default values
+                response.headers[header_name] = header_value
+                # Also try raw header setting for more control
+                response.raw_headers.append(
+                    (header_name.encode(), header_value.encode())
+                )
+
+        return response

ccproxy/api/middleware/logging.py

@@ -0,0 +1,175 @@
+"""Access logging middleware for structured HTTP request/response logging."""
+
+import time
+from typing import Any, Optional
+
+import structlog
+from fastapi import Request, Response
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.types import ASGIApp
+
+
+logger = structlog.get_logger(__name__)
+
+
+class AccessLogMiddleware(BaseHTTPMiddleware):
+    """Middleware for structured access logging with request/response details."""
+
+    def __init__(self, app: ASGIApp):
+        """Initialize the access log middleware.
+
+        Args:
+            app: The ASGI application
+        """
+        super().__init__(app)
+
+    async def dispatch(self, request: Request, call_next: Any) -> Response:
+        """Process the request and log access details.
+
+        Args:
+            request: The incoming HTTP request
+            call_next: The next middleware/handler in the chain
+
+        Returns:
+            The HTTP response
+        """
+        # Record start time
+        start_time = time.perf_counter()
+
+        # Store log storage in request state if collection is enabled
+        from ccproxy.config.settings import get_settings
+
+        settings = get_settings()
+
+        if settings.observability.logs_collection_enabled and hasattr(
+            request.app.state, "log_storage"
+        ):
+            request.state.log_storage = request.app.state.log_storage
+
+        # Extract client info
+        client_ip = "unknown"
+        if request.client:
+            client_ip = request.client.host
+
+        # Extract request info
+        method = request.method
+        path = str(request.url.path)
+        query = str(request.url.query) if request.url.query else None
+        user_agent = request.headers.get("user-agent", "unknown")
+
+        # Get request ID from context if available
+        request_id: str | None = None
+        try:
+            if hasattr(request.state, "request_id"):
+                request_id = request.state.request_id
+            elif hasattr(request.state, "context"):
+                # Try to check if it's a RequestContext without importing
+                context = request.state.context
+                if hasattr(context, "request_id") and hasattr(context, "metadata"):
+                    request_id = context.request_id
+        except Exception:
+            # Ignore any errors getting request_id
+            pass
+
+        # Process the request
+        response: Response | None = None
+        error_message: str | None = None
+
+        try:
+            response = await call_next(request)
+        except Exception as e:
+            # Capture error for logging
+            error_message = str(e)
+            # Re-raise to let error handlers process it
+            raise
+        finally:
+            try:
+                # Calculate duration
+                duration_seconds = time.perf_counter() - start_time
+                duration_ms = duration_seconds * 1000
+
+                # Extract response info
+                if response:
+                    status_code = response.status_code
+
+                    # Extract rate limit headers if present
+                    rate_limit_info = {}
+                    anthropic_request_id = None
+                    for header_name, header_value in response.headers.items():
+                        header_lower = header_name.lower()
+                        # Capture x-ratelimit-* headers
+                        if header_lower.startswith(
+                            "x-ratelimit-"
+                        ) or header_lower.startswith("anthropic-ratelimit-"):
+                            rate_limit_info[header_lower] = header_value
+                        # Capture request-id from Anthropic's response
+                        elif header_lower == "request-id":
+                            anthropic_request_id = header_value
+
+                    # Add anthropic request ID if present
+                    if anthropic_request_id:
+                        rate_limit_info["anthropic_request_id"] = anthropic_request_id
+
+                    # Extract metadata from context if available
+                    context_metadata = {}
+                    try:
+                        if hasattr(request.state, "context"):
+                            context = request.state.context
+                            # Check if it has the expected attributes of RequestContext
+                            if hasattr(context, "metadata") and isinstance(
+                                context.metadata, dict
+                            ):
+                                # Get all metadata from the context
+                                context_metadata = context.metadata.copy()
+                                # Remove fields we're already logging separately
+                                for key in [
+                                    "method",
+                                    "path",
+                                    "client_ip",
+                                    "status_code",
+                                    "request_id",
+                                    "duration_ms",
+                                    "duration_seconds",
+                                    "query",
+                                    "user_agent",
+                                    "error_message",
+                                ]:
+                                    context_metadata.pop(key, None)
+                    except Exception:
+                        # Ignore any errors extracting context metadata
+                        pass
+
+                    # Use start-only logging - let context handle comprehensive access logging
+                    # Only log basic request start info since context will handle complete access log
+                    from ccproxy.observability.access_logger import log_request_start
+
+                    log_request_start(
+                        request_id=request_id or "unknown",
+                        method=method,
+                        path=path,
+                        client_ip=client_ip,
+                        user_agent=user_agent,
+                        query=query,
+                        **rate_limit_info,
+                    )
+                else:
+                    # Log error case
+                    logger.error(
+                        "access_log_error",
+                        request_id=request_id,
+                        method=method,
+                        path=path,
+                        query=query,
+                        client_ip=client_ip,
+                        user_agent=user_agent,
+                        duration_ms=duration_ms,
+                        duration_seconds=duration_seconds,
+                        error_message=error_message or "No response generated",
+                        exc_info=True,
+                    )
+            except Exception as log_error:
+                # If logging fails, don't crash the app
+                # Use print as a last resort to indicate the issue
+                print(f"Failed to write access log: {log_error}")
+
+        return response

ccproxy/api/middleware/request_id.py

@@ -0,0 +1,69 @@
+"""Request ID middleware for generating and tracking request IDs."""
+
+import uuid
+from typing import Any
+
+import structlog
+from fastapi import Request, Response
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.types import ASGIApp
+
+from ccproxy.observability.context import request_context
+
+
+logger = structlog.get_logger(__name__)
+
+
+class RequestIDMiddleware(BaseHTTPMiddleware):
+    """Middleware for generating request IDs and initializing request context."""
+
+    def __init__(self, app: ASGIApp):
+        """Initialize the request ID middleware.
+
+        Args:
+            app: The ASGI application
+        """
+        super().__init__(app)
+
+    async def dispatch(self, request: Request, call_next: Any) -> Response:
+        """Process the request and add request ID/context.
+
+        Args:
+            request: The incoming HTTP request
+            call_next: The next middleware/handler in the chain
+
+        Returns:
+            The HTTP response
+        """
+        # Generate or extract request ID
+        request_id = request.headers.get("x-request-id") or str(uuid.uuid4())
+
+        # Get DuckDB storage from app state if available
+        storage = getattr(request.app.state, "duckdb_storage", None)
+
+        # Use the proper request context manager to ensure __aexit__ is called
+        async with request_context(
+            request_id=request_id,
+            storage=storage,
+            method=request.method,
+            path=str(request.url.path),
+            client_ip=request.client.host if request.client else "unknown",
+            user_agent=request.headers.get("user-agent", "unknown"),
+            query=str(request.url.query) if request.url.query else None,
+            service_type="access_log",
+        ) as ctx:
+            # Store context in request state for access by services
+            request.state.request_id = request_id
+            request.state.context = ctx
+
+            # Add DuckDB storage to context if available
+            if hasattr(request.state, "duckdb_storage"):
+                ctx.storage = request.state.duckdb_storage
+
+            # Process the request
+            response = await call_next(request)
+
+            # Add request ID to response headers
+            response.headers["x-request-id"] = request_id
+
+            return response  # type: ignore[no-any-return]

ccproxy/api/middleware/server_header.py

@@ -0,0 +1,62 @@
+"""Server header middleware to set a default server header for non-proxy routes."""
+
+from typing import Any
+
+from fastapi import Request, Response
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.types import ASGIApp, Message, Receive, Scope, Send
+
+
+class ServerHeaderMiddleware:
+    """Middleware to set a default server header for responses.
+
+    This middleware adds a server header to responses that don't already have one.
+    Proxy responses using ProxyResponse will preserve their upstream server header,
+    while other routes will get the default header.
+    """
+
+    def __init__(self, app: ASGIApp, server_name: str = "Claude Code Proxy"):
+        """Initialize the server header middleware.
+
+        Args:
+            app: The ASGI application
+            server_name: The default server name to use
+        """
+        self.app = app
+        self.server_name = server_name
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        """ASGI application entrypoint."""
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        async def send_wrapper(message: Message) -> None:
+            if message["type"] == "http.response.start":
+                headers = list(message.get("headers", []))
+
+                # Check if server header already exists
+                has_server = any(header[0].lower() == b"server" for header in headers)
+
+                # Only add server header for non-proxy routes
+                # Proxy routes will have their server header preserved from upstream
+                if not has_server:
+                    # Check if this looks like a proxy response by looking for specific headers
+                    is_proxy_response = any(
+                        header[0].lower()
+                        in [
+                            b"cf-ray",
+                            b"cf-cache-status",
+                            b"anthropic-ratelimit-unified-status",
+                        ]
+                        for header in headers
+                    )
+
+                    # Only add our server header if this is NOT a proxy response
+                    if not is_proxy_response:
+                        headers.append((b"server", self.server_name.encode()))
+                        message["headers"] = headers
+
+            await send(message)
+
+        await self.app(scope, receive, send_wrapper)

ccproxy/api/responses.py

@@ -0,0 +1,84 @@
+"""Custom response classes for preserving proxy headers."""
+
+from typing import Any
+
+from fastapi import Response
+from starlette.types import Receive, Scope, Send
+
+
+class ProxyResponse(Response):
+    """Custom response class that preserves all headers from upstream API.
+
+    This response class ensures that headers like 'server' from the upstream
+    API are preserved and not overridden by Uvicorn/Starlette.
+    """
+
+    def __init__(
+        self,
+        content: Any = None,
+        status_code: int = 200,
+        headers: dict[str, str] | None = None,
+        media_type: str | None = None,
+        background: Any = None,
+    ):
+        """Initialize the proxy response with preserved headers.
+
+        Args:
+            content: Response content
+            status_code: HTTP status code
+            headers: Headers to preserve from upstream
+            media_type: Content type
+            background: Background task
+        """
+        super().__init__(
+            content=content,
+            status_code=status_code,
+            headers=headers,
+            media_type=media_type,
+            background=background,
+        )
+        # Store original headers for preservation
+        self._preserve_headers = headers or {}
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        """Override the ASGI call to ensure headers are preserved.
+
+        This method intercepts the response sending process to ensure
+        that our headers are not overridden by the server.
+        """
+        # Ensure we include all original headers, including 'server'
+        headers_list = []
+
+        # Add all headers from the response, but skip content-length
+        # as we'll recalculate it based on actual body
+        for name, value in self._preserve_headers.items():
+            lower_name = name.lower()
+            # Skip content-length and transfer-encoding as we'll set them correctly
+            if lower_name not in ["content-length", "transfer-encoding"]:
+                headers_list.append((lower_name.encode(), value.encode()))
+
+        # Always set correct content-length based on actual body
+        if self.body:
+            headers_list.append((b"content-length", str(len(self.body)).encode()))
+        else:
+            headers_list.append((b"content-length", b"0"))
+
+        # Ensure we have content-type
+        has_content_type = any(h[0] == b"content-type" for h in headers_list)
+        if not has_content_type and self.media_type:
+            headers_list.append((b"content-type", self.media_type.encode()))
+
+        await send(
+            {
+                "type": "http.response.start",
+                "status": self.status_code,
+                "headers": headers_list,
+            }
+        )
+
+        await send(
+            {
+                "type": "http.response.body",
+                "body": self.body,
+            }
+        )

ccproxy/api/routes/__init__.py

@@ -0,0 +1,16 @@
+"""API routes for CCProxy API Server."""
+
+# from ccproxy.api.routes.auth import router as auth_router  # Module doesn't exist
+from ccproxy.api.routes.claude import router as claude_router
+from ccproxy.api.routes.health import router as health_router
+from ccproxy.api.routes.metrics import router as metrics_router
+from ccproxy.api.routes.proxy import router as proxy_router
+
+
+__all__ = [
+    # "auth_router",  # Module doesn't exist
+    "claude_router",
+    "health_router",
+    "metrics_router",
+    "proxy_router",
+]

ccproxy/api/routes/claude.py

@@ -0,0 +1,181 @@
+"""Claude SDK endpoints for CCProxy API Server."""
+
+import json
+from collections.abc import AsyncIterator
+from typing import Any
+
+import structlog
+from fastapi import APIRouter, Depends, HTTPException, Request
+from fastapi.responses import StreamingResponse
+
+from ccproxy.adapters.openai.adapter import (
+    OpenAIAdapter,
+    OpenAIChatCompletionRequest,
+    OpenAIChatCompletionResponse,
+)
+from ccproxy.api.dependencies import get_claude_service
+from ccproxy.models.messages import MessageCreateParams, MessageResponse
+from ccproxy.services.claude_sdk_service import ClaudeSDKService
+
+
+# Create the router for Claude SDK endpoints
+router = APIRouter(tags=["claude-sdk"])
+
+logger = structlog.get_logger(__name__)
+
+
+@router.post("/v1/chat/completions", response_model=None)
+async def create_openai_chat_completion(
+    request: Request,
+    openai_request: OpenAIChatCompletionRequest,
+    claude_service: ClaudeSDKService = Depends(get_claude_service),
+) -> StreamingResponse | OpenAIChatCompletionResponse:
+    """Create a chat completion using Claude SDK with OpenAI-compatible format.
+
+    This endpoint handles OpenAI API format requests and converts them
+    to Anthropic format before using the Claude SDK directly.
+    """
+    try:
+        # Create adapter instance
+        adapter = OpenAIAdapter()
+
+        # Convert entire OpenAI request to Anthropic format using adapter
+        anthropic_request = adapter.adapt_request(openai_request.model_dump())
+
+        # Extract stream parameter
+        stream = openai_request.stream or False
+
+        # Call Claude SDK service with adapted request
+        if request and hasattr(request, "state") and hasattr(request.state, "context"):
+            # Use existing context from middleware
+            ctx = request.state.context
+            # Add service-specific metadata
+            ctx.add_metadata(streaming=stream)
+
+        response = await claude_service.create_completion(
+            messages=anthropic_request["messages"],
+            model=anthropic_request["model"],
+            temperature=anthropic_request.get("temperature"),
+            max_tokens=anthropic_request.get("max_tokens"),
+            stream=stream,
+            user_id=getattr(openai_request, "user", None),
+        )
+
+        if stream:
+            # Handle streaming response
+            async def openai_stream_generator() -> AsyncIterator[bytes]:
+                # Use adapt_stream for streaming responses
+                async for openai_chunk in adapter.adapt_stream(response):  # type: ignore[arg-type]
+                    yield f"data: {json.dumps(openai_chunk)}\n\n".encode()
+                # Send final chunk
+                yield b"data: [DONE]\n\n"
+
+            return StreamingResponse(
+                openai_stream_generator(),
+                media_type="text/event-stream",
+                headers={
+                    "Cache-Control": "no-cache",
+                    "Connection": "keep-alive",
+                },
+            )
+        else:
+            # Convert non-streaming response to OpenAI format using adapter
+            openai_response = adapter.adapt_response(response)  # type: ignore[arg-type]
+            return OpenAIChatCompletionResponse.model_validate(openai_response)
+
+    except Exception as e:
+        # Re-raise specific proxy errors to be handled by the error handler
+        from ccproxy.core.errors import ClaudeProxyError
+
+        if isinstance(e, ClaudeProxyError):
+            raise
+        raise HTTPException(
+            status_code=500, detail=f"Internal server error: {str(e)}"
+        ) from e
+
+
+@router.post("/v1/messages", response_model=None)
+async def create_anthropic_message(
+    request: MessageCreateParams,
+    claude_service: ClaudeSDKService = Depends(get_claude_service),
+) -> StreamingResponse | MessageResponse:
+    """Create a message using Claude SDK with Anthropic format.
+
+    This endpoint handles Anthropic API format requests directly
+    using the Claude SDK without any format conversion.
+    """
+    try:
+        # Extract parameters from Anthropic request
+        messages = [msg.model_dump() for msg in request.messages]
+        model = request.model
+        temperature = request.temperature
+        max_tokens = request.max_tokens
+        stream = request.stream or False
+
+        # Call Claude SDK service directly with Anthropic format
+        response = await claude_service.create_completion(
+            messages=messages,
+            model=model,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            stream=stream,
+            user_id=getattr(request, "user_id", None),
+        )
+
+        if stream:
+            # Handle streaming response
+            async def anthropic_stream_generator() -> AsyncIterator[bytes]:
+                async for chunk in response:  # type: ignore[union-attr]
+                    if chunk:
+                        yield f"data: {json.dumps(chunk)}\n\n".encode()
+                # Send final chunk
+                yield b"data: [DONE]\n\n"
+
+            return StreamingResponse(
+                anthropic_stream_generator(),
+                media_type="text/event-stream",
+                headers={
+                    "Cache-Control": "no-cache",
+                    "Connection": "keep-alive",
+                },
+            )
+        else:
+            # Return Anthropic format response directly
+            return MessageResponse.model_validate(response)
+
+    except Exception as e:
+        # Re-raise specific proxy errors to be handled by the error handler
+        from ccproxy.core.errors import ClaudeProxyError
+
+        if isinstance(e, ClaudeProxyError):
+            raise
+        raise HTTPException(
+            status_code=500, detail=f"Internal server error: {str(e)}"
+        ) from e
+
+
+@router.get("/v1/models", response_model=None)
+async def list_models(
+    claude_service: ClaudeSDKService = Depends(get_claude_service),
+) -> dict[str, Any]:
+    """List available models using Claude SDK service.
+
+    Returns a combined list of Anthropic models and recent OpenAI models.
+    """
+    try:
+        return await claude_service.list_models()
+    except Exception as e:
+        # Re-raise specific proxy errors to be handled by the error handler
+        from ccproxy.core.errors import ClaudeProxyError
+
+        if isinstance(e, ClaudeProxyError):
+            raise
+        raise HTTPException(
+            status_code=500, detail=f"Internal server error: {str(e)}"
+        ) from e
+
+
+@router.get("/status")
+async def claude_sdk_status() -> dict[str, str]:
+    """Get Claude SDK status."""
+    return {"status": "claude sdk endpoint available", "service": "direct"}