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

ccproxy/services/handler_config.py

@@ -0,0 +1,76 @@
+"""Handler configuration for request handling."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
+
+from ccproxy.services.adapters.format_context import FormatContext
+
+
+if TYPE_CHECKING:
+    from ccproxy.services.adapters.format_adapter import FormatAdapterProtocol
+
+
+@runtime_checkable
+class PluginTransformerProtocol(Protocol):
+    """Protocol for plugin-based transformers with header and body methods."""
+
+    def transform_headers(
+        self, headers: dict[str, str], *args: Any, **kwargs: Any
+    ) -> dict[str, str]:
+        """Transform request headers."""
+        ...
+
+
+@runtime_checkable
+class SSEParserProtocol(Protocol):
+    """Protocol for SSE parsers to extract a final JSON response.
+
+    Implementations should return a parsed dict for the final response, or
+    None if no final response could be determined.
+    """
+
+    def __call__(
+        self, raw: str
+    ) -> dict[str, Any] | None:  # pragma: no cover - protocol
+        ...
+
+    def transform_body(self, body: Any) -> Any:
+        """Transform request body."""
+        ...
+
+
+@dataclass(frozen=True)
+class HandlerConfig:
+    """Processing pipeline configuration for HTTP/streaming handlers.
+
+    This config only contains universal processing concerns,
+    not plugin-specific parameters like session_id or access_token.
+
+    Following the Parameter Object pattern, this groups related processing
+    components while maintaining clean separation of concerns. Plugin-specific
+    parameters should be passed directly as method parameters.
+    """
+
+    # Format conversion (e.g., OpenAI ↔ Anthropic)
+    request_adapter: FormatAdapterProtocol | None = None
+    response_adapter: FormatAdapterProtocol | None = None
+
+    # Header/body transformation
+    request_transformer: PluginTransformerProtocol | None = None
+    response_transformer: PluginTransformerProtocol | None = None
+
+    # Feature flag
+    supports_streaming: bool = True
+
+    # Header case preservation toggle for upstream requests
+    # When True, the HTTP handler will not canonicalize header names and will
+    # forward them with their original casing/order as produced by transformers.
+    preserve_header_case: bool = False
+
+    # Optional SSE parser provided by plugins that return SSE streams
+    sse_parser: SSEParserProtocol | None = None
+
+    # Format context for adapter selection
+    format_context: FormatContext | None = None

ccproxy/services/interfaces.py

@@ -0,0 +1,298 @@
+"""Service interfaces for explicit dependency injection.
+
+This module defines protocol interfaces for core services that adapters need,
+enabling explicit dependency injection and removing the service locator pattern.
+"""
+
+from collections.abc import AsyncIterator
+from typing import TYPE_CHECKING, Any, Protocol
+
+import httpx
+from starlette.responses import Response
+
+
+if TYPE_CHECKING:
+    from ccproxy.core.request_context import RequestContext
+
+
+class IRequestHandler(Protocol):
+    """Protocol for request handling functionality.
+
+    Note: The dispatch_request method has been removed in favor of
+    using plugin adapters' handle_request() method directly.
+    """
+
+    pass
+
+
+class IRequestTracer(Protocol):
+    """Request tracing interface."""
+
+    async def trace_request(
+        self,
+        request_id: str,
+        method: str,
+        url: str,
+        headers: dict[str, str],
+        body: bytes | None = None,
+    ) -> None:
+        """Trace an outgoing request.
+
+        Args:
+            request_id: Unique request identifier
+            method: HTTP method
+            url: Target URL
+            headers: Request headers
+            body: Request body if available
+        """
+        ...
+
+    async def trace_response(
+        self,
+        request_id: str,
+        status: int,
+        headers: dict[str, str],
+        body: bytes | None = None,
+    ) -> None:
+        """Trace an incoming response.
+
+        Args:
+            request_id: Unique request identifier
+            status: HTTP status code
+            headers: Response headers
+            body: Response body if available
+        """
+        ...
+
+    def should_trace(self) -> bool:
+        """Check if tracing is enabled.
+
+        Returns:
+            True if tracing should be performed
+        """
+        ...
+
+
+class IMetricsCollector(Protocol):
+    """Metrics collection interface."""
+
+    def track_request(
+        self, method: str, path: str, provider: str | None = None
+    ) -> None:
+        """Track an incoming request.
+
+        Args:
+            method: HTTP method
+            path: Request path
+            provider: Optional provider identifier
+        """
+        ...
+
+    def track_response(
+        self, status: int, duration: float, provider: str | None = None
+    ) -> None:
+        """Track a response.
+
+        Args:
+            status: HTTP status code
+            duration: Response time in seconds
+            provider: Optional provider identifier
+        """
+        ...
+
+    def track_error(self, error_type: str, provider: str | None = None) -> None:
+        """Track an error occurrence.
+
+        Args:
+            error_type: Type of error
+            provider: Optional provider identifier
+        """
+        ...
+
+    def track_tokens(
+        self,
+        input_tokens: int,
+        output_tokens: int,
+        provider: str | None = None,
+        model: str | None = None,
+    ) -> None:
+        """Track token usage.
+
+        Args:
+            input_tokens: Number of input tokens
+            output_tokens: Number of output tokens
+            provider: Optional provider identifier
+            model: Optional model identifier
+        """
+        ...
+
+
+class StreamingMetrics(Protocol):
+    """Streaming response handler interface."""
+
+    async def handle_stream(
+        self,
+        response: httpx.Response,
+        request_context: "RequestContext | None" = None,
+    ) -> AsyncIterator[bytes]:
+        """Handle a streaming response.
+
+        Args:
+            response: HTTP response object
+            request_context: Optional request context
+
+        Yields:
+            Response chunks
+        """
+        ...
+
+    def create_streaming_response(
+        self,
+        stream: AsyncIterator[bytes],
+        headers: dict[str, str] | None = None,
+    ) -> Response:
+        """Create a streaming response.
+
+        Args:
+            stream: Async iterator of response chunks
+            headers: Optional response headers
+
+        Returns:
+            Streaming response object
+        """
+        ...
+
+    async def handle_streaming_request(
+        self,
+        method: str,
+        url: str,
+        headers: dict[str, str],
+        body: bytes,
+        handler_config: Any,
+        request_context: Any,
+        client_config: dict[str, Any] | None = None,
+        client: httpx.AsyncClient | None = None,
+    ) -> Any:
+        """Handle a streaming request.
+
+        Args:
+            method: HTTP method
+            url: Target URL
+            headers: Request headers
+            body: Request body
+            handler_config: Handler configuration
+            request_context: Request context
+            client_config: Optional client configuration
+            client: Optional HTTP client
+
+        Returns:
+            Deferred streaming response
+        """
+        ...
+
+
+# Null implementations for optional dependencies
+
+
+class NullRequestTracer:
+    """Null implementation of request tracer (no-op)."""
+
+    async def trace_request(
+        self,
+        request_id: str,
+        method: str,
+        url: str,
+        headers: dict[str, str],
+        body: bytes | None = None,
+    ) -> None:
+        """No-op request tracing."""
+        pass
+
+    async def trace_response(
+        self,
+        request_id: str,
+        status: int,
+        headers: dict[str, str],
+        body: bytes | None = None,
+    ) -> None:
+        """No-op response tracing."""
+        pass
+
+    def should_trace(self) -> bool:
+        """Always return False for null tracer."""
+        return False
+
+
+class NullMetricsCollector:
+    """Null implementation of metrics collector (no-op)."""
+
+    def track_request(
+        self, method: str, path: str, provider: str | None = None
+    ) -> None:
+        """No-op request tracking."""
+        pass
+
+    def track_response(
+        self, status: int, duration: float, provider: str | None = None
+    ) -> None:
+        """No-op response tracking."""
+        pass
+
+    def track_error(self, error_type: str, provider: str | None = None) -> None:
+        """No-op error tracking."""
+        pass
+
+    def track_tokens(
+        self,
+        input_tokens: int,
+        output_tokens: int,
+        provider: str | None = None,
+        model: str | None = None,
+    ) -> None:
+        """No-op token tracking."""
+        pass
+
+
+class NullStreamingHandler:
+    """Null implementation of streaming handler."""
+
+    async def handle_stream(
+        self,
+        response: httpx.Response,
+        request_context: "RequestContext | None" = None,
+    ) -> AsyncIterator[bytes]:
+        """Return empty stream."""
+        # Make this a proper async generator
+        for _ in []:
+            yield b""
+
+    def create_streaming_response(
+        self,
+        stream: AsyncIterator[bytes],
+        headers: dict[str, str] | None = None,
+    ) -> Response:
+        """Create empty response."""
+        from starlette.responses import Response
+
+        return Response(content=b"", headers=headers or {})
+
+    async def handle_streaming_request(
+        self,
+        method: str,
+        url: str,
+        headers: dict[str, str],
+        body: bytes,
+        handler_config: Any,
+        request_context: Any,
+        client_config: dict[str, Any] | None = None,
+        client: httpx.AsyncClient | None = None,
+    ) -> Any:
+        """Null implementation - returns a simple error response."""
+        # For null implementation, return a regular response instead of trying to stream
+        from starlette.responses import JSONResponse
+
+        return JSONResponse(
+            content={"error": "Streaming handler not available"},
+            status_code=503,  # Service Unavailable
+            headers={"X-Error": "NullStreamingHandler"},
+        )

ccproxy/services/mocking/__init__.py

@@ -0,0 +1,6 @@
+"""Mock response handling services for bypass mode."""
+
+from ccproxy.services.mocking.mock_handler import MockResponseHandler
+
+
+__all__ = ["MockResponseHandler"]

ccproxy/services/mocking/mock_handler.py

@@ -0,0 +1,291 @@
+"""Mock response handler for bypass mode."""
+
+import asyncio
+import json
+import random
+from collections.abc import AsyncGenerator
+from typing import Any
+
+import structlog
+from fastapi.responses import StreamingResponse
+
+from ccproxy.core.request_context import RequestContext
+from ccproxy.services.adapters.format_adapter import DictFormatAdapter
+from ccproxy.services.adapters.simple_converters import (
+    convert_anthropic_to_openai_response,
+)
+from ccproxy.testing import RealisticMockResponseGenerator
+
+
+logger = structlog.get_logger(__name__)
+
+
+class MockResponseHandler:
+    """Handles bypass mode with realistic mock responses."""
+
+    def __init__(
+        self,
+        mock_generator: RealisticMockResponseGenerator,
+        openai_adapter: DictFormatAdapter | None = None,
+        error_rate: float = 0.05,
+        latency_range: tuple[float, float] = (0.5, 2.0),
+    ) -> None:
+        """Initialize with mock generator and format adapter.
+
+        - Uses existing testing utilities
+        - Supports both Anthropic and OpenAI formats
+        """
+        self.mock_generator = mock_generator
+        if openai_adapter is None:
+            openai_adapter = DictFormatAdapter(
+                response=convert_anthropic_to_openai_response,
+                name="mock_anthropic_to_openai",
+            )
+        self.openai_adapter = openai_adapter
+        self.error_rate = error_rate
+        self.latency_range = latency_range
+
+    def extract_message_type(self, body: bytes | None) -> str:
+        """Analyze request body to determine response type.
+
+        - Checks for 'tools' field → returns 'tool_use'
+        - Analyzes message length → returns 'long'|'medium'|'short'
+        - Handles JSON decode errors gracefully
+        """
+        if not body:
+            return "short"
+
+        try:
+            data = json.loads(body)
+
+            # Check for tool use
+            if "tools" in data:
+                return "tool_use"
+
+            # Analyze message content length
+            messages = data.get("messages", [])
+            if messages:
+                total_content_length = sum(
+                    len(msg.get("content", ""))
+                    for msg in messages
+                    if isinstance(msg.get("content"), str)
+                )
+
+                if total_content_length > 1000:
+                    return "long"
+                elif total_content_length > 200:
+                    return "medium"
+
+            return "short"
+
+        except (json.JSONDecodeError, TypeError):
+            return "short"
+
+    def should_simulate_error(self) -> bool:
+        """Randomly decide if error should be simulated.
+
+        - Uses configuration-based error rate
+        - Provides realistic error distribution
+        """
+        return random.random() < self.error_rate
+
+    async def generate_standard_response(
+        self,
+        model: str | None,
+        is_openai_format: bool,
+        ctx: RequestContext,
+        message_type: str = "short",
+    ) -> tuple[int, dict[str, str], bytes]:
+        """Generate non-streaming mock response.
+
+        - Simulates realistic latency (configurable)
+        - Generates appropriate token counts
+        - Updates request context with metrics
+        - Returns (status_code, headers, body)
+        """
+        # Simulate latency
+        latency = random.uniform(*self.latency_range)
+        await asyncio.sleep(latency)
+
+        # Check if we should simulate an error
+        if self.should_simulate_error():
+            error_response = self._generate_error_response(is_openai_format)
+            return 429, {"content-type": "application/json"}, error_response
+
+        # Generate mock response based on type
+        if message_type == "tool_use":
+            mock_response = self.mock_generator.generate_tool_use_response(model=model)
+        elif message_type == "long":
+            mock_response = self.mock_generator.generate_long_response(model=model)
+        elif message_type == "medium":
+            mock_response = self.mock_generator.generate_medium_response(model=model)
+        else:
+            mock_response = self.mock_generator.generate_short_response(model=model)
+
+        # Convert to OpenAI format if needed
+        if is_openai_format and message_type != "tool_use":
+            # Use dict-based conversion
+            mock_response = await self.openai_adapter.convert_response(mock_response)
+
+        # Update context with metrics
+        if ctx:
+            ctx.metrics["mock_response_type"] = message_type
+            ctx.metrics["mock_latency_ms"] = int(latency * 1000)
+
+        headers = {
+            "content-type": "application/json",
+            "x-request-id": ctx.request_id if ctx else "mock-request",
+        }
+
+        return 200, headers, json.dumps(mock_response).encode()
+
+    async def generate_streaming_response(
+        self,
+        model: str | None,
+        is_openai_format: bool,
+        ctx: RequestContext,
+        message_type: str = "short",
+    ) -> StreamingResponse:
+        """Generate SSE streaming mock response.
+
+        - Simulates realistic token generation rate
+        - Properly formatted SSE events
+        - Includes [DONE] marker
+        """
+
+        async def stream_generator() -> AsyncGenerator[bytes, None]:
+            # Generate base response
+            if message_type == "tool_use":
+                base_response = self.mock_generator.generate_tool_use_response(
+                    model=model
+                )
+            elif message_type == "long":
+                base_response = self.mock_generator.generate_long_response(model=model)
+            else:
+                base_response = self.mock_generator.generate_short_response(model=model)
+
+            content = base_response.get("content", [{"text": "Mock response"}])
+            if isinstance(content, list) and content:
+                text_content = content[0].get("text", "Mock response")
+            else:
+                text_content = "Mock response"
+
+            # Split content into chunks
+            words = text_content.split()
+            chunk_size = 3  # Words per chunk
+
+            # Send initial event
+            if is_openai_format:
+                initial_event = {
+                    "id": f"chatcmpl-{ctx.request_id if ctx else 'mock'}",
+                    "object": "chat.completion.chunk",
+                    "created": 1234567890,
+                    "model": model or "gpt-4",
+                    "choices": [
+                        {
+                            "index": 0,
+                            "delta": {"role": "assistant"},
+                            "finish_reason": None,
+                        }
+                    ],
+                }
+                yield f"data: {json.dumps(initial_event)}\n\n".encode()
+            else:
+                initial_event = {
+                    "type": "message_start",
+                    "message": {
+                        "id": f"msg_{ctx.request_id if ctx else 'mock'}",
+                        "type": "message",
+                        "role": "assistant",
+                        "model": model or "claude-3-opus-20240229",
+                        "content": [],
+                        "usage": {"input_tokens": 10, "output_tokens": 0},
+                    },
+                }
+                yield f"data: {json.dumps(initial_event)}\n\n".encode()
+
+            # Stream content chunks
+            for i in range(0, len(words), chunk_size):
+                chunk_words = words[i : i + chunk_size]
+                chunk_text = " ".join(chunk_words)
+                if i + chunk_size < len(words):
+                    chunk_text += " "
+
+                await asyncio.sleep(0.05)  # Simulate token generation delay
+
+                if is_openai_format:
+                    chunk_event = {
+                        "id": f"chatcmpl-{ctx.request_id if ctx else 'mock'}",
+                        "object": "chat.completion.chunk",
+                        "created": 1234567890,
+                        "model": model or "gpt-4",
+                        "choices": [
+                            {
+                                "index": 0,
+                                "delta": {"content": chunk_text},
+                                "finish_reason": None,
+                            }
+                        ],
+                    }
+                else:
+                    chunk_event = {
+                        "type": "content_block_delta",
+                        "index": 0,
+                        "delta": {"type": "text_delta", "text": chunk_text},
+                    }
+
+                yield f"data: {json.dumps(chunk_event)}\n\n".encode()
+
+            # Send final event
+            if is_openai_format:
+                final_event = {
+                    "id": f"chatcmpl-{ctx.request_id if ctx else 'mock'}",
+                    "object": "chat.completion.chunk",
+                    "created": 1234567890,
+                    "model": model or "gpt-4",
+                    "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}],
+                }
+                yield f"data: {json.dumps(final_event)}\n\n".encode()
+            else:
+                final_event = {
+                    "type": "message_stop",
+                    "message": {
+                        "usage": {
+                            "input_tokens": 10,
+                            "output_tokens": len(text_content.split()),
+                        }
+                    },
+                }
+                yield f"data: {json.dumps(final_event)}\n\n".encode()
+
+            # Send [DONE] marker
+            yield b"data: [DONE]\n\n"
+
+        return StreamingResponse(
+            stream_generator(),
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "X-Request-ID": ctx.request_id if ctx else "mock-request",
+            },
+        )
+
+    def _generate_error_response(self, is_openai_format: bool) -> bytes:
+        """Generate a mock error response."""
+        if is_openai_format:
+            error: dict[str, Any] = {
+                "error": {
+                    "message": "Rate limit exceeded (mock error)",
+                    "type": "rate_limit_error",
+                    "code": "rate_limit_exceeded",
+                }
+            }
+        else:
+            error = {
+                "type": "error",
+                "error": {
+                    "type": "rate_limit_error",
+                    "message": "Rate limit exceeded (mock error)",
+                },
+            }
+        return json.dumps(error).encode()

ccproxy/services/tracing/__init__.py

@@ -0,0 +1,7 @@
+"""Request tracing services for monitoring and debugging."""
+
+from ccproxy.services.tracing.interfaces import RequestTracer, StreamingTracer
+from ccproxy.services.tracing.null_tracer import NullRequestTracer
+
+
+__all__ = ["RequestTracer", "StreamingTracer", "NullRequestTracer"]