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

ccproxy/llms/formatters/common/usage.py

@@ -0,0 +1,135 @@
+"""Shared token usage conversion helpers for formatter adapters."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ccproxy.llms.formatters.utils import (
+    anthropic_usage_snapshot,
+    openai_completion_usage_snapshot,
+    openai_response_usage_snapshot,
+)
+from ccproxy.llms.models import anthropic as anthropic_models
+from ccproxy.llms.models import openai as openai_models
+
+
+def convert_openai_responses_usage_to_completion_usage(
+    usage: Any,
+) -> openai_models.CompletionUsage:
+    """Normalize Responses usage into the legacy CompletionUsage envelope."""
+
+    snapshot = openai_response_usage_snapshot(usage)
+
+    prompt_tokens_details = openai_models.PromptTokensDetails(
+        cached_tokens=snapshot.cache_read_tokens,
+        audio_tokens=0,
+    )
+    completion_tokens_details = openai_models.CompletionTokensDetails(
+        reasoning_tokens=snapshot.reasoning_tokens,
+        audio_tokens=0,
+        accepted_prediction_tokens=0,
+        rejected_prediction_tokens=0,
+    )
+
+    return openai_models.CompletionUsage(
+        prompt_tokens=snapshot.input_tokens,
+        completion_tokens=snapshot.output_tokens,
+        total_tokens=snapshot.input_tokens + snapshot.output_tokens,
+        prompt_tokens_details=prompt_tokens_details,
+        completion_tokens_details=completion_tokens_details,
+    )
+
+
+def convert_openai_completion_usage_to_responses_usage(
+    usage: Any,
+) -> openai_models.ResponseUsage:
+    """Map Completion usage payloads into Responses Usage structures."""
+
+    snapshot = openai_completion_usage_snapshot(usage)
+
+    input_tokens_details = openai_models.InputTokensDetails(
+        cached_tokens=snapshot.cache_read_tokens
+    )
+    output_tokens_details = openai_models.OutputTokensDetails(
+        reasoning_tokens=snapshot.reasoning_tokens
+    )
+
+    return openai_models.ResponseUsage(
+        input_tokens=snapshot.input_tokens,
+        input_tokens_details=input_tokens_details,
+        output_tokens=snapshot.output_tokens,
+        output_tokens_details=output_tokens_details,
+        total_tokens=snapshot.input_tokens + snapshot.output_tokens,
+    )
+
+
+def convert_openai_responses_usage_to_anthropic_usage(
+    usage: Any,
+) -> anthropic_models.Usage:
+    """Translate OpenAI Responses usage into Anthropic Usage models."""
+
+    snapshot = openai_response_usage_snapshot(usage)
+
+    return anthropic_models.Usage(
+        input_tokens=snapshot.input_tokens,
+        output_tokens=snapshot.output_tokens,
+        cache_read_input_tokens=snapshot.cache_read_tokens,
+        cache_creation_input_tokens=snapshot.cache_creation_tokens,
+    )
+
+
+def convert_anthropic_usage_to_openai_completion_usage(
+    usage: Any,
+) -> openai_models.CompletionUsage:
+    """Translate Anthropic Usage values into OpenAI Completion usage."""
+
+    snapshot = anthropic_usage_snapshot(usage)
+    cached_tokens = snapshot.cache_read_tokens or snapshot.cache_creation_tokens
+
+    prompt_tokens_details = openai_models.PromptTokensDetails(
+        cached_tokens=cached_tokens,
+        audio_tokens=0,
+    )
+    completion_tokens_details = openai_models.CompletionTokensDetails(
+        reasoning_tokens=0,
+        audio_tokens=0,
+        accepted_prediction_tokens=0,
+        rejected_prediction_tokens=0,
+    )
+
+    return openai_models.CompletionUsage(
+        prompt_tokens=snapshot.input_tokens,
+        completion_tokens=snapshot.output_tokens,
+        total_tokens=snapshot.input_tokens + snapshot.output_tokens,
+        prompt_tokens_details=prompt_tokens_details,
+        completion_tokens_details=completion_tokens_details,
+    )
+
+
+def convert_anthropic_usage_to_openai_responses_usage(
+    usage: Any,
+) -> openai_models.ResponseUsage:
+    """Translate Anthropic Usage values into OpenAI Responses usage."""
+
+    snapshot = anthropic_usage_snapshot(usage)
+    cached_tokens = snapshot.cache_read_tokens or snapshot.cache_creation_tokens
+
+    input_tokens_details = openai_models.InputTokensDetails(cached_tokens=cached_tokens)
+    output_tokens_details = openai_models.OutputTokensDetails(reasoning_tokens=0)
+
+    return openai_models.ResponseUsage(
+        input_tokens=snapshot.input_tokens,
+        input_tokens_details=input_tokens_details,
+        output_tokens=snapshot.output_tokens,
+        output_tokens_details=output_tokens_details,
+        total_tokens=snapshot.input_tokens + snapshot.output_tokens,
+    )
+
+
+__all__ = [
+    "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/constants.py

@@ -0,0 +1,55 @@
+"""Shared constant mappings for LLM adapters."""
+
+from __future__ import annotations
+
+from typing import Final
+
+
+ANTHROPIC_TO_OPENAI_FINISH_REASON: Final[dict[str, str]] = {
+    "end_turn": "stop",
+    "max_tokens": "length",
+    "stop_sequence": "stop",
+    "tool_use": "tool_calls",
+    # Anthropic-specific values mapped to closest reasonable OpenAI value
+    "pause_turn": "stop",
+    "refusal": "stop",
+}
+
+OPENAI_TO_ANTHROPIC_STOP_REASON: Final[dict[str, str]] = {
+    "stop": "end_turn",
+    "length": "max_tokens",
+    "tool_calls": "tool_use",
+}
+
+OPENAI_TO_ANTHROPIC_ERROR_TYPE: Final[dict[str, str]] = {
+    "invalid_request_error": "invalid_request_error",
+    "authentication_error": "invalid_request_error",
+    "permission_error": "invalid_request_error",
+    "not_found_error": "invalid_request_error",
+    "rate_limit_error": "rate_limit_error",
+    "internal_server_error": "api_error",
+    "overloaded_error": "api_error",
+}
+
+ANTHROPIC_TO_OPENAI_ERROR_TYPE: Final[dict[str, str]] = {
+    "invalid_request_error": "invalid_request_error",
+    "authentication_error": "authentication_error",
+    "permission_error": "permission_error",
+    "not_found_error": "invalid_request_error",  # OpenAI doesn't expose not_found
+    "rate_limit_error": "rate_limit_error",
+    "api_error": "api_error",
+    "overloaded_error": "api_error",
+    "billing_error": "invalid_request_error",
+    "timeout_error": "api_error",
+}
+
+DEFAULT_MAX_TOKENS: Final[int] = 1024
+
+
+__all__ = [
+    "ANTHROPIC_TO_OPENAI_FINISH_REASON",
+    "OPENAI_TO_ANTHROPIC_STOP_REASON",
+    "OPENAI_TO_ANTHROPIC_ERROR_TYPE",
+    "ANTHROPIC_TO_OPENAI_ERROR_TYPE",
+    "DEFAULT_MAX_TOKENS",
+]

ccproxy/llms/formatters/context.py

@@ -0,0 +1,116 @@
+"""Context helpers for formatter conversions using async contextvars."""
+
+from __future__ import annotations
+
+from contextvars import ContextVar
+from typing import Any
+
+
+_REQUEST_VAR: ContextVar[Any | None] = ContextVar("formatter_request", default=None)
+_INSTRUCTIONS_VAR: ContextVar[str | None] = ContextVar(
+    "formatter_instructions", default=None
+)
+_TOOLS_VAR: ContextVar[list[Any] | None] = ContextVar("formatter_tools", default=None)
+
+
+def register_request(request: Any | None, instructions: str | None = None) -> None:
+    """Record the most recent upstream request for streaming conversions."""
+
+    normalized = instructions.strip() if isinstance(instructions, str) else None
+
+    _REQUEST_VAR.set(request)
+    _INSTRUCTIONS_VAR.set(normalized)
+
+    try:
+        from ccproxy.core.request_context import RequestContext
+
+        ctx = RequestContext.get_current()
+        if ctx is not None:
+            formatter_state = ctx.metadata.setdefault("formatter_state", {})
+            if request is None:
+                formatter_state.pop("request", None)
+            else:
+                formatter_state["request"] = request
+
+            if normalized:
+                formatter_state["instructions"] = normalized
+            elif instructions is None:
+                formatter_state.pop("instructions", None)
+    except Exception:
+        # Request context propagation is best-effort; proceed even when
+        # request context is unavailable (e.g., during unit tests).
+        pass
+
+
+def get_last_request() -> Any | None:
+    """Return the cached upstream request for the active conversion, if any."""
+
+    try:
+        from ccproxy.core.request_context import RequestContext
+
+        ctx = RequestContext.get_current()
+        if ctx is not None:
+            formatter_state = ctx.metadata.get("formatter_state", {})
+            if "request" in formatter_state:
+                return formatter_state["request"]
+    except Exception:
+        pass
+
+    return _REQUEST_VAR.get()
+
+
+def get_last_instructions() -> str | None:
+    """Return the cached instruction string from the last registered request."""
+
+    try:
+        from ccproxy.core.request_context import RequestContext
+
+        ctx = RequestContext.get_current()
+        if ctx is not None:
+            formatter_state = ctx.metadata.get("formatter_state", {})
+            instructions = formatter_state.get("instructions")
+            if isinstance(instructions, str) and instructions.strip():
+                return instructions.strip()
+    except Exception:
+        pass
+
+    return _INSTRUCTIONS_VAR.get()
+
+
+def register_request_tools(tools: list[Any] | None) -> None:
+    """Cache request tool definitions for downstream streaming responses."""
+
+    normalized = list(tools) if tools else None
+    _TOOLS_VAR.set(normalized)
+
+    try:
+        from ccproxy.core.request_context import RequestContext
+
+        ctx = RequestContext.get_current()
+        if ctx is not None:
+            formatter_state = ctx.metadata.setdefault("formatter_state", {})
+            if normalized is None:
+                formatter_state.pop("tools", None)
+            else:
+                formatter_state["tools"] = normalized
+    except Exception:
+        pass
+
+
+def get_last_request_tools() -> list[Any] | None:
+    """Return cached request tool definitions, if any."""
+
+    try:
+        from ccproxy.core.request_context import RequestContext
+
+        ctx = RequestContext.get_current()
+        if ctx is not None:
+            formatter_state = ctx.metadata.get("formatter_state", {})
+            tools = formatter_state.get("tools")
+            if isinstance(tools, list):
+                return list(tools)
+    except Exception:
+        pass
+
+    cached = _TOOLS_VAR.get()
+    return list(cached) if cached else None

ccproxy/llms/formatters/mapping.py

@@ -0,0 +1,33 @@
+"""Compatibility layer for adapter mapping utilities.
+
+This shim was previously used to re-export usage converters that have now been
+inlined into their respective adapter helpers. It now only re-exports constants
+and error conversion utilities that remain shared.
+"""
+
+from __future__ import annotations
+
+from ccproxy.llms.formatters.anthropic_to_openai import (
+    convert__anthropic_to_openai__error,
+)
+from ccproxy.llms.formatters.constants import (
+    ANTHROPIC_TO_OPENAI_ERROR_TYPE,
+    ANTHROPIC_TO_OPENAI_FINISH_REASON,
+    DEFAULT_MAX_TOKENS,
+    OPENAI_TO_ANTHROPIC_ERROR_TYPE,
+    OPENAI_TO_ANTHROPIC_STOP_REASON,
+)
+from ccproxy.llms.formatters.openai_to_anthropic import (
+    convert__openai_to_anthropic__error,
+)
+
+
+__all__ = [
+    "ANTHROPIC_TO_OPENAI_ERROR_TYPE",
+    "ANTHROPIC_TO_OPENAI_FINISH_REASON",
+    "DEFAULT_MAX_TOKENS",
+    "OPENAI_TO_ANTHROPIC_ERROR_TYPE",
+    "OPENAI_TO_ANTHROPIC_STOP_REASON",
+    "convert__anthropic_to_openai__error",
+    "convert__openai_to_anthropic__error",
+]

ccproxy/llms/formatters/openai_to_anthropic/__init__.py

@@ -0,0 +1,55 @@
+"""Facade module exposing OpenAI→Anthropic formatter entry points."""
+
+import sys
+from types import ModuleType
+
+from . import streams as _streams
+from .errors import convert__openai_to_anthropic__error
+from .requests import (
+    convert__openai_chat_to_anthropic_message__request,
+    convert__openai_responses_to_anthropic_message__request,
+)
+from .responses import (
+    convert__openai_chat_to_anthropic_messages__response,
+    convert__openai_responses_to_anthropic_message__response,
+    convert__openai_responses_usage_to_anthropic__usage,
+    convert__openai_responses_usage_to_openai_completion__usage,
+)
+from .streams import (
+    OpenAIChatToAnthropicStreamAdapter,
+    OpenAIResponsesToAnthropicStreamAdapter,
+    convert__openai_chat_to_anthropic_messages__stream,
+    convert__openai_responses_to_anthropic_messages__stream,
+)
+
+
+__all__ = [
+    "convert__openai_to_anthropic__error",
+    "convert__openai_chat_to_anthropic_message__request",
+    "convert__openai_responses_to_anthropic_message__request",
+    "convert__openai_chat_to_anthropic_messages__response",
+    "convert__openai_responses_to_anthropic_message__response",
+    "convert__openai_responses_usage_to_anthropic__usage",
+    "convert__openai_responses_usage_to_openai_completion__usage",
+    "OpenAIChatToAnthropicStreamAdapter",
+    "OpenAIResponsesToAnthropicStreamAdapter",
+    "convert__openai_chat_to_anthropic_messages__stream",
+    "convert__openai_responses_to_anthropic_messages__stream",
+]
+
+
+class _OpenAIToAnthropicModule(ModuleType):
+    _propagated_names = {
+        "OpenAIChatToAnthropicStreamAdapter",
+        "OpenAIResponsesToAnthropicStreamAdapter",
+    }
+
+    def __setattr__(self, name: str, value: object) -> None:
+        super().__setattr__(name, value)
+        if name in self._propagated_names and hasattr(_streams, name):
+            setattr(_streams, name, value)
+
+
+_module = sys.modules[__name__]
+if not isinstance(_module, _OpenAIToAnthropicModule):
+    _module.__class__ = _OpenAIToAnthropicModule

ccproxy/llms/formatters/openai_to_anthropic/_helpers.py

@@ -0,0 +1,141 @@
+"""Shared helper utilities for OpenAI→Anthropic formatters."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+from ccproxy.llms.formatters.utils import strict_parse_tool_arguments
+from ccproxy.llms.models import openai as openai_models
+
+
+def _to_mapping(value: Any) -> Mapping[str, Any] | None:
+    if isinstance(value, Mapping):
+        return value
+    if hasattr(value, "model_dump"):
+        dumped = value.model_dump()
+        if isinstance(dumped, Mapping):
+            return dumped
+    return None
+
+
+def _normalize_text_and_images(
+    content: Any,
+) -> tuple[list[str], list[dict[str, Any]]]:
+    text_parts: list[str] = []
+    image_blocks: list[dict[str, Any]] = []
+
+    if not isinstance(content, list):
+        return text_parts, image_blocks
+
+    for part in content:
+        mapping = _to_mapping(part)
+        if not mapping:
+            continue
+        part_type = str(mapping.get("type", "")).lower()
+        if part_type in {"text", "input_text"}:
+            text_val = mapping.get("text")
+            if isinstance(text_val, str) and text_val:
+                text_parts.append(text_val)
+        elif part_type == "image_url":
+            image_info = mapping.get("image_url")
+            image_map = _to_mapping(image_info)
+            if not image_map:
+                continue
+            url = image_map.get("url")
+            if isinstance(url, str) and url.startswith("data:"):
+                try:
+                    header, b64data = url.split(",", 1)
+                    mediatype = header.split(";")[0].split(":", 1)[1]
+                except (ValueError, IndexError):
+                    continue
+                image_blocks.append(
+                    {
+                        "type": "image",
+                        "source": {
+                            "type": "base64",
+                            "media_type": mediatype,
+                            "data": b64data,
+                        },
+                    }
+                )
+
+    return text_parts, image_blocks
+
+
+def _stringify_content(content: Any) -> str:
+    if content is None:
+        return ""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        text_parts, _ = _normalize_text_and_images(content)
+        return " ".join(text_parts)
+    return str(content)
+
+
+def _coerce_system_content(content: Any) -> str | None:
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        text_parts, _ = _normalize_text_and_images(content)
+        return " ".join(text_parts) if text_parts else None
+    return None
+
+
+def _build_user_blocks(content: Any) -> str | list[dict[str, Any]] | None:
+    if content is None:
+        return None
+    if isinstance(content, str):
+        return content
+
+    text_parts, image_blocks = _normalize_text_and_images(content)
+
+    if not text_parts and not image_blocks:
+        return ""
+
+    blocks: list[dict[str, Any]] = []
+    if text_parts:
+        blocks.append({"type": "text", "text": " ".join(text_parts)})
+    blocks.extend(image_blocks)
+
+    if len(blocks) == 1 and blocks[0]["type"] == "text":
+        return str(blocks[0]["text"])
+    return blocks
+
+
+def _build_assistant_blocks(
+    content: Any, tool_calls: list[openai_models.ToolCall] | None
+) -> list[dict[str, Any]]:
+    blocks: list[dict[str, Any]] = []
+
+    normalized_content = _build_user_blocks(content)
+    if isinstance(normalized_content, str):
+        text = normalized_content.strip()
+        if text:
+            blocks.append({"type": "text", "text": text})
+    elif isinstance(normalized_content, list):
+        blocks.extend(normalized_content)
+
+    for call in tool_calls or []:
+        args_dict = strict_parse_tool_arguments(call.function.arguments)
+        blocks.append(
+            {
+                "type": "tool_use",
+                "id": call.id,
+                "name": call.function.name,
+                "input": args_dict,
+            }
+        )
+
+    return blocks
+
+
+__all__ = [
+    "_to_mapping",
+    "_normalize_text_and_images",
+    "_stringify_content",
+    "_coerce_system_content",
+    "_build_user_blocks",
+    "_build_assistant_blocks",
+]

ccproxy/llms/formatters/openai_to_anthropic/errors.py

@@ -0,0 +1,53 @@
+"""OpenAI→Anthropic error conversion entry point."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from ccproxy.llms.formatters.constants import OPENAI_TO_ANTHROPIC_ERROR_TYPE
+from ccproxy.llms.models import anthropic as anthropic_models
+from ccproxy.llms.models import openai as openai_models
+
+
+def convert__openai_to_anthropic__error(error: BaseModel) -> BaseModel:
+    """Convert an OpenAI error payload to the Anthropic envelope."""
+    if isinstance(error, openai_models.ErrorResponse):
+        openai_error = error.error
+        error_message = openai_error.message
+        openai_error_type = openai_error.type or "api_error"
+        anthropic_error_type = OPENAI_TO_ANTHROPIC_ERROR_TYPE.get(
+            openai_error_type, "api_error"
+        )
+
+        if anthropic_error_type == "invalid_request_error":
+            anthropic_error: anthropic_models.ErrorType = (
+                anthropic_models.InvalidRequestError(message=error_message)
+            )
+        elif anthropic_error_type == "rate_limit_error":
+            anthropic_error = anthropic_models.RateLimitError(message=error_message)
+        else:
+            anthropic_error = anthropic_models.APIError(message=error_message)
+
+        return anthropic_models.ErrorResponse(error=anthropic_error)
+
+    if hasattr(error, "error") and hasattr(error.error, "message"):
+        error_message = error.error.message
+        fallback_error: anthropic_models.ErrorType = anthropic_models.APIError(
+            message=error_message
+        )
+        return anthropic_models.ErrorResponse(error=fallback_error)
+
+    error_message = "Unknown error occurred"
+    if hasattr(error, "message"):
+        error_message = error.message
+    elif hasattr(error, "model_dump"):
+        error_dict = error.model_dump()
+        error_message = str(error_dict.get("message", error_dict))
+
+    generic_error: anthropic_models.ErrorType = anthropic_models.APIError(
+        message=error_message
+    )
+    return anthropic_models.ErrorResponse(error=generic_error)
+
+
+__all__ = ["convert__openai_to_anthropic__error"]