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

ccproxy/api/bootstrap.py

@@ -0,0 +1,30 @@
+"""
+Application bootstrapping and dependency injection container setup.
+
+This module is responsible for the initial setup of the application's core services,
+including configuration loading and service container initialization. It acts as the
+main entry point for assembling the application's components before the web server
+starts.
+"""
+
+from ccproxy.config.settings import Settings
+from ccproxy.services.container import ServiceContainer
+
+
+def create_service_container(settings: Settings | None = None) -> ServiceContainer:
+    """
+    Create and configure the service container.
+
+    Args:
+        settings: Optional pre-loaded settings instance. If not provided,
+                  settings will be loaded from config files/environment.
+
+    Returns:
+        The initialized service container.
+    """
+    if settings is None:
+        settings = Settings.from_config()
+
+    container = ServiceContainer(settings)
+
+    return container

ccproxy/api/decorators.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import time
+import uuid
+from collections.abc import Awaitable, Callable
+from functools import wraps
+from typing import ParamSpec, TypeVar
+
+from fastapi import Request
+
+from ccproxy.core.logging import get_logger as _get_logger
+from ccproxy.core.request_context import RequestContext
+
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def format_chain(
+    *formats: str,
+) -> Callable[[Callable[P, Awaitable[R]]], Callable[P, Awaitable[R]]]:
+    """Existing simple decorator to attach a format chain to a route handler.
+
+    This attaches a __format_chain__ attribute used by validation and helpers.
+    """
+
+    def decorator(func: Callable[P, Awaitable[R]]) -> Callable[P, Awaitable[R]]:
+        func.__format_chain__ = list(formats)  # type: ignore[attr-defined]
+
+        @wraps(func)
+        async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            return await func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def with_format_chain(
+    formats: list[str], *, endpoint: str | None = None
+) -> Callable[[Callable[P, Awaitable[R]]], Callable[P, Awaitable[R]]]:
+    """Decorator to set format chain and optional endpoint metadata on a route.
+
+    - Attaches __format_chain__ to the endpoint for upstream processing/validation
+    - Ensures request.state.context exists and sets context.format_chain
+    - Optionally sets context.metadata["endpoint"] to the provided upstream endpoint path
+    """
+
+    def decorator(func: Callable[P, Awaitable[R]]) -> Callable[P, Awaitable[R]]:
+        func.__format_chain__ = list(formats)  # type: ignore[attr-defined]
+
+        @wraps(func)
+        async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            # Find Request in args/kwargs
+            request: Request | None = None
+            for arg in args:
+                if isinstance(arg, Request):
+                    request = arg
+                    break
+            if request is None:
+                req = kwargs.get("request")
+                if isinstance(req, Request):
+                    request = req
+
+            if request is not None:
+                # Ensure a context exists
+                if (
+                    not hasattr(request.state, "context")
+                    or request.state.context is None
+                ):
+                    request.state.context = RequestContext(
+                        request_id=str(uuid.uuid4()),
+                        start_time=time.perf_counter(),
+                        logger=_get_logger(__name__),
+                    )
+                # Set chain and endpoint metadata
+                request.state.context.format_chain = list(formats)
+                if endpoint:
+                    request.state.context.metadata["endpoint"] = endpoint
+
+            return await func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

ccproxy/api/dependencies.py

@@ -2,214 +2,190 @@
 
 from __future__ import annotations
 
-from typing import Annotated
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Annotated, Any, TypeVar
 
-from fastapi import Depends, Request
-from structlog import get_logger
+import httpx
+from fastapi import Depends, HTTPException, Request
 
-from ccproxy.config.settings import Settings, get_settings
-from ccproxy.core.http import BaseProxyClient
-from ccproxy.observability import PrometheusMetrics, get_metrics
-from ccproxy.observability.storage.duckdb_simple import SimpleDuckDBStorage
-from ccproxy.services.claude_sdk_service import ClaudeSDKService
-from ccproxy.services.credentials.manager import CredentialsManager
-from ccproxy.services.proxy_service import ProxyService
+from ccproxy.config.settings import Settings
+from ccproxy.core.logging import get_logger
+from ccproxy.core.plugins import PluginRegistry, ProviderPluginRuntime
+from ccproxy.core.plugins.hooks import HookManager
+from ccproxy.services.adapters.base import BaseAdapter
+from ccproxy.services.container import ServiceContainer
 
 
+if TYPE_CHECKING:
+    pass
+
 logger = get_logger(__name__)
 
+T = TypeVar("T")
 
-def get_cached_settings(request: Request) -> Settings:
-    """Get cached settings from app state.
 
-    This avoids recomputing settings on every request by using the
-    settings instance computed during application startup.
+def get_service(service_type: type[T]) -> Callable[[Request], T]:
+    """Return a dependency callable that fetches a service from the container."""
 
-    Args:
-        request: FastAPI request object
+    def _get_service(request: Request) -> T:
+        """Get a service from the container."""
+        container: ServiceContainer | None = getattr(
+            request.app.state, "service_container", None
+        )
+        if container is None:
+            logger.error(
+                "service_container_missing_on_app_state",
+                category="lifecycle",
+            )
+            raise HTTPException(
+                status_code=503, detail="Service container not initialized"
+            )
+        return container.get_service(service_type)
 
-    Returns:
-        Settings instance from app state
+    return _get_service
 
-    Raises:
-        RuntimeError: If settings are not available in app state
-    """
-    settings = getattr(request.app.state, "settings", None)
-    if settings is None:
-        # Fallback to get_settings() for safety, but this should not happen
-        # in normal operation after lifespan startup
-        logger.warning(
-            "Settings not found in app state, falling back to get_settings()"
-        )
-        settings = get_settings()
-    return settings
 
+def _resolve_service_container(request: Request) -> ServiceContainer | None:
+    """Resolve a service container from the request or global context."""
 
-def get_cached_claude_service(request: Request) -> ClaudeSDKService:
-    """Get cached ClaudeSDKService from app state.
+    container: ServiceContainer | None = getattr(
+        request.app.state, "service_container", None
+    )
+    if container is not None:
+        return container
+
+    try:
+        return ServiceContainer.get_current(strict=False)
+    except RuntimeError:
+        # Should not happen with strict=False but guard defensively
+        return None
 
-    This avoids recreating the ClaudeSDKService on every request by using the
-    service instance created during application startup.
 
-    Args:
-        request: FastAPI request object
+def get_cached_settings(request: Request) -> Settings:
+    """Get cached settings from app state.
+
+    Raises a 503 HTTPException if no service container is available,
+    preserving the existing behaviour for required dependencies.
+    """
+    return get_service(Settings)(request)
+
 
-    Returns:
-        ClaudeSDKService instance from app state
+def get_optional_settings(request: Request) -> Settings | None:
+    """Best-effort retrieval of settings for optional dependencies.
 
-    Raises:
-        RuntimeError: If ClaudeSDKService is not available in app state
+    Returns a Settings instance if a service container is available.
+    Falls back to a new Settings object (with defaults) when running in
+    lightweight test contexts where the container is not initialised.
     """
-    claude_service = getattr(request.app.state, "claude_service", None)
-    if claude_service is None:
-        # Fallback to get_claude_service() for safety, but this should not happen
-        # in normal operation after lifespan startup
+
+    container = _resolve_service_container(request)
+    if container is not None:
+        try:
+            return container.get_service(Settings)
+        except ValueError:
+            logger.debug(
+                "settings_not_registered_in_container",
+                category="config",
+            )
+
+    try:
+        return Settings()
+    except Exception as exc:  # pragma: no cover - defensive guard
         logger.warning(
-            "ClaudeSDKService not found in app state, falling back to get_claude_service()"
+            "optional_settings_initialization_failed",
+            error=str(exc),
+            category="config",
         )
-        # Get dependencies manually for fallback
-        settings = get_cached_settings(request)
+        return None
 
-        claude_service = get_claude_service(settings)
-    return claude_service
 
+async def get_http_client(request: Request) -> httpx.AsyncClient:
+    """Get container-managed HTTP client from the service container."""
+    return get_service(httpx.AsyncClient)(request)
 
-# Type aliases for dependency injection
-SettingsDep = Annotated[Settings, Depends(get_cached_settings)]
 
+def get_hook_manager(request: Request) -> HookManager:
+    """Get HookManager from the service container.
 
-def get_claude_service(
-    settings: SettingsDep,
-) -> ClaudeSDKService:
-    """Get Claude SDK service instance.
+    This dependency is required; if the hook system has not been initialized
+    the request will fail with 503 to reflect misconfigured startup order.
+    """
+    return get_service(HookManager)(request)
 
-    Args:
-        settings: Application settings dependency
 
-    Returns:
-        Claude SDK service instance
-    """
-    logger.debug("Creating Claude SDK service instance")
-    # Get global metrics instance
-    metrics = get_metrics()
-
-    # Check if pooling should be enabled from configuration
-    use_pool = settings.claude.sdk_session_pool.enabled
-    session_manager = None
-
-    if use_pool:
-        logger.info(
-            "claude_sdk_pool_enabled",
-            message="Using Claude SDK client pooling for improved performance",
-            pool_size=settings.claude.sdk_session_pool.max_sessions,
-            max_pool_size=settings.claude.sdk_session_pool.max_sessions,
-        )
-        # Note: Session manager should be created in the lifespan function, not here
-        # This dependency function should not create stateful resources
+def get_plugin_adapter(plugin_name: str) -> Any:
+    """Create a dependency function for a specific plugin's adapter."""
 
-    return ClaudeSDKService(
-        metrics=metrics,
-        settings=settings,
-        session_manager=session_manager,
-    )
+    def _get_adapter(request: Request) -> BaseAdapter:
+        """Get adapter for the specified plugin."""
+        if not hasattr(request.app.state, "plugin_registry"):
+            raise HTTPException(
+                status_code=503, detail="Plugin registry not initialized"
+            )
 
+        registry: PluginRegistry = request.app.state.plugin_registry
+        runtime = registry.get_runtime(plugin_name)
 
-def get_credentials_manager(
-    settings: SettingsDep,
-) -> CredentialsManager:
-    """Get credentials manager instance.
+        if not runtime:
+            raise HTTPException(
+                status_code=503, detail=f"Plugin {plugin_name} not initialized"
+            )
 
-    Args:
-        settings: Application settings dependency
+        if not isinstance(runtime, ProviderPluginRuntime):
+            raise HTTPException(
+                status_code=503, detail=f"Plugin {plugin_name} is not a provider plugin"
+            )
 
-    Returns:
-        Credentials manager instance
-    """
-    logger.debug("Creating credentials manager instance")
-    return CredentialsManager(config=settings.auth)
-
-
-def get_proxy_service(
-    request: Request,
-    settings: SettingsDep,
-    credentials_manager: Annotated[
-        CredentialsManager, Depends(get_credentials_manager)
-    ],
-) -> ProxyService:
-    """Get proxy service instance.
-
-    Args:
-        request: FastAPI request object (for app state access)
-        settings: Application settings dependency
-        credentials_manager: Credentials manager dependency
-
-    Returns:
-        Proxy service instance
-    """
-    logger.debug("get_proxy_service")
-    # Create HTTP client for proxy
-    from ccproxy.core.http import HTTPXClient
-
-    http_client = HTTPXClient()
-    proxy_client = BaseProxyClient(http_client)
-
-    # Get global metrics instance
-    metrics = get_metrics()
-
-    return ProxyService(
-        proxy_client=proxy_client,
-        credentials_manager=credentials_manager,
-        settings=settings,
-        proxy_mode="full",
-        target_base_url=settings.reverse_proxy.target_url,
-        metrics=metrics,
-        app_state=request.app.state,  # Pass app state for detection data access
-    )
+        if not runtime.adapter:
+            raise HTTPException(
+                status_code=503, detail=f"Plugin {plugin_name} adapter not available"
+            )
 
+        adapter: BaseAdapter = runtime.adapter
+        return adapter
 
-def get_observability_metrics() -> PrometheusMetrics:
-    """Get observability metrics instance.
+    return _get_adapter
 
-    Returns:
-        PrometheusMetrics instance
-    """
-    logger.debug("get_observability_metrics")
-    return get_metrics()
 
+def get_provider_config_dependency(
+    plugin_name: str, config_type: type[T]
+) -> Callable[[Request], T]:
+    """Return a dependency that fetches a provider plugin's validated config."""
 
-async def get_log_storage(request: Request) -> SimpleDuckDBStorage | None:
-    """Get log storage from app state.
+    def _get_config(request: Request) -> T:
+        if not hasattr(request.app.state, "plugin_registry"):
+            raise HTTPException(
+                status_code=503, detail="Plugin registry not initialized"
+            )
 
-    Args:
-        request: FastAPI request object
+        registry: PluginRegistry = request.app.state.plugin_registry
+        runtime = registry.get_runtime(plugin_name)
 
-    Returns:
-        SimpleDuckDBStorage instance if available, None otherwise
-    """
-    return getattr(request.app.state, "log_storage", None)
+        if not runtime or not isinstance(runtime, ProviderPluginRuntime):
+            raise HTTPException(
+                status_code=503, detail=f"Plugin {plugin_name} not initialized"
+            )
 
+        context = getattr(runtime, "context", None)
+        if not context:
+            raise HTTPException(
+                status_code=503,
+                detail=f"Plugin {plugin_name} configuration unavailable",
+            )
 
-async def get_duckdb_storage(request: Request) -> SimpleDuckDBStorage | None:
-    """Get DuckDB storage from app state (backward compatibility).
+        try:
+            config = context.get(config_type)
+            return config  # type: ignore[no-any-return]
+        except ValueError as exc:  # pragma: no cover - defensive guard
+            raise HTTPException(
+                status_code=503,
+                detail=f"Plugin {plugin_name} configuration not loaded",
+            ) from exc
 
-    Args:
-        request: FastAPI request object
+    return _get_config
 
-    Returns:
-        SimpleDuckDBStorage instance if available, None otherwise
-    """
-    # Try new name first, then fall back to old name for backward compatibility
-    storage = getattr(request.app.state, "log_storage", None)
-    if storage is None:
-        storage = getattr(request.app.state, "duckdb_storage", None)
-    return storage
-
-
-# Type aliases for service dependencies
-ClaudeServiceDep = Annotated[ClaudeSDKService, Depends(get_cached_claude_service)]
-ProxyServiceDep = Annotated[ProxyService, Depends(get_proxy_service)]
-ObservabilityMetricsDep = Annotated[
-    PrometheusMetrics, Depends(get_observability_metrics)
-]
-LogStorageDep = Annotated[SimpleDuckDBStorage | None, Depends(get_log_storage)]
-DuckDBStorageDep = Annotated[SimpleDuckDBStorage | None, Depends(get_duckdb_storage)]
+
+SettingsDep = Annotated[Settings, Depends(get_cached_settings)]
+OptionalSettingsDep = Annotated[Settings | None, Depends(get_optional_settings)]
+HTTPClientDep = Annotated[httpx.AsyncClient, Depends(get_http_client)]
+HookManagerDep = Annotated[HookManager, Depends(get_hook_manager)]

ccproxy/api/format_validation.py

@@ -0,0 +1,54 @@
+"""Utilities for validating format adapter chains during application startup."""
+
+from __future__ import annotations
+
+from fastapi import FastAPI
+
+from ccproxy.core.logging import TraceBoundLogger
+from ccproxy.services.adapters.chain_validation import (
+    validate_chains,
+    validate_stream_pairs,
+)
+from ccproxy.services.adapters.format_registry import FormatRegistry
+
+
+def collect_declared_format_chains(app: FastAPI) -> list[list[str]]:
+    """Collect declared format chains from FastAPI routes."""
+
+    chains: list[list[str]] = []
+    for route in app.router.routes:
+        endpoint = getattr(route, "endpoint", None)
+        chain = getattr(endpoint, "__format_chain__", None)
+        if chain:
+            chains.append(chain)
+    return chains
+
+
+def validate_route_format_chains(
+    *,
+    app: FastAPI,
+    registry: FormatRegistry,
+    logger: TraceBoundLogger,
+) -> None:
+    """Validate format chains declared on routes against the format registry."""
+
+    try:
+        declared_chains = collect_declared_format_chains(app)
+        if not declared_chains:
+            return
+
+        missing = validate_chains(registry=registry, chains=declared_chains)
+        missing_stream = validate_stream_pairs(
+            registry=registry, chains=declared_chains
+        )
+        if missing or missing_stream:
+            logger.error(
+                "format_chain_validation_failed",
+                missing_adapters=missing,
+                missing_stream_adapters=missing_stream,
+            )
+    except Exception as exc:  # pragma: no cover - defensive logging path
+        logger.warning("format_registry_setup_skipped", error=str(exc))
+
+
+__all__ = ["validate_route_format_chains", "collect_declared_format_chains"]

ccproxy/api/middleware/cors.py

@@ -4,9 +4,9 @@ from typing import Any
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
-from structlog import get_logger
 
 from ccproxy.config.settings import Settings
+from ccproxy.core.logging import get_logger
 
 
 logger = get_logger(__name__)
@@ -19,7 +19,6 @@ def setup_cors_middleware(app: FastAPI, settings: Settings) -> None:
         app: FastAPI application instance
         settings: Application settings containing CORS configuration
     """
-    logger.debug("cors_middleware_setup_start")
 
     app.add_middleware(
         CORSMiddleware,
@@ -32,7 +31,11 @@ def setup_cors_middleware(app: FastAPI, settings: Settings) -> None:
         max_age=settings.cors.max_age,
     )
 
-    logger.debug("cors_middleware_configured", origins=settings.cors.origins)
+    logger.debug(
+        "cors_middleware_configured",
+        origins=settings.cors.origins,
+        category="middleware",
+    )
 
 
 def get_cors_config(settings: Settings) -> dict[str, Any]: