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

ccproxy/{adapters/openai/streaming.py → llms/streaming/processors.py}

@@ -1,239 +1,80 @@
-"""OpenAI streaming response formatting.
+"""Stream processing utilities for converting between different streaming formats.
 
-This module provides Server-Sent Events (SSE) formatting for OpenAI-compatible
-streaming responses.
+This module provides stream processors that convert between different LLM
+streaming response formats (e.g., Anthropic to OpenAI, OpenAI to Anthropic).
 """
 
-from __future__ import annotations
-
 import json
+import os
 import time
 from collections.abc import AsyncIterator
 from typing import Any, Literal
 
-import structlog
-
-from .models import (
-    generate_openai_response_id,
-)
+from ccproxy.core.logging import get_logger
 
+from .formatters import AnthropicSSEFormatter, OpenAISSEFormatter
 
-logger = structlog.get_logger(__name__)
 
+logger = get_logger(__name__)
 
-class OpenAISSEFormatter:
-    """Formats streaming responses to match OpenAI's SSE format."""
 
-    @staticmethod
-    def format_data_event(data: dict[str, Any]) -> str:
-        """Format a data event for OpenAI-compatible Server-Sent Events.
-
-        Args:
-            data: Event data dictionary
-
-        Returns:
-            Formatted SSE string
-        """
-        json_data = json.dumps(data, separators=(",", ":"))
-        return f"data: {json_data}\n\n"
+class AnthropicStreamProcessor:
+    """Processes OpenAI streaming data into Anthropic SSE format."""
 
-    @staticmethod
-    def format_first_chunk(
-        message_id: str, model: str, created: int, role: str = "assistant"
-    ) -> str:
-        """Format the first chunk with role and basic metadata.
+    def __init__(self, model: str = "claude-3-5-sonnet-20241022"):
+        """Initialize the stream processor.
 
         Args:
-            message_id: Unique identifier for the completion
-            model: Model name being used
-            created: Unix timestamp when the completion was created
-            role: Role of the assistant
-
-        Returns:
-            Formatted SSE string
+            model: Model name for responses
         """
-        data = {
-            "id": message_id,
-            "object": "chat.completion.chunk",
-            "created": created,
-            "model": model,
-            "choices": [
-                {
-                    "index": 0,
-                    "delta": {"role": role},
-                    "logprobs": None,
-                    "finish_reason": None,
-                }
-            ],
-        }
-        return OpenAISSEFormatter.format_data_event(data)
-
-    @staticmethod
-    def format_content_chunk(
-        message_id: str, model: str, created: int, content: str, choice_index: int = 0
-    ) -> str:
-        """Format a content chunk with text delta.
-
-        Args:
-            message_id: Unique identifier for the completion
-            model: Model name being used
-            created: Unix timestamp when the completion was created
-            content: Text content to include in the delta
-            choice_index: Index of the choice (usually 0)
+        self.model = model
+        self.formatter = AnthropicSSEFormatter()
 
-        Returns:
-            Formatted SSE string
-        """
-        data = {
-            "id": message_id,
-            "object": "chat.completion.chunk",
-            "created": created,
-            "model": model,
-            "choices": [
-                {
-                    "index": choice_index,
-                    "delta": {"content": content},
-                    "logprobs": None,
-                    "finish_reason": None,
-                }
-            ],
-        }
-        return OpenAISSEFormatter.format_data_event(data)
-
-    @staticmethod
-    def format_tool_call_chunk(
-        message_id: str,
-        model: str,
-        created: int,
-        tool_call_id: str,
-        function_name: str | None = None,
-        function_arguments: str | None = None,
-        tool_call_index: int = 0,
-        choice_index: int = 0,
-    ) -> str:
-        """Format a tool call chunk.
+    async def process_stream(
+        self, stream: AsyncIterator[dict[str, Any]]
+    ) -> AsyncIterator[str]:
+        """Process OpenAI-format streaming data into Anthropic SSE format.
 
         Args:
-            message_id: Unique identifier for the completion
-            model: Model name being used
-            created: Unix timestamp when the completion was created
-            tool_call_id: ID of the tool call
-            function_name: Name of the function being called
-            function_arguments: Arguments for the function
-            tool_call_index: Index of the tool call
-            choice_index: Index of the choice (usually 0)
+            stream: Async iterator of OpenAI-style response chunks
 
-        Returns:
-            Formatted SSE string
+        Yields:
+            Anthropic-formatted SSE strings with proper event: lines
         """
-        tool_call: dict[str, Any] = {
-            "index": tool_call_index,
-            "id": tool_call_id,
-            "type": "function",
-            "function": {},
-        }
-
-        if function_name is not None:
-            tool_call["function"]["name"] = function_name
-
-        if function_arguments is not None:
-            tool_call["function"]["arguments"] = function_arguments
-
-        data = {
-            "id": message_id,
-            "object": "chat.completion.chunk",
-            "created": created,
-            "model": model,
-            "choices": [
-                {
-                    "index": choice_index,
-                    "delta": {"tool_calls": [tool_call]},
-                    "logprobs": None,
-                    "finish_reason": None,
-                }
-            ],
-        }
-        return OpenAISSEFormatter.format_data_event(data)
-
-    @staticmethod
-    def format_final_chunk(
-        message_id: str,
-        model: str,
-        created: int,
-        finish_reason: str = "stop",
-        choice_index: int = 0,
-        usage: dict[str, int] | None = None,
-    ) -> str:
-        """Format the final chunk with finish_reason.
+        message_started = False
+        content_block_started = False
 
-        Args:
-            message_id: Unique identifier for the completion
-            model: Model name being used
-            created: Unix timestamp when the completion was created
-            finish_reason: Reason for completion (stop, length, tool_calls, etc.)
-            choice_index: Index of the choice (usually 0)
-            usage: Optional usage information to include
+        async for chunk in stream:
+            if not isinstance(chunk, dict):
+                continue
 
-        Returns:
-            Formatted SSE string
-        """
-        data = {
-            "id": message_id,
-            "object": "chat.completion.chunk",
-            "created": created,
-            "model": model,
-            "choices": [
-                {
-                    "index": choice_index,
-                    "delta": {},
-                    "logprobs": None,
-                    "finish_reason": finish_reason,
-                }
-            ],
-        }
+            chunk_type = chunk.get("type")
 
-        # Add usage if provided
-        if usage:
-            data["usage"] = usage
+            if chunk_type == "message_start":
+                if not message_started:
+                    yield self.formatter.format_event("message_start", chunk)
+                    message_started = True
 
-        return OpenAISSEFormatter.format_data_event(data)
+            elif chunk_type == "content_block_start":
+                if not content_block_started:
+                    yield self.formatter.format_event("content_block_start", chunk)
+                    content_block_started = True
 
-    @staticmethod
-    def format_error_chunk(
-        message_id: str, model: str, created: int, error_type: str, error_message: str
-    ) -> str:
-        """Format an error chunk.
+            elif chunk_type == "content_block_delta":
+                yield self.formatter.format_event("content_block_delta", chunk)
 
-        Args:
-            message_id: Unique identifier for the completion
-            model: Model name being used
-            created: Unix timestamp when the completion was created
-            error_type: Type of error
-            error_message: Error message
+            elif chunk_type == "ping":
+                yield self.formatter.format_ping()
 
-        Returns:
-            Formatted SSE string
-        """
-        data = {
-            "id": message_id,
-            "object": "chat.completion.chunk",
-            "created": created,
-            "model": model,
-            "choices": [
-                {"index": 0, "delta": {}, "logprobs": None, "finish_reason": "error"}
-            ],
-            "error": {"type": error_type, "message": error_message},
-        }
-        return OpenAISSEFormatter.format_data_event(data)
+            elif chunk_type == "content_block_stop":
+                yield self.formatter.format_event("content_block_stop", chunk)
 
-    @staticmethod
-    def format_done() -> str:
-        """Format the final DONE event.
+            elif chunk_type == "message_delta":
+                yield self.formatter.format_event("message_delta", chunk)
 
-        Returns:
-            Formatted SSE termination string
-        """
-        return "data: [DONE]\n\n"
+            elif chunk_type == "message_stop":
+                yield self.formatter.format_event("message_stop", chunk)
+                break
 
 
 class OpenAIStreamProcessor:
@@ -246,6 +87,7 @@ class OpenAIStreamProcessor:
         created: int | None = None,
         enable_usage: bool = True,
         enable_tool_calls: bool = True,
+        enable_thinking_serialization: bool | None = None,
         output_format: Literal["sse", "dict"] = "sse",
     ):
         """Initialize the stream processor.
@@ -258,12 +100,45 @@ class OpenAIStreamProcessor:
             enable_tool_calls: Whether to process tool calls
             output_format: Output format - "sse" for Server-Sent Events strings, "dict" for dict objects
         """
-        self.message_id = message_id or generate_openai_response_id()
+        # Import here to avoid circular imports
+        from ccproxy.llms.models.openai import generate_responses_id
+
+        self.message_id = message_id or generate_responses_id()
         self.model = model
         self.created = created or int(time.time())
         self.enable_usage = enable_usage
         self.enable_tool_calls = enable_tool_calls
         self.output_format = output_format
+        if enable_thinking_serialization is None:
+            # Prefer service Settings.llm.openai_thinking_xml if available
+            setting_val: bool | None = None
+            try:
+                from ccproxy.config.settings import Settings
+
+                cfg = Settings.from_config()
+                setting_val = bool(
+                    getattr(getattr(cfg, "llm", {}), "openai_thinking_xml", True)
+                )
+            except Exception:
+                setting_val = None
+
+            if setting_val is not None:
+                self.enable_thinking_serialization = setting_val
+            else:
+                # Fallback to env-based toggle
+                env_val = (
+                    os.getenv("LLM__OPENAI_THINKING_XML")
+                    or os.getenv("OPENAI_STREAM_ENABLE_THINKING_SERIALIZATION")
+                    or "true"
+                ).lower()
+                self.enable_thinking_serialization = env_val not in (
+                    "0",
+                    "false",
+                    "no",
+                    "off",
+                )
+        else:
+            self.enable_thinking_serialization = enable_thinking_serialization
         self.formatter = OpenAISSEFormatter()
 
         # State tracking
@@ -287,31 +162,44 @@ class OpenAIStreamProcessor:
         Yields:
             OpenAI-formatted SSE strings or dict objects based on output_format
         """
+        # Get logger with request context at the start of the function
+        logger = get_logger(__name__)
+
         try:
             chunk_count = 0
             processed_count = 0
+            logger.debug(
+                "openai_stream_processor_start",
+                message_id=self.message_id,
+                model=self.model,
+                output_format=self.output_format,
+                enable_usage=self.enable_usage,
+                enable_tool_calls=self.enable_tool_calls,
+                category="streaming_conversion",
+                enable_thinking_serialization=self.enable_thinking_serialization,
+            )
+
             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,
+                chunk_type = chunk.get("type", "unknown")
+
+                logger.trace(
+                    "openai_processor_input_chunk",
+                    chunk_number=chunk_count,
+                    chunk_type=chunk_type,
+                    category="format_detection",
                 )
+
                 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,
+                message_id=self.message_id,
+                category="streaming_conversion",
             )
 
             # Send final chunk
@@ -327,7 +215,23 @@ class OpenAIStreamProcessor:
             if self.output_format == "sse":
                 yield self.formatter.format_done()
 
+        except (OSError, PermissionError) as e:
+            logger.error("stream_processing_io_error", error=str(e), exc_info=e)
+            # Send error chunk for IO errors
+            if self.output_format == "sse":
+                yield self.formatter.format_error_chunk(
+                    self.message_id,
+                    self.model,
+                    self.created,
+                    "error",
+                    f"IO error: {str(e)}",
+                )
+                yield self.formatter.format_done()
+            else:
+                # Dict format error
+                yield self._create_chunk_dict(finish_reason="error")
         except Exception as e:
+            logger.error("stream_processing_error", error=str(e), exc_info=e)
             # Send error chunk
             if self.output_format == "sse":
                 yield self.formatter.format_error_chunk(
@@ -357,14 +261,29 @@ class OpenAIStreamProcessor:
             # Claude SDK format
             chunk_data = chunk.get("data", {})
             chunk_type = chunk_data.get("type")
+            format_source = "claude_sdk"
         else:
             # Standard Anthropic API format
             chunk_data = chunk
             chunk_type = chunk.get("type")
+            format_source = "anthropic_api"
+
+        logger.trace(
+            "openai_processor_chunk_conversion",
+            format_source=format_source,
+            chunk_type=chunk_type,
+            event_type=event_type,
+            category="format_detection",
+        )
 
         if chunk_type == "message_start":
             # Send initial role chunk
             if not self.role_sent:
+                logger.trace(
+                    "openai_conversion_message_start",
+                    action="sending_role_chunk",
+                    category="streaming_conversion",
+                )
                 yield self._format_chunk_output(delta={"role": "assistant"})
                 self.role_sent = True
 
@@ -378,7 +297,7 @@ class OpenAIStreamProcessor:
             elif block.get("type") == "system_message":
                 # Handle system message content block
                 system_text = block.get("text", "")
-                source = block.get("source", "claude_code_sdk")
+                source = block.get("source", "ccproxy")
                 # Format as text with clear source attribution
                 formatted_text = f"[{source}]: {system_text}"
                 yield self._format_chunk_output(delta={"content": formatted_text})
@@ -387,7 +306,7 @@ class OpenAIStreamProcessor:
                 tool_id = block.get("id", "")
                 tool_name = block.get("name", "")
                 tool_input = block.get("input", {})
-                source = block.get("source", "claude_code_sdk")
+                source = block.get("source", "ccproxy")
 
                 # For dict format, immediately yield the tool call
                 if self.output_format == "dict":
@@ -416,7 +335,7 @@ class OpenAIStreamProcessor:
                     }
             elif block.get("type") == "tool_result_sdk":
                 # Handle custom tool_result_sdk content block
-                source = block.get("source", "claude_code_sdk")
+                source = block.get("source", "ccproxy")
                 tool_use_id = block.get("tool_use_id", "")
                 result_content = block.get("content", "")
                 is_error = block.get("is_error", False)
@@ -425,7 +344,7 @@ class OpenAIStreamProcessor:
                 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")
+                source = block.get("source", "ccproxy")
                 result_data = block.get("data", {})
                 session_id = result_data.get("session_id", "")
                 stop_reason = result_data.get("stop_reason", "")
@@ -454,6 +373,11 @@ class OpenAIStreamProcessor:
                 # Text content
                 text = delta.get("text", "")
                 if text:
+                    logger.trace(
+                        "openai_conversion_text_delta",
+                        text_length=len(text),
+                        category="streaming_conversion",
+                    )
                     yield self._format_chunk_output(delta={"content": text})
 
             elif delta_type == "thinking_delta" and self.thinking_block_active:
@@ -485,24 +409,45 @@ class OpenAIStreamProcessor:
                 self.thinking_block_active = False
                 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._format_chunk_output(delta={"content": thinking_content})
+                    if self.enable_thinking_serialization:
+                        thinking_content = (
+                            f'<thinking signature="{self.current_thinking_signature}">'
+                            f"{self.current_thinking_text}</thinking>"
+                        )
+                        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
-                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():
+            elif self.tool_calls and self.enable_tool_calls:
+                # Send completed tool calls for both SSE and dict formats
+                # Previous bug: Only sent for SSE format, causing dict format (SDK mode) to miss tool calls
+                logger.trace(
+                    "openai_stream_sending_tool_calls",
+                    tool_count=len(self.tool_calls),
+                    output_format=self.output_format,
+                    category="streaming_conversion",
+                )
+
+                for tool_call_index, (tool_call_id, tool_call) in enumerate(
+                    self.tool_calls.items()
+                ):
+                    logger.trace(
+                        "openai_stream_tool_call_yielding",
+                        tool_call_id=tool_call_id,
+                        tool_name=tool_call["name"],
+                        has_arguments=bool(tool_call["arguments"]),
+                        index=tool_call_index,
+                        category="streaming_conversion",
+                    )
+
                     yield self._format_chunk_output(
                         delta={
                             "tool_calls": [
                                 {
-                                    "index": 0,
+                                    "index": tool_call_index,
                                     "id": tool_call["id"],
                                     "type": "function",
                                     "function": {
@@ -516,10 +461,24 @@ class OpenAIStreamProcessor:
                         }
                     )
 
+                # Clear tool_calls after yielding to prevent duplicates
+                logger.trace(
+                    "openai_stream_clearing_tool_calls",
+                    cleared_count=len(self.tool_calls),
+                    category="streaming_conversion",
+                )
+                self.tool_calls.clear()
+
         elif chunk_type == "message_delta":
             # Usage information
             usage = chunk_data.get("usage", {})
             if usage and self.enable_usage:
+                logger.trace(
+                    "openai_conversion_usage_info",
+                    input_tokens=usage.get("input_tokens", 0),
+                    output_tokens=usage.get("output_tokens", 0),
+                    category="streaming_conversion",
+                )
                 self.usage_info = {
                     "prompt_tokens": usage.get("input_tokens", 0),
                     "completion_tokens": usage.get("output_tokens", 0),
@@ -620,13 +579,7 @@ class OpenAIStreamProcessor:
                     tool_call.get("function", {}).get("arguments"),
                 )
             else:
-                # Empty delta
-                return self.formatter.format_final_chunk(
-                    self.message_id, self.model, self.created, "stop"
+                # Empty delta - send chunk with null finish_reason
+                return self.formatter.format_content_chunk(
+                    self.message_id, self.model, self.created, ""
                 )
-
-
-__all__ = [
-    "OpenAISSEFormatter",
-    "OpenAIStreamProcessor",
-]