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

ccproxy/llms/formatters/base.py

@@ -0,0 +1,140 @@
+"""Base adapter interface for API format conversion."""
+
+from abc import ABC, abstractmethod
+from collections.abc import AsyncGenerator, AsyncIterator
+from typing import Generic, TypeVar
+
+from pydantic import BaseModel
+
+from ccproxy.core.interfaces import StreamingConfigurable
+
+
+RequestType = TypeVar("RequestType", bound=BaseModel)
+ResponseType = TypeVar("ResponseType", bound=BaseModel)
+StreamEventType = TypeVar("StreamEventType", bound=BaseModel)
+
+
+class APIAdapter(ABC, Generic[RequestType, ResponseType, StreamEventType]):
+    """Abstract base class for API format adapters.
+
+    Provides strongly-typed interface for converting between different API formats
+    with full type safety and validation.
+    """
+
+    @abstractmethod
+    async def adapt_request(self, request: RequestType) -> BaseModel:
+        """Convert a request using strongly-typed Pydantic models.
+
+        Args:
+            request: The typed request model to convert
+
+        Returns:
+            The converted typed request model
+
+        Raises:
+            ValueError: If the request format is invalid or unsupported
+        """
+        pass
+
+    @abstractmethod
+    async def adapt_response(self, response: ResponseType) -> BaseModel:
+        """Convert a response using strongly-typed Pydantic models.
+
+        Args:
+            response: The typed response model to convert
+
+        Returns:
+            The converted typed response model
+
+        Raises:
+            ValueError: If the response format is invalid or unsupported
+        """
+        pass
+
+    @abstractmethod
+    def adapt_stream(
+        self, stream: AsyncIterator[StreamEventType]
+    ) -> AsyncGenerator[BaseModel, None]:
+        """Convert a streaming response using strongly-typed Pydantic models.
+
+        Args:
+            stream: The typed streaming response data to convert
+
+        Yields:
+            The converted typed streaming response chunks
+
+        Raises:
+            ValueError: If the stream format is invalid or unsupported
+        """
+        # This should be implemented as an async generator
+        # Subclasses must override this method
+        ...
+
+    @abstractmethod
+    async def adapt_error(self, error: BaseModel) -> BaseModel:
+        """Convert an error response using strongly-typed Pydantic models.
+
+        Args:
+            error: The typed error response model to convert
+
+        Returns:
+            The converted typed error response model
+
+        Raises:
+            ValueError: If the error format is invalid or unsupported
+        """
+        pass
+
+
+class BaseAPIAdapter(
+    APIAdapter[RequestType, ResponseType, StreamEventType],
+    StreamingConfigurable,
+):
+    """Base implementation with common functionality.
+
+    Provides strongly-typed interface for API format conversion with
+    better type safety and validation.
+    """
+
+    def __init__(self, name: str):
+        self.name = name
+        # Optional streaming flags that subclasses may use
+        self._openai_thinking_xml: bool | None = None
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}({self.name})"
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    # StreamingConfigurable
+    def configure_streaming(self, *, openai_thinking_xml: bool | None = None) -> None:
+        self._openai_thinking_xml = openai_thinking_xml
+
+    # Strongly-typed interface - subclasses implement these
+    @abstractmethod
+    async def adapt_request(self, request: RequestType) -> BaseModel:
+        """Convert a request using strongly-typed Pydantic models."""
+        pass
+
+    @abstractmethod
+    async def adapt_response(self, response: ResponseType) -> BaseModel:
+        """Convert a response using strongly-typed Pydantic models."""
+        pass
+
+    @abstractmethod
+    def adapt_stream(
+        self, stream: AsyncIterator[StreamEventType]
+    ) -> AsyncGenerator[BaseModel, None]:
+        """Convert a streaming response using strongly-typed Pydantic models."""
+        # This should be implemented as an async generator
+        # Subclasses must override this method
+        ...
+
+    @abstractmethod
+    async def adapt_error(self, error: BaseModel) -> BaseModel:
+        """Convert an error response using strongly-typed Pydantic models."""
+        pass
+
+
+__all__ = ["APIAdapter", "BaseAPIAdapter"]

ccproxy/llms/formatters/base_model.py

@@ -0,0 +1,33 @@
+"""Shared base model for all LLM API models."""
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+
+class LlmBaseModel(BaseModel):
+    """Base model for all LLM API models with proper JSON serialization.
+
+    Excludes None values and empty collections to match API conventions.
+    """
+
+    model_config = ConfigDict(
+        extra="allow",  # Allow extra fields
+    )
+
+    def model_dump(self, **kwargs: Any) -> dict[str, Any]:
+        """Override to exclude empty collections as well as None values."""
+        # Extract exclude_none from kwargs, defaulting to True for our convention
+        exclude_none = kwargs.pop("exclude_none", True)
+        # First get the data with None values excluded
+        data = super().model_dump(exclude_none=exclude_none, **kwargs)
+
+        # Filter out empty collections (lists, dicts, sets)
+        filtered_data = {}
+        for key, value in data.items():
+            if isinstance(value, list | dict | set) and len(value) == 0:
+                # Skip empty collections
+                continue
+            filtered_data[key] = value
+
+        return filtered_data

ccproxy/llms/formatters/common/__init__.py

@@ -0,0 +1,51 @@
+"""Shared helpers used by formatter adapters."""
+
+from .identifiers import ensure_identifier, normalize_suffix
+from .streams import (
+    IndexedToolCallTracker,
+    ObfuscationTokenFactory,
+    ReasoningBuffer,
+    ReasoningPartState,
+    ToolCallState,
+    ToolCallTracker,
+    build_anthropic_tool_use_block,
+    emit_anthropic_tool_use_events,
+)
+from .thinking import (
+    THINKING_CLOSE_PATTERN,
+    THINKING_OPEN_PATTERN,
+    THINKING_PATTERN,
+    ThinkingSegment,
+    merge_thinking_segments,
+)
+from .usage import (
+    convert_anthropic_usage_to_openai_completion_usage,
+    convert_anthropic_usage_to_openai_responses_usage,
+    convert_openai_completion_usage_to_responses_usage,
+    convert_openai_responses_usage_to_anthropic_usage,
+    convert_openai_responses_usage_to_completion_usage,
+)
+
+
+__all__ = [
+    "ensure_identifier",
+    "normalize_suffix",
+    "THINKING_PATTERN",
+    "THINKING_OPEN_PATTERN",
+    "THINKING_CLOSE_PATTERN",
+    "ThinkingSegment",
+    "merge_thinking_segments",
+    "ReasoningBuffer",
+    "ReasoningPartState",
+    "ToolCallState",
+    "ToolCallTracker",
+    "IndexedToolCallTracker",
+    "ObfuscationTokenFactory",
+    "build_anthropic_tool_use_block",
+    "emit_anthropic_tool_use_events",
+    "convert_anthropic_usage_to_openai_completion_usage",
+    "convert_anthropic_usage_to_openai_responses_usage",
+    "convert_openai_completion_usage_to_responses_usage",
+    "convert_openai_responses_usage_to_anthropic_usage",
+    "convert_openai_responses_usage_to_completion_usage",
+]

ccproxy/llms/formatters/common/identifiers.py

@@ -0,0 +1,48 @@
+"""Identifier helpers shared across formatter adapters."""
+
+from __future__ import annotations
+
+import uuid
+
+
+def normalize_suffix(identifier: str) -> str:
+    """Return the suffix part of an identifier split on the first underscore."""
+
+    if "_" in identifier:
+        return identifier.split("_", 1)[1]
+    return identifier
+
+
+def ensure_identifier(prefix: str, existing: str | None = None) -> tuple[str, str]:
+    """Return a stable identifier and suffix for the given prefix.
+
+    If an existing identifier already matches the prefix we reuse its suffix.
+    Existing identifiers that begin with ``resp_`` are also understood so both
+    ``resp`` and alternate prefixes can build consistent derived identifiers.
+    """
+
+    if isinstance(existing, str) and existing.startswith(f"{prefix}_"):
+        return existing, normalize_suffix(existing)
+
+    if (
+        isinstance(existing, str)
+        and existing
+        and prefix == "resp"
+        and existing.startswith("resp_")
+    ):
+        return existing, normalize_suffix(existing)
+
+    if (
+        isinstance(existing, str)
+        and existing
+        and existing.startswith("resp_")
+        and prefix != "resp"
+    ):
+        suffix = normalize_suffix(existing)
+        return f"{prefix}_{suffix}", suffix
+
+    suffix = uuid.uuid4().hex
+    return f"{prefix}_{suffix}", suffix
+
+
+__all__ = ["ensure_identifier", "normalize_suffix"]

ccproxy/llms/formatters/common/streams.py

@@ -0,0 +1,254 @@
+"""Shared streaming helpers for formatter adapters."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+from ccproxy.llms.formatters.utils import build_obfuscation_token
+from ccproxy.llms.models import anthropic as anthropic_models
+
+from .thinking import ThinkingSegment
+
+
+@dataclass(slots=True)
+class ReasoningPartState:
+    """Mutable reasoning buffer for a specific summary segment."""
+
+    buffer: list[str] = field(default_factory=list)
+    signature: str | None = None
+    open: bool = False
+
+
+class ReasoningBuffer:
+    """Utility to manage reasoning text buffers keyed by item/summary ids."""
+
+    def __init__(self) -> None:
+        self._states: dict[str, dict[Any, ReasoningPartState]] = {}
+
+    def ensure_part(self, item_id: str, summary_index: Any) -> ReasoningPartState:
+        item_states = self._states.setdefault(item_id, {})
+        part_state = item_states.get(summary_index)
+        if part_state is None:
+            part_state = ReasoningPartState()
+            item_states[summary_index] = part_state
+        return part_state
+
+    def set_signature(
+        self, item_id: str, summary_index: Any, signature: str | None
+    ) -> None:
+        if not signature:
+            return
+        part_state = self.ensure_part(item_id, summary_index)
+        part_state.signature = signature
+
+    def reset_buffer(self, item_id: str, summary_index: Any) -> None:
+        part_state = self.ensure_part(item_id, summary_index)
+        part_state.buffer.clear()
+
+    def open_part(
+        self, item_id: str, summary_index: Any, signature: str | None = None
+    ) -> ReasoningPartState:
+        part_state = self.ensure_part(item_id, summary_index)
+        if signature:
+            part_state.signature = signature
+        part_state.buffer.clear()
+        part_state.open = True
+        return part_state
+
+    def close_part(self, item_id: str, summary_index: Any) -> None:
+        part_state = self.ensure_part(item_id, summary_index)
+        part_state.open = False
+
+    def is_open(self, item_id: str, summary_index: Any) -> bool:
+        return self.ensure_part(item_id, summary_index).open
+
+    def append_text(self, item_id: str, summary_index: Any, text: str | None) -> None:
+        if not isinstance(text, str) or not text:
+            return
+        part_state = self.ensure_part(item_id, summary_index)
+        part_state.buffer.append(text)
+
+    def emit(
+        self, item_id: str, summary_index: Any, final_text: str | None = None
+    ) -> list[str]:
+        part_state = self.ensure_part(item_id, summary_index)
+        text = (
+            final_text
+            if isinstance(final_text, str) and final_text
+            else "".join(part_state.buffer)
+        )
+        part_state.buffer.clear()
+        part_state.open = False
+        if not text:
+            return []
+        segment = ThinkingSegment(thinking=text, signature=part_state.signature)
+        xml = segment.to_xml()
+        closing = "</thinking>"
+        body = xml[: -len(closing)] if xml.endswith(closing) else xml
+        return [body, closing]
+
+
+@dataclass(slots=True)
+class ToolCallState:
+    """Mutable state for a single streaming tool call."""
+
+    id: str
+    index: int
+    call_id: str | None = None
+    item_id: str | None = None
+    name: str | None = None
+    arguments: str = ""
+    arguments_parts: list[str] = field(default_factory=list)
+    output_index: int = -1
+    emitted: bool = False
+    initial_emitted: bool = False
+    name_emitted: bool = False
+    arguments_emitted: bool = False
+    arguments_done_emitted: bool = False
+    item_done_emitted: bool = False
+    added_emitted: bool = False
+    completed: bool = False
+    final_arguments: str | None = None
+
+    def append_arguments(self, segment: str) -> None:
+        if segment:
+            self.arguments += segment
+
+    def add_arguments_part(self, segment: str) -> None:
+        if segment:
+            self.arguments_parts.append(segment)
+
+
+class ToolCallTracker:
+    """Registry tracking streaming tool calls by item identifier."""
+
+    def __init__(self) -> None:
+        self._states: dict[str, ToolCallState] = {}
+        self._order: list[str] = []
+
+    def ensure(self, item_id: str) -> ToolCallState:
+        state = self._states.get(item_id)
+        if state is None:
+            state = ToolCallState(
+                id=item_id,
+                index=len(self._order),
+            )
+            state.output_index = len(self._order)
+            self._states[item_id] = state
+            self._order.append(item_id)
+        return state
+
+    def values(self) -> list[ToolCallState]:
+        return [self._states[item_id] for item_id in self._order]
+
+    def any_completed(self) -> bool:
+        return any(state.completed for state in self._states.values())
+
+    def __len__(self) -> int:  # noqa: D401
+        return len(self._states)
+
+
+class IndexedToolCallTracker:
+    """Registry tracking streaming tool calls keyed by integer index."""
+
+    def __init__(self) -> None:
+        self._states: dict[int, ToolCallState] = {}
+
+    def ensure(self, index: int) -> ToolCallState:
+        state = self._states.get(index)
+        if state is None:
+            state = ToolCallState(id=f"call_{index}", index=index)
+            self._states[index] = state
+        return state
+
+    def items(self) -> list[tuple[int, ToolCallState]]:
+        return [(idx, self._states[idx]) for idx in sorted(self._states)]
+
+    def values(self) -> list[ToolCallState]:
+        return [state for _, state in self.items()]
+
+    def __contains__(self, index: int) -> bool:  # noqa: D401
+        return index in self._states
+
+    def __len__(self) -> int:  # noqa: D401
+        return len(self._states)
+
+
+class ObfuscationTokenFactory:
+    """Utility for building deterministic obfuscation tokens."""
+
+    def __init__(self, fallback_identifier: Callable[[], str]) -> None:
+        self._fallback_identifier = fallback_identifier
+
+    def make(
+        self,
+        kind: str,
+        *,
+        sequence: int,
+        item_id: str | None = None,
+        payload: str | None = None,
+    ) -> str:
+        base_identifier = item_id or self._fallback_identifier()
+        return build_obfuscation_token(
+            seed=f"{kind}:{base_identifier}",
+            sequence=sequence,
+            payload=payload or "",
+        )
+
+
+def build_anthropic_tool_use_block(
+    state: ToolCallState,
+    *,
+    default_id: str | None = None,
+    parser: Callable[[str], dict[str, Any]] | None = None,
+) -> anthropic_models.ToolUseBlock:
+    """Create an Anthropic ToolUseBlock from a tracked tool-call state."""
+
+    tool_id = state.item_id or state.call_id or default_id or f"call_{state.index}"
+    arguments_text = (
+        state.final_arguments or state.arguments or "".join(state.arguments_parts)
+    )
+    parse_input = parser or (lambda text: {"arguments": text} if text else {})
+    input_payload = parse_input(arguments_text)
+
+    return anthropic_models.ToolUseBlock(
+        type="tool_use",
+        id=str(tool_id),
+        name=str(state.name or "tool"),
+        input=input_payload,
+    )
+
+
+def emit_anthropic_tool_use_events(
+    index: int,
+    state: ToolCallState,
+    *,
+    parser: Callable[[str], dict[str, Any]] | None = None,
+) -> list[anthropic_models.MessageStreamEvent]:
+    """Build start/stop events for a tool-use block at the given index."""
+
+    block = build_anthropic_tool_use_block(
+        state,
+        default_id=f"call_{state.index}",
+        parser=parser,
+    )
+    return [
+        anthropic_models.ContentBlockStartEvent(
+            type="content_block_start", index=index, content_block=block
+        ),
+        anthropic_models.ContentBlockStopEvent(type="content_block_stop", index=index),
+    ]
+
+
+__all__ = [
+    "ReasoningBuffer",
+    "ReasoningPartState",
+    "ToolCallState",
+    "ToolCallTracker",
+    "IndexedToolCallTracker",
+    "ObfuscationTokenFactory",
+    "build_anthropic_tool_use_block",
+    "emit_anthropic_tool_use_events",
+]

ccproxy/llms/formatters/common/thinking.py

@@ -0,0 +1,74 @@
+"""Shared helpers for reasoning/thinking segment handling."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable
+from dataclasses import dataclass
+
+from ccproxy.llms.models import anthropic as anthropic_models
+
+
+THINKING_PATTERN = re.compile(
+    r"<thinking(?:\s+signature=\"([^\"]*)\")?>(.*?)</thinking>",
+    re.DOTALL,
+)
+THINKING_OPEN_PATTERN = re.compile(
+    r"<thinking(?:\s+signature=\"([^\"]*)\")?\s*>",
+    re.IGNORECASE,
+)
+THINKING_CLOSE_PATTERN = re.compile(r"</thinking>", re.IGNORECASE)
+
+
+@dataclass(slots=True)
+class ThinkingSegment:
+    """Lightweight reasoning segment mirroring Anthropic's ThinkingBlock."""
+
+    thinking: str
+    signature: str | None = None
+
+    def to_block(self) -> anthropic_models.ThinkingBlock:
+        return anthropic_models.ThinkingBlock(
+            type="thinking",
+            thinking=self.thinking,
+            signature=self.signature or "",
+        )
+
+    def to_xml(self) -> str:
+        signature = (self.signature or "").strip()
+        signature_attr = f' signature="{signature}"' if signature else ""
+        return f"<thinking{signature_attr}>{self.thinking}</thinking>"
+
+    @classmethod
+    def from_xml(cls, signature: str | None, text: str) -> ThinkingSegment:
+        return cls(thinking=text, signature=signature or None)
+
+
+def merge_thinking_segments(
+    segments: Iterable[ThinkingSegment],
+) -> list[ThinkingSegment]:
+    """Collapse adjacent segments that share the same signature."""
+
+    merged: list[ThinkingSegment] = []
+    for segment in segments:
+        text = segment.thinking if isinstance(segment.thinking, str) else None
+        if not text:
+            continue
+        signature = segment.signature or None
+        if merged and merged[-1].signature == signature:
+            merged[-1] = ThinkingSegment(
+                thinking=f"{merged[-1].thinking}{text}",
+                signature=signature,
+            )
+        else:
+            merged.append(ThinkingSegment(thinking=text, signature=signature))
+    return merged
+
+
+__all__ = [
+    "THINKING_PATTERN",
+    "THINKING_OPEN_PATTERN",
+    "THINKING_CLOSE_PATTERN",
+    "ThinkingSegment",
+    "merge_thinking_segments",
+]