ccproxy-api 0.2.0a4__tar.gz → 0.2.3__tar.gz

{ccproxy_api-0.2.0a4 → ccproxy_api-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ccproxy-api
-Version: 0.2.0a4
+Version: 0.2.3
 Summary: API server that provides an Anthropic and OpenAI compatible interface over Claude Code, allowing to use your Claude OAuth account or over the API.
 License-File: LICENSE
 Requires-Python: >=3.11
@@ -20,6 +20,7 @@ Requires-Dist: typing-extensions>=4.0.0
 Requires-Dist: uvicorn>=0.34.0
 Provides-Extra: plugins-claude
 Requires-Dist: claude-agent-sdk>=0.1.0; extra == 'plugins-claude'
+Requires-Dist: keyring>=25.0.0; extra == 'plugins-claude'
 Requires-Dist: qrcode>=8.2; extra == 'plugins-claude'
 Provides-Extra: plugins-codex
 Requires-Dist: pyjwt>=2.10.1; extra == 'plugins-codex'
@@ -196,14 +197,14 @@ To install the latest stable release without cloning the repository, use `uvx`
 to grab the published wheel and launch the CLI:
 
 ```bash
-uvx --with "ccproxy-api[all]==0.2.0" ccproxy serve --port 8000
+uvx --with "ccproxy-api[all]" ccproxy serve --port 8000
 ```
 
 If you prefer `pipx`, install the package (optionally with extras) and use the
 local shim:
 
 ```bash
-pipx install "ccproxy-api[all]==0.2.0"
+pipx install "ccproxy-api[all]"
 ccproxy serve  # default on localhost:8000
 ```
 

{ccproxy_api-0.2.0a4 → ccproxy_api-0.2.3}/README.md

@@ -156,14 +156,14 @@ To install the latest stable release without cloning the repository, use `uvx`
 to grab the published wheel and launch the CLI:
 
 ```bash
-uvx --with "ccproxy-api[all]==0.2.0" ccproxy serve --port 8000
+uvx --with "ccproxy-api[all]" ccproxy serve --port 8000
 ```
 
 If you prefer `pipx`, install the package (optionally with extras) and use the
 local shim:
 
 ```bash
-pipx install "ccproxy-api[all]==0.2.0"
+pipx install "ccproxy-api[all]"
 ccproxy serve  # default on localhost:8000
 ```
 

{ccproxy_api-0.2.0a4 → ccproxy_api-0.2.3}/ccproxy/core/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.0a4'
-__version_tuple__ = version_tuple = (0, 2, 0, 'a4')
+__version__ = version = '0.2.3'
+__version_tuple__ = version_tuple = (0, 2, 3)
 
 __commit_id__ = commit_id = None

ccproxy_api-0.2.3/ccproxy/llms/formatters/anthropic_to_openai/_helpers.py

@@ -0,0 +1,44 @@
+"""Shared helpers for Anthropic to OpenAI formatting."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from ccproxy.llms.models import openai as openai_models
+
+
+def serialize_tool_arguments(tool_input: Any) -> str:
+    if isinstance(tool_input, str):
+        return tool_input
+    try:
+        return json.dumps(tool_input, ensure_ascii=False)
+    except Exception:
+        return json.dumps({"arguments": str(tool_input)})
+
+
+def build_openai_tool_call(
+    *,
+    tool_id: str | None,
+    tool_name: str | None,
+    tool_input: Any,
+    arguments: Any = None,
+    fallback_index: int = 0,
+) -> openai_models.ToolCall:
+    args_str = (
+        arguments
+        if isinstance(arguments, str) and arguments
+        else serialize_tool_arguments(tool_input)
+    )
+    call_id = (
+        tool_id if isinstance(tool_id, str) and tool_id else f"call_{fallback_index}"
+    )
+    name = tool_name if isinstance(tool_name, str) and tool_name else "function"
+
+    return openai_models.ToolCall(
+        id=str(call_id),
+        function=openai_models.FunctionCall(
+            name=str(name),
+            arguments=str(args_str),
+        ),
+    )

{ccproxy_api-0.2.0a4 → ccproxy_api-0.2.3}/ccproxy/llms/formatters/anthropic_to_openai/responses.py

@@ -14,6 +14,8 @@ from ccproxy.llms.formatters.constants import ANTHROPIC_TO_OPENAI_FINISH_REASON
 from ccproxy.llms.models import anthropic as anthropic_models
 from ccproxy.llms.models import openai as openai_models
 
+from ._helpers import build_openai_tool_call
+
 
 logger = ccproxy.core.logging.get_logger(__name__)
 
@@ -101,6 +103,8 @@ def convert__anthropic_message_to_openai_chat__response(
     """Convert Anthropic MessageResponse to an OpenAI ChatCompletionResponse."""
     content_blocks = response.content
     parts: list[str] = []
+    tool_calls: list[openai_models.ToolCall] = []
+
     for block in content_blocks:
         btype = getattr(block, "type", None)
         if btype == "text":
@@ -117,8 +121,17 @@ def convert__anthropic_message_to_openai_chat__response(
                     else ""
                 )
                 parts.append(f"<thinking{sig_attr}>{thinking}</thinking>")
+        elif btype == "tool_use":
+            tool_calls.append(
+                build_openai_tool_call(
+                    tool_id=getattr(block, "id", None),
+                    tool_name=getattr(block, "name", None),
+                    tool_input=getattr(block, "input", {}) or {},
+                    fallback_index=len(tool_calls),
+                )
+            )
 
-    content_text = "".join(parts)
+    content_text = "".join(parts) if parts else None
 
     stop_reason = response.stop_reason
     finish_reason = ANTHROPIC_TO_OPENAI_FINISH_REASON.get(
@@ -127,12 +140,16 @@ def convert__anthropic_message_to_openai_chat__response(
 
     usage_model = convert__anthropic_usage_to_openai_completion__usage(response.usage)
 
+    message_dict: dict[str, Any] = {"role": "assistant", "content": content_text}
+    if tool_calls:
+        message_dict["tool_calls"] = [call.model_dump() for call in tool_calls]
+
     payload = {
         "id": response.id,
         "choices": [
             {
                 "index": 0,
-                "message": {"role": "assistant", "content": content_text},
+                "message": message_dict,
                 "finish_reason": finish_reason,
             }
         ],

{ccproxy_api-0.2.0a4 → ccproxy_api-0.2.3}/ccproxy/llms/formatters/anthropic_to_openai/streams.py

@@ -27,10 +27,9 @@ from ccproxy.llms.models import anthropic as anthropic_models
 from ccproxy.llms.models import openai as openai_models
 from ccproxy.llms.streaming.accumulators import ClaudeAccumulator
 
+from ._helpers import build_openai_tool_call
 from .requests import _build_responses_payload_from_anthropic_request
-from .responses import (
-    convert__anthropic_usage_to_openai_responses__usage,
-)
+from .responses import convert__anthropic_usage_to_openai_responses__usage
 
 
 logger = ccproxy.core.logging.get_logger(__name__)
@@ -100,22 +99,15 @@ def _build_openai_tool_call(
         function_payload = (
             tool_call.get("function", {}) if isinstance(tool_call, dict) else {}
         )
-        name = function_payload.get("name") or tool_call.get("name") or "function"
+        tool_name = function_payload.get("name") or tool_call.get("name")
         arguments = function_payload.get("arguments")
-        if not isinstance(arguments, str) or not arguments:
-            try:
-                arguments = json.dumps(tool_call.get("input", {}), ensure_ascii=False)
-            except Exception:
-                arguments = json.dumps(tool_call.get("input", {}))
-
-        tool_id = tool_call.get("id") or f"call_{block_index}"
 
-        return openai_models.ToolCall(
-            id=str(tool_id),
-            function=openai_models.FunctionCall(
-                name=str(name),
-                arguments=str(arguments),
-            ),
+        return build_openai_tool_call(
+            tool_id=tool_call.get("id"),
+            tool_name=tool_name,
+            tool_input=tool_call.get("input", {}),
+            arguments=arguments,
+            fallback_index=block_index,
         )
 
     return None

{ccproxy_api-0.2.0a4 → ccproxy_api-0.2.3}/ccproxy/plugins/claude_api/adapter.py

@@ -85,6 +85,11 @@ class ClaudeAPIAdapter(BaseHTTPAdapter):
         # Always set Authorization from OAuth-managed access token
         filtered_headers["authorization"] = f"Bearer {token_value}"
 
+        # PATCH: Add Computer Use beta headers for Anthropic API
+        # These are required for browser automation tools to work
+        filtered_headers["anthropic-version"] = "2023-06-01"
+        filtered_headers["anthropic-beta"] = "computer-use-2025-01-24"
+
         # Add CLI headers if available, but never allow overriding auth
         cli_headers = self._collect_cli_headers()
         if cli_headers:

{ccproxy_api-0.2.0a4 → ccproxy_api-0.2.3}/ccproxy/plugins/oauth_claude/storage.py

@@ -15,6 +15,77 @@ from .models import ClaudeCredentials, ClaudeProfileInfo
 logger = get_plugin_logger()
 
 
+# Keychain service name used by Claude Code
+KEYCHAIN_SERVICE = "Claude Code"
+KEYCHAIN_ACCOUNT = "credentials"
+
+
+def _is_keyring_available() -> bool:
+    """Check if keyring library is available."""
+    try:
+        import keyring  # noqa: F401
+
+        return True
+    except ImportError:
+        return False
+
+
+async def _read_from_keychain() -> dict[str, Any] | None:
+    """Read Claude credentials from system keychain.
+
+    Claude Code stores OAuth credentials in the system keychain and intentionally
+    deletes the plain text ~/.claude/.credentials.json file for security.
+    See: https://github.com/anthropics/claude-code/issues/1414
+
+    Uses the keyring library which supports:
+    - macOS Keychain
+    - Windows Credential Manager
+    - Linux Secret Service (GNOME Keyring, KDE Wallet)
+
+    Returns:
+        Parsed credentials dict or None if not found or keyring unavailable
+    """
+    if not _is_keyring_available():
+        logger.debug(
+            "keyring_not_available",
+            hint="Install keyring package for system keychain support",
+            category="auth",
+        )
+        return None
+
+    def read_keychain() -> dict[str, Any] | None:
+        try:
+            import keyring
+
+            password = keyring.get_password(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT)
+            if password:
+                parsed = json.loads(password)
+                if isinstance(parsed, dict):
+                    return parsed
+                logger.debug(
+                    "keychain_invalid_format",
+                    expected="dict",
+                    got=type(parsed).__name__,
+                    category="auth",
+                )
+        except json.JSONDecodeError as e:
+            logger.debug(
+                "keychain_json_decode_error",
+                error=str(e),
+                category="auth",
+            )
+        except Exception as e:
+            logger.debug(
+                "keychain_read_error",
+                error=str(e),
+                error_type=type(e).__name__,
+                category="auth",
+            )
+        return None
+
+    return await asyncio.to_thread(read_keychain)
+
+
 class ClaudeOAuthStorage(BaseJsonStorage[ClaudeCredentials]):
     """Claude OAuth-specific token storage implementation."""
 
@@ -61,24 +132,48 @@ class ClaudeOAuthStorage(BaseJsonStorage[ClaudeCredentials]):
             return False
 
     async def load(self) -> ClaudeCredentials | None:
-        """Load Claude credentials.
+        """Load Claude credentials from file or system keychain.
+
+        Claude Code stores credentials in the system keychain and intentionally
+        deletes the plain text file for security. This method tries file first,
+        then falls back to the system keychain (macOS Keychain, Windows Credential
+        Manager, or Linux Secret Service).
 
         Returns:
             Stored credentials or None
         """
         try:
-            # Use parent class's read method
+            # Try file first (works on all platforms, manual setups)
             data = await self._read_json()
-            if not data:
-                return None
+            if data:
+                credentials = ClaudeCredentials.model_validate(data)
+                logger.debug(
+                    "claude_oauth_credentials_loaded",
+                    has_oauth=bool(credentials.claude_ai_oauth),
+                    source="file",
+                    category="auth",
+                )
+                return credentials
+
+            # Fallback to system keychain (where Claude Code stores credentials)
+            keychain_data = await _read_from_keychain()
+            if keychain_data:
+                credentials = ClaudeCredentials.model_validate(keychain_data)
+                logger.debug(
+                    "claude_oauth_credentials_loaded",
+                    has_oauth=bool(credentials.claude_ai_oauth),
+                    source="keychain",
+                    category="auth",
+                )
+                return credentials
 
-            credentials = ClaudeCredentials.model_validate(data)
             logger.debug(
-                "claude_oauth_credentials_loaded",
-                has_oauth=bool(credentials.claude_ai_oauth),
+                "claude_oauth_credentials_not_found",
+                checked_file=str(self.file_path),
+                checked_keychain=_is_keyring_available(),
                 category="auth",
             )
-            return credentials
+            return None
         except Exception as e:
             logger.error(
                 "claude_oauth_credentials_load_error",

{ccproxy_api-0.2.0a4 → ccproxy_api-0.2.3}/pyproject.toml

@@ -92,10 +92,11 @@ dev = [
   "bandit",
   "types-aiofiles>=24.0.0",
   "types-PyYAML>=6.0.12.12",
+  "keyring>=25.0.0",
 ]
 
 [project.optional-dependencies]
-plugins-claude = ["claude-agent-sdk>=0.1.0", "qrcode>=8.2"]
+plugins-claude = ["claude-agent-sdk>=0.1.0", "qrcode>=8.2", "keyring>=25.0.0"]
 plugins-codex = ["qrcode>=8.2", "pyjwt>=2.10.1"]
 plugins-storage = [
   "sqlmodel>=0.0.24",