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

ccproxy/api/routes/claude.py

@@ -14,6 +14,7 @@ from ccproxy.adapters.openai.adapter import (
 )
 from ccproxy.api.dependencies import ClaudeServiceDep
 from ccproxy.models.messages import MessageCreateParams, MessageResponse
+from ccproxy.observability.streaming_response import StreamingResponseWithLogging
 
 
 # Create the router for Claude SDK endpoints
@@ -24,9 +25,9 @@ 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: ClaudeServiceDep,
+    request: Request,
 ) -> StreamingResponse | OpenAIChatCompletionResponse:
     """Create a chat completion using Claude SDK with OpenAI-compatible format.
 
@@ -43,13 +44,102 @@ async def create_openai_chat_completion(
         # Extract stream parameter
         stream = openai_request.stream or False
 
+        # Get request context from middleware
+        request_context = getattr(request.state, "context", None)
+
+        if request_context is None:
+            raise HTTPException(
+                status_code=500, detail="Internal server error: no request context"
+            )
+
         # 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),
+            request_context=request_context,
+        )
+
+        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"
 
+            # Use unified streaming wrapper with logging
+            return StreamingResponseWithLogging(
+                content=openai_stream_generator(),
+                request_context=request_context,
+                metrics=getattr(claude_service, "metrics", None),
+                status_code=200,
+                media_type="text/event-stream",
+                headers={
+                    "Cache-Control": "no-cache",
+                    "Connection": "keep-alive",
+                },
+            )
+        else:
+            # Convert non-streaming response to OpenAI format using adapter
+            # Convert MessageResponse model to dict for adapter
+            # In non-streaming mode, response should always be MessageResponse
+            assert isinstance(response, MessageResponse), (
+                "Non-streaming response must be MessageResponse"
+            )
+            response_dict = response.model_dump()
+            openai_response = adapter.adapt_response(response_dict)
+            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(
+    "/{session_id}/v1/chat/completions",
+    response_model=None,
+)
+async def create_openai_chat_completion_with_session(
+    session_id: str,
+    openai_request: OpenAIChatCompletionRequest,
+    claude_service: ClaudeServiceDep,
+    request: Request,
+) -> StreamingResponse | OpenAIChatCompletionResponse:
+    """Create a chat completion using Claude SDK with OpenAI-compatible format and session ID.
+
+    This endpoint handles OpenAI API format requests with session ID 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
+
+        # Get request context from middleware
+        request_context = getattr(request.state, "context", None)
+
+        if request_context is None:
+            raise HTTPException(
+                status_code=500, detail="Internal server error: no request context"
+            )
+
+        # Call Claude SDK service with adapted request and session_id
         response = await claude_service.create_completion(
             messages=anthropic_request["messages"],
             model=anthropic_request["model"],
@@ -57,6 +147,8 @@ async def create_openai_chat_completion(
             max_tokens=anthropic_request.get("max_tokens"),
             stream=stream,
             user_id=getattr(openai_request, "user", None),
+            session_id=session_id,
+            request_context=request_context,
         )
 
         if stream:
@@ -68,8 +160,13 @@ async def create_openai_chat_completion(
                 # Send final chunk
                 yield b"data: [DONE]\n\n"
 
-            return StreamingResponse(
-                openai_stream_generator(),
+            # Use unified streaming wrapper with logging
+            # Session interrupts are now handled directly by the StreamHandle
+            return StreamingResponseWithLogging(
+                content=openai_stream_generator(),
+                request_context=request_context,
+                metrics=getattr(claude_service, "metrics", None),
+                status_code=200,
                 media_type="text/event-stream",
                 headers={
                     "Cache-Control": "no-cache",
@@ -98,10 +195,98 @@ async def create_openai_chat_completion(
         ) from e
 
 
+@router.post(
+    "/{session_id}/v1/messages",
+    response_model=None,
+)
+async def create_anthropic_message_with_session(
+    session_id: str,
+    message_request: MessageCreateParams,
+    claude_service: ClaudeServiceDep,
+    request: Request,
+) -> StreamingResponse | MessageResponse:
+    """Create a message using Claude SDK with Anthropic format and session ID.
+
+    This endpoint handles Anthropic API format requests with session ID directly
+    using the Claude SDK without any format conversion.
+    """
+    try:
+        # Extract parameters from Anthropic request
+        messages = [msg.model_dump() for msg in message_request.messages]
+        model = message_request.model
+        temperature = message_request.temperature
+        max_tokens = message_request.max_tokens
+        stream = message_request.stream or False
+
+        # Get request context from middleware
+        request_context = getattr(request.state, "context", None)
+        if request_context is None:
+            raise HTTPException(
+                status_code=500, detail="Internal server error: no request context"
+            )
+
+        # Call Claude SDK service directly with Anthropic format and session_id
+        response = await claude_service.create_completion(
+            messages=messages,
+            model=model,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            stream=stream,
+            user_id=getattr(message_request, "user_id", None),
+            session_id=session_id,
+            request_context=request_context,
+        )
+
+        if stream:
+            # Handle streaming response
+            async def anthropic_stream_generator() -> AsyncIterator[bytes]:
+                async for chunk in response:  # type: ignore[union-attr]
+                    if chunk:
+                        # All chunks from Claude SDK streaming should be dict format
+                        # and need proper SSE event formatting
+                        if isinstance(chunk, dict):
+                            # Determine event type from chunk type
+                            event_type = chunk.get("type", "message_delta")
+                            yield f"event: {event_type}\n".encode()
+                            yield f"data: {json.dumps(chunk)}\n\n".encode()
+                        else:
+                            # Fallback for unexpected format
+                            yield f"data: {json.dumps(chunk)}\n\n".encode()
+                # No final [DONE] chunk for Anthropic format
+
+            # Use unified streaming wrapper with logging
+            # Session interrupts are now handled directly by the StreamHandle
+            return StreamingResponseWithLogging(
+                content=anthropic_stream_generator(),
+                request_context=request_context,
+                metrics=getattr(claude_service, "metrics", None),
+                status_code=200,
+                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 e
+        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,
+    message_request: MessageCreateParams,
     claude_service: ClaudeServiceDep,
+    request: Request,
 ) -> StreamingResponse | MessageResponse:
     """Create a message using Claude SDK with Anthropic format.
 
@@ -110,11 +295,24 @@ async def create_anthropic_message(
     """
     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
+        messages = [msg.model_dump() for msg in message_request.messages]
+        model = message_request.model
+        temperature = message_request.temperature
+        max_tokens = message_request.max_tokens
+        stream = message_request.stream or False
+
+        # Get request context from middleware
+        request_context = getattr(request.state, "context", None)
+        if request_context is None:
+            raise HTTPException(
+                status_code=500, detail="Internal server error: no request context"
+            )
+
+        # Extract session_id from metadata if present
+        session_id = None
+        if message_request.metadata:
+            metadata_dict = message_request.metadata.model_dump()
+            session_id = metadata_dict.get("session_id")
 
         # Call Claude SDK service directly with Anthropic format
         response = await claude_service.create_completion(
@@ -123,7 +321,9 @@ async def create_anthropic_message(
             temperature=temperature,
             max_tokens=max_tokens,
             stream=stream,
-            user_id=getattr(request, "user_id", None),
+            user_id=getattr(message_request, "user_id", None),
+            session_id=session_id,
+            request_context=request_context,
         )
 
         if stream:
@@ -143,8 +343,13 @@ async def create_anthropic_message(
                             yield f"data: {json.dumps(chunk)}\n\n".encode()
                 # No final [DONE] chunk for Anthropic format
 
-            return StreamingResponse(
-                anthropic_stream_generator(),
+            # Use unified streaming wrapper with logging for all requests
+            # Session interrupts are now handled directly by the StreamHandle
+            return StreamingResponseWithLogging(
+                content=anthropic_stream_generator(),
+                request_context=request_context,
+                metrics=getattr(claude_service, "metrics", None),
+                status_code=200,
                 media_type="text/event-stream",
                 headers={
                     "Cache-Control": "no-cache",

ccproxy/api/routes/proxy.py

@@ -38,9 +38,11 @@ async def create_openai_chat_completion(
         )
 
         # Handle the request using proxy service directly
+        # Strip the /api prefix from the path
+        service_path = request.url.path.removeprefix("/api")
         response = await proxy_service.handle_request(
             method=request.method,
-            path=request.url.path,
+            path=service_path,
             headers=headers,
             body=body,
             query_params=query_params,
@@ -55,6 +57,8 @@ async def create_openai_chat_completion(
             # Tuple response - handle regular response
             status_code, response_headers, response_body = response
             if status_code >= 400:
+                # Store headers for preservation middleware
+                request.state.preserve_headers = response_headers
                 # Forward error response directly with headers
                 return ProxyResponse(
                     content=response_body,
@@ -128,9 +132,11 @@ async def create_anthropic_message(
         )
 
         # Handle the request using proxy service directly
+        # Strip the /api prefix from the path
+        service_path = request.url.path.removeprefix("/api")
         response = await proxy_service.handle_request(
             method=request.method,
-            path=request.url.path,
+            path=service_path,
             headers=headers,
             body=body,
             query_params=query_params,
@@ -145,6 +151,8 @@ async def create_anthropic_message(
             # Tuple response - handle regular response
             status_code, response_headers, response_body = response
             if status_code >= 400:
+                # Store headers for preservation middleware
+                request.state.preserve_headers = response_headers
                 # Forward error response directly with headers
                 return ProxyResponse(
                     content=response_body,
@@ -163,15 +171,26 @@ async def create_anthropic_message(
                         if line.strip():
                             yield f"{line}\n".encode()
 
+                # Start with the response headers from proxy service
+                streaming_headers = response_headers.copy()
+
+                # Ensure critical headers for streaming
+                streaming_headers["Cache-Control"] = "no-cache"
+                streaming_headers["Connection"] = "keep-alive"
+
+                # Set content-type if not already set by upstream
+                if "content-type" not in streaming_headers:
+                    streaming_headers["content-type"] = "text/event-stream"
+
                 return StreamingResponse(
                     stream_generator(),
                     media_type="text/event-stream",
-                    headers={
-                        "Cache-Control": "no-cache",
-                        "Connection": "keep-alive",
-                    },
+                    headers=streaming_headers,
                 )
             else:
+                # Store headers for preservation middleware
+                request.state.preserve_headers = response_headers
+
                 # Parse JSON response
                 response_data = json.loads(response_body.decode())
 

ccproxy/api/services/permission_service.py

@@ -35,7 +35,7 @@ class PermissionService:
     async def start(self) -> None:
         if self._expiry_task is None:
             self._expiry_task = asyncio.create_task(self._expiry_checker())
-            logger.info("permission_service_started")
+            logger.debug("permission_service_started")
 
     async def stop(self) -> None:
         self._shutdown = True
@@ -44,7 +44,7 @@ class PermissionService:
             with contextlib.suppress(asyncio.CancelledError):
                 await self._expiry_task
             self._expiry_task = None
-        logger.info("permission_service_stopped")
+        logger.debug("permission_service_stopped")
 
     async def request_permission(self, tool_name: str, input: dict[str, str]) -> str:
         """Create a new permission request.

ccproxy/claude_sdk/__init__.py

@@ -1,21 +1,17 @@
 """Claude SDK integration module."""
 
-from .client import (
-    ClaudeSDKClient,
-    ClaudeSDKConnectionError,
-    ClaudeSDKError,
-    ClaudeSDKProcessError,
-)
+from .client import ClaudeSDKClient
 from .converter import MessageConverter
+from .exceptions import ClaudeSDKError, StreamTimeoutError
 from .options import OptionsHandler
 from .parser import parse_formatted_sdk_content
 
 
 __all__ = [
+    # Session Context will be imported here once created
     "ClaudeSDKClient",
     "ClaudeSDKError",
-    "ClaudeSDKConnectionError",
-    "ClaudeSDKProcessError",
+    "StreamTimeoutError",
     "MessageConverter",
     "OptionsHandler",
     "parse_formatted_sdk_content",