ccproxy-api 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

ccproxy/adapters/openai/streaming.py

@@ -8,19 +8,19 @@ from __future__ import annotations
 
 import json
 import time
-from collections.abc import AsyncGenerator, AsyncIterator
-from typing import Any
+from collections.abc import AsyncIterator
+from typing import Any, Literal
+
+import structlog
 
 from .models import (
-    OpenAIStreamingChatCompletionResponse,
-    OpenAIStreamingChoice,
-    OpenAIStreamingDelta,
-    OpenAIUsage,
     generate_openai_response_id,
-    generate_openai_system_fingerprint,
 )
 
 
+logger = structlog.get_logger(__name__)
+
+
 class OpenAISSEFormatter:
     """Formats streaming responses to match OpenAI's SSE format."""
 
@@ -246,8 +246,7 @@ class OpenAIStreamProcessor:
         created: int | None = None,
         enable_usage: bool = True,
         enable_tool_calls: bool = True,
-        enable_text_chunking: bool = True,
-        chunk_size_words: int = 3,
+        output_format: Literal["sse", "dict"] = "sse",
     ):
         """Initialize the stream processor.
 
@@ -257,16 +256,14 @@ class OpenAIStreamProcessor:
             created: Creation timestamp, current time if not provided
             enable_usage: Whether to include usage information
             enable_tool_calls: Whether to process tool calls
-            enable_text_chunking: Whether to chunk text content
-            chunk_size_words: Number of words per text chunk
+            output_format: Output format - "sse" for Server-Sent Events strings, "dict" for dict objects
         """
         self.message_id = message_id or generate_openai_response_id()
         self.model = model
         self.created = created or int(time.time())
         self.enable_usage = enable_usage
         self.enable_tool_calls = enable_tool_calls
-        self.enable_text_chunking = enable_text_chunking
-        self.chunk_size_words = chunk_size_words
+        self.output_format = output_format
         self.formatter = OpenAISSEFormatter()
 
         # State tracking
@@ -281,71 +278,164 @@ class OpenAIStreamProcessor:
 
     async def process_stream(
         self, claude_stream: AsyncIterator[dict[str, Any]]
-    ) -> AsyncIterator[str]:
+    ) -> AsyncIterator[str | dict[str, Any]]:
         """Process a Claude/Anthropic stream into OpenAI format.
 
         Args:
             claude_stream: Async iterator of Claude response chunks
 
         Yields:
-            OpenAI-formatted SSE strings
+            OpenAI-formatted SSE strings or dict objects based on output_format
         """
         try:
+            chunk_count = 0
+            processed_count = 0
             async for chunk in claude_stream:
+                chunk_count += 1
+                logger.debug(
+                    "openai_stream_chunk_received",
+                    chunk_count=chunk_count,
+                    chunk_type=chunk.get("type"),
+                    chunk=chunk,
+                )
                 async for sse_chunk in self._process_chunk(chunk):
+                    processed_count += 1
+                    logger.debug(
+                        "openai_stream_chunk_processed",
+                        processed_count=processed_count,
+                        sse_chunk=sse_chunk,
+                    )
                     yield sse_chunk
 
+            logger.debug(
+                "openai_stream_complete",
+                total_chunks=chunk_count,
+                processed_chunks=processed_count,
+                usage_info=self.usage_info,
+            )
+
             # Send final chunk
             if self.usage_info and self.enable_usage:
-                yield self.formatter.format_final_chunk(
-                    self.message_id,
-                    self.model,
-                    self.created,
+                yield self._format_chunk_output(
                     finish_reason="stop",
                     usage=self.usage_info,
                 )
             else:
-                yield self.formatter.format_final_chunk(
-                    self.message_id, self.model, self.created, finish_reason="stop"
-                )
+                yield self._format_chunk_output(finish_reason="stop")
 
-            # Send DONE event
-            yield self.formatter.format_done()
+            # Send DONE event (only for SSE format)
+            if self.output_format == "sse":
+                yield self.formatter.format_done()
 
         except Exception as e:
             # Send error chunk
-            yield self.formatter.format_error_chunk(
-                self.message_id, self.model, self.created, "error", str(e)
-            )
-            yield self.formatter.format_done()
+            if self.output_format == "sse":
+                yield self.formatter.format_error_chunk(
+                    self.message_id, self.model, self.created, "error", str(e)
+                )
+                yield self.formatter.format_done()
+            else:
+                # Dict format error
+                yield self._create_chunk_dict(finish_reason="error")
 
-    async def _process_chunk(self, chunk: dict[str, Any]) -> AsyncIterator[str]:
+    async def _process_chunk(
+        self, chunk: dict[str, Any]
+    ) -> AsyncIterator[str | dict[str, Any]]:
         """Process a single chunk from the Claude stream.
 
         Args:
             chunk: Claude response chunk
 
         Yields:
-            OpenAI-formatted SSE strings
+            OpenAI-formatted SSE strings or dict objects based on output_format
         """
-        chunk_type = chunk.get("type")
+        # Handle both Claude SDK and standard Anthropic API formats:
+        # Claude SDK format: {"event": "...", "data": {"type": "..."}}
+        # Anthropic API format: {"type": "...", ...}
+        event_type = chunk.get("event")
+        if event_type:
+            # Claude SDK format
+            chunk_data = chunk.get("data", {})
+            chunk_type = chunk_data.get("type")
+        else:
+            # Standard Anthropic API format
+            chunk_data = chunk
+            chunk_type = chunk.get("type")
 
         if chunk_type == "message_start":
             # Send initial role chunk
             if not self.role_sent:
-                yield self.formatter.format_first_chunk(
-                    self.message_id, self.model, self.created
-                )
+                yield self._format_chunk_output(delta={"role": "assistant"})
                 self.role_sent = True
 
         elif chunk_type == "content_block_start":
-            block = chunk.get("content_block", {})
+            block = chunk_data.get("content_block", {})
             if block.get("type") == "thinking":
                 # Start of thinking block
                 self.thinking_block_active = True
                 self.current_thinking_text = ""
                 self.current_thinking_signature = None
-            elif block.get("type") == "tool_use" and self.enable_tool_calls:
+            elif block.get("type") == "system_message":
+                # Handle system message content block
+                system_text = block.get("text", "")
+                source = block.get("source", "claude_code_sdk")
+                # Format as text with clear source attribution
+                formatted_text = f"[{source}]: {system_text}"
+                yield self._format_chunk_output(delta={"content": formatted_text})
+            elif block.get("type") == "tool_use_sdk" and self.enable_tool_calls:
+                # Handle custom tool_use_sdk content block
+                tool_id = block.get("id", "")
+                tool_name = block.get("name", "")
+                tool_input = block.get("input", {})
+                source = block.get("source", "claude_code_sdk")
+
+                # For dict format, immediately yield the tool call
+                if self.output_format == "dict":
+                    yield self._format_chunk_output(
+                        delta={
+                            "tool_calls": [
+                                {
+                                    "index": 0,
+                                    "id": tool_id,
+                                    "type": "function",
+                                    "function": {
+                                        "name": tool_name,
+                                        "arguments": json.dumps(tool_input),
+                                    },
+                                }
+                            ]
+                        }
+                    )
+                else:
+                    # For SSE format, store for later processing
+                    self.tool_calls[tool_id] = {
+                        "id": tool_id,
+                        "name": tool_name,
+                        "arguments": tool_input,
+                        "source": source,
+                    }
+            elif block.get("type") == "tool_result_sdk":
+                # Handle custom tool_result_sdk content block
+                source = block.get("source", "claude_code_sdk")
+                tool_use_id = block.get("tool_use_id", "")
+                result_content = block.get("content", "")
+                is_error = block.get("is_error", False)
+                error_indicator = " (ERROR)" if is_error else ""
+                formatted_text = f"[{source} tool_result {tool_use_id}{error_indicator}]: {result_content}"
+                yield self._format_chunk_output(delta={"content": formatted_text})
+            elif block.get("type") == "result_message":
+                # Handle custom result_message content block
+                source = block.get("source", "claude_code_sdk")
+                result_data = block.get("data", {})
+                session_id = result_data.get("session_id", "")
+                stop_reason = result_data.get("stop_reason", "")
+                usage = result_data.get("usage", {})
+                cost_usd = result_data.get("total_cost_usd")
+                formatted_text = f"[{source} result {session_id}]: stop_reason={stop_reason}, usage={usage}"
+                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", "")
                 tool_name = block.get("name", "")
@@ -356,27 +446,14 @@ class OpenAIStreamProcessor:
                 }
 
         elif chunk_type == "content_block_delta":
-            delta = chunk.get("delta", {})
+            delta = chunk_data.get("delta", {})
             delta_type = delta.get("type")
 
             if delta_type == "text_delta":
                 # Text content
                 text = delta.get("text", "")
                 if text:
-                    if self.enable_text_chunking:
-                        # Chunk the text
-                        words = text.split()
-                        for i in range(0, len(words), self.chunk_size_words):
-                            chunk_words = words[i : i + self.chunk_size_words]
-                            chunk_text = " ".join(chunk_words)
-                            yield self.formatter.format_content_chunk(
-                                self.message_id, self.model, self.created, chunk_text
-                            )
-                    else:
-                        # Send text as-is
-                        yield self.formatter.format_content_chunk(
-                            self.message_id, self.model, self.created, text
-                        )
+                    yield self._format_chunk_output(delta={"content": text})
 
             elif delta_type == "thinking_delta" and self.thinking_block_active:
                 # Thinking content
@@ -392,7 +469,7 @@ class OpenAIStreamProcessor:
                         self.current_thinking_signature = ""
                     self.current_thinking_signature += signature
 
-            elif delta_type == "input_json_delta" and self.enable_tool_calls:
+            elif delta_type == "input_json_delta":
                 # Tool call arguments
                 partial_json = delta.get("partial_json", "")
                 if partial_json and self.tool_calls:
@@ -408,28 +485,39 @@ class OpenAIStreamProcessor:
                 if self.current_thinking_text:
                     # Format thinking block with signature
                     thinking_content = f'<thinking signature="{self.current_thinking_signature}">{self.current_thinking_text}</thinking>'
-                    yield self.formatter.format_content_chunk(
-                        self.message_id, self.model, self.created, thinking_content
-                    )
+                    yield self._format_chunk_output(delta={"content": thinking_content})
                 # Reset thinking state
                 self.current_thinking_text = ""
                 self.current_thinking_signature = None
 
-            elif self.tool_calls and self.enable_tool_calls:
-                # Send completed tool calls
+            elif (
+                self.tool_calls
+                and self.enable_tool_calls
+                and self.output_format == "sse"
+            ):
+                # Send completed tool calls (only for SSE format, dict format sends immediately)
                 for tool_call in self.tool_calls.values():
-                    yield self.formatter.format_tool_call_chunk(
-                        self.message_id,
-                        self.model,
-                        self.created,
-                        tool_call["id"],
-                        function_name=tool_call["name"],
-                        function_arguments=tool_call["arguments"],
+                    yield self._format_chunk_output(
+                        delta={
+                            "tool_calls": [
+                                {
+                                    "index": 0,
+                                    "id": tool_call["id"],
+                                    "type": "function",
+                                    "function": {
+                                        "name": tool_call["name"],
+                                        "arguments": json.dumps(tool_call["arguments"])
+                                        if isinstance(tool_call["arguments"], dict)
+                                        else tool_call["arguments"],
+                                    },
+                                }
+                            ]
+                        }
                     )
 
         elif chunk_type == "message_delta":
             # Usage information
-            usage = chunk.get("usage", {})
+            usage = chunk_data.get("usage", {})
             if usage and self.enable_usage:
                 self.usage_info = {
                     "prompt_tokens": usage.get("input_tokens", 0),
@@ -442,6 +530,100 @@ class OpenAIStreamProcessor:
             # End of message - handled in main process_stream method
             pass
 
+    def _create_chunk_dict(
+        self,
+        delta: dict[str, Any] | None = None,
+        finish_reason: str | None = None,
+        usage: dict[str, int] | None = None,
+    ) -> dict[str, Any]:
+        """Create an OpenAI completion chunk dict.
+
+        Args:
+            delta: The delta content for the chunk
+            finish_reason: Optional finish reason
+            usage: Optional usage information
+
+        Returns:
+            OpenAI completion chunk dict
+        """
+        chunk = {
+            "id": self.message_id,
+            "object": "chat.completion.chunk",
+            "created": self.created,
+            "model": self.model,
+            "choices": [
+                {
+                    "index": 0,
+                    "delta": delta or {},
+                    "logprobs": None,
+                    "finish_reason": finish_reason,
+                }
+            ],
+        }
+
+        if usage:
+            chunk["usage"] = usage
+
+        return chunk
+
+    def _format_chunk_output(
+        self,
+        delta: dict[str, Any] | None = None,
+        finish_reason: str | None = None,
+        usage: dict[str, int] | None = None,
+    ) -> str | dict[str, Any]:
+        """Format chunk output based on output_format flag.
+
+        Args:
+            delta: The delta content for the chunk
+            finish_reason: Optional finish reason
+            usage: Optional usage information
+
+        Returns:
+            Either SSE string or dict based on output_format
+        """
+        if self.output_format == "dict":
+            return self._create_chunk_dict(delta, finish_reason, usage)
+        else:
+            # SSE format
+            if finish_reason:
+                if usage:
+                    return self.formatter.format_final_chunk(
+                        self.message_id,
+                        self.model,
+                        self.created,
+                        finish_reason,
+                        usage=usage,
+                    )
+                else:
+                    return self.formatter.format_final_chunk(
+                        self.message_id, self.model, self.created, finish_reason
+                    )
+            elif delta and delta.get("role"):
+                return self.formatter.format_first_chunk(
+                    self.message_id, self.model, self.created, delta["role"]
+                )
+            elif delta and delta.get("content"):
+                return self.formatter.format_content_chunk(
+                    self.message_id, self.model, self.created, delta["content"]
+                )
+            elif delta and delta.get("tool_calls"):
+                # Handle tool calls
+                tool_call = delta["tool_calls"][0]  # Assume single tool call for now
+                return self.formatter.format_tool_call_chunk(
+                    self.message_id,
+                    self.model,
+                    self.created,
+                    tool_call["id"],
+                    tool_call.get("function", {}).get("name"),
+                    tool_call.get("function", {}).get("arguments"),
+                )
+            else:
+                # Empty delta
+                return self.formatter.format_final_chunk(
+                    self.message_id, self.model, self.created, "stop"
+                )
+
 
 __all__ = [
     "OpenAISSEFormatter",

ccproxy/api/__init__.py

@@ -12,10 +12,7 @@ from ccproxy.api.dependencies import (
 )
 
 
-app = create_app()
-
 __all__ = [
-    "app",
     "create_app",
     "get_app",
     "get_claude_service",