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

ccproxy/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.4'
-__version_tuple__ = version_tuple = (0, 1, 4)
+__version__ = version = '0.1.5'
+__version_tuple__ = version_tuple = (0, 1, 5)

ccproxy/adapters/openai/adapter.py

@@ -432,7 +432,7 @@ class OpenAIAdapter(APIAdapter):
                     thinking_text = block.get("thinking", "")
                     signature = block.get("signature")
                     if thinking_text:
-                        content += f'<thinking signature="{signature}">{thinking_text}</thinking>'
+                        content += f'<thinking signature="{signature}">{thinking_text}</thinking>\n'
                 elif block.get("type") == "tool_use":
                     # Handle legacy tool_use content blocks
                     tool_calls.append(format_openai_tool_call(block))

ccproxy/adapters/openai/streaming.py

@@ -435,6 +435,7 @@ class OpenAIStreamProcessor:
                 if cost_usd is not None:
                     formatted_text += f", cost_usd={cost_usd}"
                 yield self._format_chunk_output(delta={"content": formatted_text})
+
             elif block.get("type") == "tool_use":
                 # Start of tool call
                 tool_id = block.get("id", "")

ccproxy/api/app.py

@@ -1,9 +1,8 @@
 """FastAPI application factory for CCProxy API Server."""
 
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Awaitable, Callable
 from contextlib import asynccontextmanager
-from datetime import UTC, datetime
-from typing import Any
+from typing import Any, TypedDict
 
 from fastapi import APIRouter, FastAPI
 from fastapi.staticfiles import StaticFiles
@@ -19,7 +18,6 @@ from ccproxy.api.middleware.request_content_logging import (
 from ccproxy.api.middleware.request_id import RequestIDMiddleware
 from ccproxy.api.middleware.server_header import ServerHeaderMiddleware
 from ccproxy.api.routes.claude import router as claude_router
-from ccproxy.api.routes.health import get_claude_cli_info
 from ccproxy.api.routes.health import router as health_router
 from ccproxy.api.routes.mcp import setup_mcp
 from ccproxy.api.routes.metrics import (
@@ -29,24 +27,93 @@ from ccproxy.api.routes.metrics import (
 )
 from ccproxy.api.routes.permissions import router as permissions_router
 from ccproxy.api.routes.proxy import router as proxy_router
-from ccproxy.api.services.permission_service import get_permission_service
-from ccproxy.auth.credentials_adapter import CredentialsAuthManager
-from ccproxy.auth.exceptions import CredentialsNotFoundError
 from ccproxy.auth.oauth.routes import router as oauth_router
 from ccproxy.config.settings import Settings, get_settings
 from ccproxy.core.logging import setup_logging
-from ccproxy.observability import get_metrics
-from ccproxy.observability.storage.duckdb_simple import SimpleDuckDBStorage
-from ccproxy.scheduler.errors import SchedulerError
-from ccproxy.scheduler.manager import start_scheduler, stop_scheduler
-from ccproxy.services.claude_sdk_service import ClaudeSDKService
-from ccproxy.services.credentials import CredentialsManager
 from ccproxy.utils.models_provider import get_models_list
+from ccproxy.utils.startup_helpers import (
+    check_claude_cli_startup,
+    flush_streaming_batches_shutdown,
+    initialize_claude_detection_startup,
+    initialize_claude_sdk_startup,
+    initialize_log_storage_shutdown,
+    initialize_log_storage_startup,
+    initialize_permission_service_startup,
+    setup_permission_service_shutdown,
+    setup_scheduler_shutdown,
+    setup_scheduler_startup,
+    setup_session_manager_shutdown,
+    validate_authentication_startup,
+)
 
 
 logger = get_logger(__name__)
 
 
+# Type definitions for lifecycle components
+class LifecycleComponent(TypedDict):
+    name: str
+    startup: Callable[[FastAPI, Any], Awaitable[None]] | None
+    shutdown: (
+        Callable[[FastAPI], Awaitable[None]]
+        | Callable[[FastAPI, Any], Awaitable[None]]
+        | None
+    )
+
+
+class ShutdownComponent(TypedDict):
+    name: str
+    shutdown: Callable[[FastAPI], Awaitable[None]] | None
+
+
+# Define lifecycle components for startup/shutdown organization
+LIFECYCLE_COMPONENTS: list[LifecycleComponent] = [
+    {
+        "name": "Authentication",
+        "startup": validate_authentication_startup,
+        "shutdown": None,  # One-time validation, no cleanup needed
+    },
+    {
+        "name": "Claude CLI",
+        "startup": check_claude_cli_startup,
+        "shutdown": None,  # Detection only, no cleanup needed
+    },
+    {
+        "name": "Claude Detection",
+        "startup": initialize_claude_detection_startup,
+        "shutdown": None,  # No cleanup needed
+    },
+    {
+        "name": "Claude SDK",
+        "startup": initialize_claude_sdk_startup,
+        "shutdown": setup_session_manager_shutdown,
+    },
+    {
+        "name": "Scheduler",
+        "startup": setup_scheduler_startup,
+        "shutdown": setup_scheduler_shutdown,
+    },
+    {
+        "name": "Log Storage",
+        "startup": initialize_log_storage_startup,
+        "shutdown": initialize_log_storage_shutdown,
+    },
+    {
+        "name": "Permission Service",
+        "startup": initialize_permission_service_startup,
+        "shutdown": setup_permission_service_shutdown,
+    },
+]
+
+# Additional shutdown-only components that need special handling
+SHUTDOWN_ONLY_COMPONENTS: list[ShutdownComponent] = [
+    {
+        "name": "Streaming Batches",
+        "shutdown": flush_streaming_batches_shutdown,
+    },
+]
+
+
 # Create shared models router
 models_router = APIRouter(tags=["models"])
 
@@ -63,7 +130,7 @@ async def list_models() -> dict[str, Any]:
 
 @asynccontextmanager
 async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
-    """Application lifespan manager."""
+    """Application lifespan manager using component-based approach."""
     settings = get_settings()
 
     # Store settings in app state for reuse in dependencies
@@ -89,216 +156,57 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
             "claude_cli_search_paths", paths=settings.claude.get_searched_paths()
         )
 
-    # Validate authentication token at startup
-    try:
-        credentials_manager = CredentialsManager()
-        validation = await credentials_manager.validate()
-
-        if validation.valid and not validation.expired:
-            credentials = validation.credentials
-            oauth_token = credentials.claude_ai_oauth if credentials else None
-
-            if oauth_token and oauth_token.expires_at_datetime:
-                hours_until_expiry = int(
-                    (
-                        oauth_token.expires_at_datetime - datetime.now(UTC)
-                    ).total_seconds()
-                    / 3600
-                )
-                logger.debug(
-                    "auth_token_valid",
-                    expires_in_hours=hours_until_expiry,
-                    subscription_type=oauth_token.subscription_type,
-                    credentials_path=str(validation.path) if validation.path else None,
+    # Execute startup components in order
+    for component in LIFECYCLE_COMPONENTS:
+        if component["startup"]:
+            component_name = component["name"]
+            try:
+                logger.debug(f"starting_{component_name.lower().replace(' ', '_')}")
+                await component["startup"](app, settings)
+            except Exception as e:
+                logger.error(
+                    f"{component_name.lower().replace(' ', '_')}_startup_failed",
+                    error=str(e),
+                    component=component_name,
                 )
-            else:
-                logger.debug("auth_token_valid", credentials_path=str(validation.path))
-        elif validation.expired:
-            logger.warning(
-                "auth_token_expired",
-                message="Authentication token has expired. Please run 'ccproxy auth login' to refresh.",
-                credentials_path=str(validation.path) if validation.path else None,
-            )
-        else:
-            logger.warning(
-                "auth_token_invalid",
-                message="Authentication token is invalid. Please run 'ccproxy auth login'.",
-                credentials_path=str(validation.path) if validation.path else None,
-            )
-    except CredentialsNotFoundError:
-        logger.warning(
-            "auth_token_not_found",
-            message="No authentication credentials found. Please run 'ccproxy auth login' to authenticate.",
-            searched_paths=settings.auth.storage.storage_paths,
-        )
-    except Exception as e:
-        logger.error(
-            "auth_token_validation_error",
-            error=str(e),
-            message="Failed to validate authentication token. The server will continue without authentication.",
-            exc_info=True,
-        )
-
-    # Validate Claude binary at startup using the new function
-    try:
-        claude_info = await get_claude_cli_info()
-
-        if claude_info.status == "available":
-            logger.info(
-                "claude_cli_available",
-                status=claude_info.status,
-                version=claude_info.version,
-                binary_path=claude_info.binary_path,
-            )
-        else:
-            logger.warning(
-                "claude_cli_unavailable",
-                status=claude_info.status,
-                error=claude_info.error,
-                binary_path=claude_info.binary_path,
-                message=f"Claude CLI status: {claude_info.status}",
-            )
-    except Exception as e:
-        logger.error(
-            "claude_cli_check_failed",
-            error=str(e),
-            message="Failed to check Claude CLI status during startup",
-        )
-
-    # Initialize ClaudeSDKService and store in app state
-    try:
-        # Create auth manager with settings
-        auth_manager = CredentialsAuthManager()
-
-        # Get global metrics instance
-        metrics = get_metrics()
-
-        # Create ClaudeSDKService instance
-        claude_service = ClaudeSDKService(
-            auth_manager=auth_manager,
-            metrics=metrics,
-            settings=settings,
-        )
-
-        # Store in app state for reuse in dependencies
-        app.state.claude_service = claude_service
-        logger.debug("claude_sdk_service_initialized")
-    except Exception as e:
-        logger.error("claude_sdk_service_initialization_failed", error=str(e))
-        # Continue startup even if ClaudeSDKService fails (graceful degradation)
-
-    # Start scheduler system
-    try:
-        scheduler = await start_scheduler(settings)
-        app.state.scheduler = scheduler
-        logger.debug("scheduler_initialized")
-    except SchedulerError as e:
-        logger.error("scheduler_initialization_failed", error=str(e))
-        # Continue startup even if scheduler fails (graceful degradation)
-
-    # Initialize log storage if needed and backend is duckdb
-    if (
-        settings.observability.needs_storage_backend
-        and settings.observability.log_storage_backend == "duckdb"
-    ):
-        try:
-            storage = SimpleDuckDBStorage(
-                database_path=settings.observability.duckdb_path
-            )
-            await storage.initialize()
-            app.state.log_storage = storage
-            logger.debug(
-                "log_storage_initialized",
-                backend="duckdb",
-                path=str(settings.observability.duckdb_path),
-                collection_enabled=settings.observability.logs_collection_enabled,
-            )
-        except Exception as e:
-            logger.error("log_storage_initialization_failed", error=str(e))
-            # Continue without log storage (graceful degradation)
-
-    # Initialize permission service
-    try:
-        permission_service = get_permission_service()
-
-        # Only connect terminal handler if not using external handler
-        if settings.server.use_terminal_permission_handler:
-            # terminal_handler = TerminalPermissionHandler()
-
-            # TODO: Terminal handler should subscribe to events from the service
-            # instead of trying to set a handler directly
-            # The service uses an event-based architecture, not direct handlers
-
-            # logger.info(
-            #     "permission_handler_configured",
-            #     handler_type="terminal",
-            #     message="Connected terminal handler to permission service",
-            # )
-            # app.state.terminal_handler = terminal_handler
-            pass
-        else:
-            logger.debug(
-                "permission_handler_configured",
-                handler_type="external_sse",
-                message="Terminal permission handler disabled - use 'ccproxy permission-handler connect' to handle permissions",
-            )
-            logger.warning(
-                "permission_handler_required",
-                message="Start external handler with: ccproxy permission-handler connect",
-            )
-
-        # Start the permission service
-        await permission_service.start()
-
-        # Store references in app state
-        app.state.permission_service = permission_service
-
-        logger.debug(
-            "permission_service_initialized",
-            timeout_seconds=permission_service._timeout_seconds,
-            terminal_handler_enabled=settings.server.use_terminal_permission_handler,
-        )
-    except Exception as e:
-        logger.error("permission_service_initialization_failed", error=str(e))
-        # Continue without permission service (API will work but without prompts)
+                # Continue with graceful degradation
 
     yield
 
     # Shutdown
     logger.debug("server_stop")
 
-    # Flush any remaining streaming log batches
-    try:
-        from ccproxy.utils.simple_request_logger import flush_all_streaming_batches
-
-        await flush_all_streaming_batches()
-        logger.debug("streaming_batches_flushed")
-    except Exception as e:
-        logger.error("streaming_batches_flush_failed", error=str(e))
-
-    # Stop scheduler system
-    try:
-        scheduler = getattr(app.state, "scheduler", None)
-        await stop_scheduler(scheduler)
-        logger.debug("scheduler_stopped_lifespan")
-    except SchedulerError as e:
-        logger.error("scheduler_stop_failed", error=str(e))
-
-    # Stop permission service
-    if hasattr(app.state, "permission_service") and app.state.permission_service:
-        try:
-            await app.state.permission_service.stop()
-            logger.debug("permission_service_stopped")
-        except Exception as e:
-            logger.error("permission_service_stop_failed", error=str(e))
-
-    # Close log storage if initialized
-    if hasattr(app.state, "log_storage") and app.state.log_storage:
-        try:
-            await app.state.log_storage.close()
-            logger.debug("log_storage_closed")
-        except Exception as e:
-            logger.error("log_storage_close_failed", error=str(e))
+    # Execute shutdown-only components first
+    for shutdown_component in SHUTDOWN_ONLY_COMPONENTS:
+        if shutdown_component["shutdown"]:
+            component_name = shutdown_component["name"]
+            try:
+                logger.debug(f"stopping_{component_name.lower().replace(' ', '_')}")
+                await shutdown_component["shutdown"](app)
+            except Exception as e:
+                logger.error(
+                    f"{component_name.lower().replace(' ', '_')}_shutdown_failed",
+                    error=str(e),
+                    component=component_name,
+                )
+
+    # Execute shutdown components in reverse order
+    for component in reversed(LIFECYCLE_COMPONENTS):
+        if component["shutdown"]:
+            component_name = component["name"]
+            try:
+                logger.debug(f"stopping_{component_name.lower().replace(' ', '_')}")
+                # Some shutdown functions need settings, others don't
+                if component_name == "Permission Service":
+                    await component["shutdown"](app, settings)  # type: ignore
+                else:
+                    await component["shutdown"](app)  # type: ignore
+            except Exception as e:
+                logger.error(
+                    f"{component_name.lower().replace(' ', '_')}_shutdown_failed",
+                    error=str(e),
+                    component=component_name,
+                )
 
 
 def create_app(settings: Settings | None = None) -> FastAPI:
@@ -346,13 +254,13 @@ def create_app(settings: Settings | None = None) -> FastAPI:
     setup_cors_middleware(app, settings)
     setup_error_handlers(app)
 
-    # Add request content logging middleware first (will run third due to middleware order)
+    # Add request content logging middleware first (will run fourth due to middleware order)
     app.add_middleware(RequestContentLoggingMiddleware)
 
-    # Add custom access log middleware second (will run second due to middleware order)
+    # Add custom access log middleware second (will run third due to middleware order)
     app.add_middleware(AccessLogMiddleware)
 
-    # Add request ID middleware third (will run first to initialize context)
+    # Add request ID middleware fourth (will run first to initialize context)
     app.add_middleware(RequestIDMiddleware)
 
     # Add server header middleware (for non-proxy routes)
@@ -384,10 +292,12 @@ def create_app(settings: Settings | None = None) -> FastAPI:
     app.include_router(models_router, prefix="/sdk", tags=["claude-sdk", "models"])
     app.include_router(models_router, prefix="/api", tags=["proxy-api", "models"])
 
-    # Confirmation endpoints for SSE streaming and responses
-    app.include_router(permissions_router, prefix="/permissions", tags=["permissions"])
-
-    setup_mcp(app)
+    # Confirmation endpoints for SSE streaming and responses (conditional on builtin_permissions)
+    if settings.claude.builtin_permissions:
+        app.include_router(
+            permissions_router, prefix="/permissions", tags=["permissions"]
+        )
+        setup_mcp(app)
 
     # Mount static files for dashboard SPA
     from pathlib import Path

ccproxy/api/dependencies.py

@@ -1,5 +1,7 @@
 """Shared dependencies for CCProxy API Server."""
 
+from __future__ import annotations
+
 from typing import Annotated
 
 from fastapi import Depends, Request
@@ -97,10 +99,25 @@ def get_claude_service(
     # 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
+
     return ClaudeSDKService(
         auth_manager=auth_manager,
         metrics=metrics,
         settings=settings,
+        session_manager=session_manager,
     )
 
 
@@ -120,6 +137,7 @@ def get_credentials_manager(
 
 
 def get_proxy_service(
+    request: Request,
     settings: SettingsDep,
     credentials_manager: Annotated[
         CredentialsManager, Depends(get_credentials_manager)
@@ -128,13 +146,14 @@ def get_proxy_service(
     """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("Creating proxy service instance")
+    logger.debug("get_proxy_service")
     # Create HTTP client for proxy
     from ccproxy.core.http import HTTPXClient
 
@@ -151,6 +170,7 @@ def get_proxy_service(
         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
     )
 
 
@@ -160,7 +180,7 @@ def get_observability_metrics() -> PrometheusMetrics:
     Returns:
         PrometheusMetrics instance
     """
-    logger.debug("Getting observability metrics instance")
+    logger.debug("get_observability_metrics")
     return get_metrics()
 
 

ccproxy/api/middleware/errors.py

@@ -50,6 +50,12 @@ def setup_error_handlers(app: FastAPI) -> None:
         request: Request, exc: ClaudeProxyError
     ) -> JSONResponse:
         """Handle Claude proxy specific errors."""
+        # Store status code in request state for access logging
+        if hasattr(request.state, "context") and hasattr(
+            request.state.context, "metadata"
+        ):
+            request.state.context.metadata["status_code"] = exc.status_code
+
         logger.error(
             "Claude proxy error",
             error_type="claude_proxy_error",
@@ -82,6 +88,12 @@ def setup_error_handlers(app: FastAPI) -> None:
         request: Request, exc: ValidationError
     ) -> JSONResponse:
         """Handle validation errors."""
+        # Store status code in request state for access logging
+        if hasattr(request.state, "context") and hasattr(
+            request.state.context, "metadata"
+        ):
+            request.state.context.metadata["status_code"] = 400
+
         logger.error(
             "Validation error",
             error_type="validation_error",
@@ -565,9 +577,15 @@ def setup_error_handlers(app: FastAPI) -> None:
         request: Request, exc: HTTPException
     ) -> JSONResponse:
         """Handle HTTP exceptions."""
+        # Store status code in request state for access logging
+        if hasattr(request.state, "context") and hasattr(
+            request.state.context, "metadata"
+        ):
+            request.state.context.metadata["status_code"] = exc.status_code
+
         # Don't log stack trace for 404 errors as they're expected
         if exc.status_code == 404:
-            logger.info(
+            logger.debug(
                 "HTTP 404 error",
                 error_type="http_404",
                 error_message=exc.detail,
@@ -581,7 +599,7 @@ def setup_error_handlers(app: FastAPI) -> None:
             # For structlog, we can always include traceback since structlog handles filtering
             import traceback
 
-            stack_trace = traceback.format_exc()
+            stack_trace = traceback.format_exc(limit=5)  # Limit to 5 frames
 
             logger.error(
                 "HTTP exception",
@@ -621,7 +639,7 @@ def setup_error_handlers(app: FastAPI) -> None:
         """Handle Starlette HTTP exceptions."""
         # Don't log stack trace for 404 errors as they're expected
         if exc.status_code == 404:
-            logger.info(
+            logger.debug(
                 "Starlette HTTP 404 error",
                 error_type="starlette_http_404",
                 error_message=exc.detail,
@@ -668,6 +686,12 @@ def setup_error_handlers(app: FastAPI) -> None:
         request: Request, exc: Exception
     ) -> JSONResponse:
         """Handle all other unhandled exceptions."""
+        # Store status code in request state for access logging
+        if hasattr(request.state, "context") and hasattr(
+            request.state.context, "metadata"
+        ):
+            request.state.context.metadata["status_code"] = 500
+
         logger.error(
             "Unhandled exception",
             error_type="unhandled_exception",

ccproxy/api/middleware/logging.py

@@ -111,6 +111,10 @@ class AccessLogMiddleware(BaseHTTPMiddleware):
                     if anthropic_request_id:
                         rate_limit_info["anthropic_request_id"] = anthropic_request_id
 
+                    headers = request.state.context.metadata.get("headers", {})
+                    headers.update(rate_limit_info)
+                    request.state.context.metadata["headers"] = headers
+                    request.state.context.metadata["status_code"] = status_code
                     # Extract metadata from context if available
                     context_metadata = {}
                     try:

ccproxy/api/responses.py

@@ -48,14 +48,19 @@ class ProxyResponse(Response):
         """
         # Ensure we include all original headers, including 'server'
         headers_list = []
+        seen_headers = set()
 
         # 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"]:
+            if (
+                lower_name not in ["content-length", "transfer-encoding"]
+                and lower_name not in seen_headers
+            ):
                 headers_list.append((lower_name.encode(), value.encode()))
+                seen_headers.add(lower_name)
 
         # Always set correct content-length based on actual body
         if self.body: