code-puppy 0.0.350__tar.gz → 0.0.352__tar.gz

{code_puppy-0.0.350 → code_puppy-0.0.352}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.350
+Version: 0.0.352
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy

{code_puppy-0.0.350 → code_puppy-0.0.352}/code_puppy/claude_cache_client.py

@@ -5,6 +5,11 @@ ClaudeCacheAsyncClient: httpx client that tries to patch /v1/messages bodies.
 We now also expose `patch_anthropic_client_messages` which monkey-patches
 AsyncAnthropic.messages.create() so we can inject cache_control BEFORE
 serialization, avoiding httpx/Pydantic internals.
+
+This module also handles:
+- Tool name prefixing/unprefixing for Claude Code OAuth compatibility
+- Header transformations (anthropic-beta, user-agent)
+- URL modifications (adding ?beta=true query param)
 """
 
 from __future__ import annotations
@@ -12,8 +17,10 @@ from __future__ import annotations
 import base64
 import json
 import logging
+import re
 import time
 from typing import Any, Callable, MutableMapping
+from urllib.parse import parse_qs, urlencode, urlparse, urlunparse
 
 import httpx
 
@@ -22,6 +29,13 @@ logger = logging.getLogger(__name__)
 # Refresh token if it's older than 1 hour (3600 seconds)
 TOKEN_MAX_AGE_SECONDS = 3600
 
+# Tool name prefix for Claude Code OAuth compatibility
+# Tools are prefixed on outgoing requests and unprefixed on incoming responses
+TOOL_PREFIX = "cp_"
+
+# User-Agent to send with Claude Code OAuth requests
+CLAUDE_CLI_USER_AGENT = "claude-cli/2.1.2 (external, cli)"
+
 try:
     from anthropic import AsyncAnthropic
 except ImportError:  # pragma: no cover - optional dep
@@ -29,6 +43,22 @@ except ImportError:  # pragma: no cover - optional dep
 
 
 class ClaudeCacheAsyncClient(httpx.AsyncClient):
+    """Async HTTP client with Claude Code OAuth transformations.
+
+    Handles:
+    - Cache control injection for prompt caching
+    - Tool name prefixing on outgoing requests
+    - Tool name unprefixing on incoming streaming responses
+    - Header transformations (anthropic-beta, user-agent)
+    - URL modifications (adding ?beta=true)
+    - Proactive token refresh
+    """
+
+    # Regex pattern for unprefixing tool names in streaming responses
+    _TOOL_UNPREFIX_PATTERN = re.compile(
+        rf'"name"\s*:\s*"{re.escape(TOOL_PREFIX)}([^"]+)"'
+    )
+
     def _get_jwt_age_seconds(self, token: str | None) -> float | None:
         """Decode a JWT and return its age in seconds.
 
@@ -107,9 +137,100 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
             )
         return should_refresh
 
+    @staticmethod
+    def _prefix_tool_names(body: bytes) -> bytes | None:
+        """Prefix all tool names in the request body with TOOL_PREFIX.
+
+        This is required for Claude Code OAuth compatibility - tools must be
+        prefixed on outgoing requests and unprefixed on incoming responses.
+        """
+        try:
+            data = json.loads(body.decode("utf-8"))
+        except Exception:
+            return None
+
+        if not isinstance(data, dict):
+            return None
+
+        tools = data.get("tools")
+        if not isinstance(tools, list) or not tools:
+            return None
+
+        modified = False
+        for tool in tools:
+            if isinstance(tool, dict) and "name" in tool:
+                name = tool["name"]
+                if name and not name.startswith(TOOL_PREFIX):
+                    tool["name"] = f"{TOOL_PREFIX}{name}"
+                    modified = True
+
+        if not modified:
+            return None
+
+        return json.dumps(data).encode("utf-8")
+
+    def _unprefix_tool_names_in_text(self, text: str) -> str:
+        """Remove TOOL_PREFIX from tool names in streaming response text."""
+        return self._TOOL_UNPREFIX_PATTERN.sub(r'"name": "\1"', text)
+
+    @staticmethod
+    def _transform_headers_for_claude_code(
+        headers: MutableMapping[str, str],
+    ) -> None:
+        """Transform headers for Claude Code OAuth compatibility.
+
+        - Sets user-agent to claude-cli
+        - Merges anthropic-beta headers appropriately
+        - Removes x-api-key (using Bearer auth instead)
+        """
+        # Set user-agent
+        headers["user-agent"] = CLAUDE_CLI_USER_AGENT
+
+        # Handle anthropic-beta header
+        incoming_beta = headers.get("anthropic-beta", "")
+        incoming_betas = [b.strip() for b in incoming_beta.split(",") if b.strip()]
+
+        # Check if claude-code beta was explicitly requested
+        include_claude_code = "claude-code-20250219" in incoming_betas
+
+        # Build merged betas list
+        merged_betas = [
+            "oauth-2025-04-20",
+            "interleaved-thinking-2025-05-14",
+        ]
+        if include_claude_code:
+            merged_betas.append("claude-code-20250219")
+
+        headers["anthropic-beta"] = ",".join(merged_betas)
+
+        # Remove x-api-key if present (we use Bearer auth)
+        for key in ["x-api-key", "X-API-Key", "X-Api-Key"]:
+            if key in headers:
+                del headers[key]
+
+    @staticmethod
+    def _add_beta_query_param(url: httpx.URL) -> httpx.URL:
+        """Add ?beta=true query parameter to the URL if not already present."""
+        # Parse the URL
+        parsed = urlparse(str(url))
+        query_params = parse_qs(parsed.query)
+
+        # Only add if not already present
+        if "beta" not in query_params:
+            query_params["beta"] = ["true"]
+            # Rebuild query string
+            new_query = urlencode(query_params, doseq=True)
+            # Rebuild URL
+            new_parsed = parsed._replace(query=new_query)
+            return httpx.URL(urlunparse(new_parsed))
+
+        return url
+
     async def send(
         self, request: httpx.Request, *args: Any, **kwargs: Any
     ) -> httpx.Response:  # type: ignore[override]
+        is_messages_endpoint = request.url.path.endswith("/v1/messages")
+
         # Proactive token refresh: check JWT age before every request
         if not request.extensions.get("claude_oauth_refresh_attempted"):
             try:
@@ -131,50 +252,88 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
             except Exception as exc:
                 logger.debug("Error during proactive token refresh check: %s", exc)
 
-        try:
-            if request.url.path.endswith("/v1/messages"):
+        # Apply Claude Code OAuth transformations for /v1/messages
+        if is_messages_endpoint:
+            try:
                 body_bytes = self._extract_body_bytes(request)
+                headers = dict(request.headers)
+                url = request.url
+                body_modified = False
+                headers_modified = False
+
+                # 1. Transform headers for Claude Code OAuth
+                self._transform_headers_for_claude_code(headers)
+                headers_modified = True
+
+                # 2. Add ?beta=true query param
+                url = self._add_beta_query_param(url)
+
+                # 3. Prefix tool names in request body
                 if body_bytes:
-                    updated = self._inject_cache_control(body_bytes)
-                    if updated is not None:
-                        # Rebuild a request with the updated body and transplant internals
-                        try:
-                            rebuilt = self.build_request(
-                                method=request.method,
-                                url=request.url,
-                                headers=request.headers,
-                                content=updated,
-                            )
-
-                            # Copy core internals so httpx uses the modified body/stream
-                            if hasattr(rebuilt, "_content"):
-                                setattr(request, "_content", rebuilt._content)  # type: ignore[attr-defined]
-                            if hasattr(rebuilt, "stream"):
-                                request.stream = rebuilt.stream
-                            if hasattr(rebuilt, "extensions"):
-                                request.extensions = rebuilt.extensions
-
-                            # Ensure Content-Length matches the new body
-                            request.headers["Content-Length"] = str(len(updated))
-
-                        except Exception:
-                            # Swallow instrumentation errors; do not break real calls.
-                            pass
-        except Exception:
-            # Swallow wrapper errors; do not break real calls.
-            pass
+                    prefixed_body = self._prefix_tool_names(body_bytes)
+                    if prefixed_body is not None:
+                        body_bytes = prefixed_body
+                        body_modified = True
+
+                    # 4. Inject cache_control
+                    cached_body = self._inject_cache_control(body_bytes)
+                    if cached_body is not None:
+                        body_bytes = cached_body
+                        body_modified = True
+
+                # Rebuild request if anything changed
+                if body_modified or headers_modified or url != request.url:
+                    try:
+                        rebuilt = self.build_request(
+                            method=request.method,
+                            url=url,
+                            headers=headers,
+                            content=body_bytes,
+                        )
+
+                        # Copy core internals so httpx uses the modified body/stream
+                        if hasattr(rebuilt, "_content"):
+                            setattr(request, "_content", rebuilt._content)  # type: ignore[attr-defined]
+                        if hasattr(rebuilt, "stream"):
+                            request.stream = rebuilt.stream
+                        if hasattr(rebuilt, "extensions"):
+                            request.extensions = rebuilt.extensions
+
+                        # Update URL
+                        request.url = url
+
+                        # Update headers
+                        for key, value in headers.items():
+                            request.headers[key] = value
+
+                        # Ensure Content-Length matches the new body
+                        if body_bytes:
+                            request.headers["Content-Length"] = str(len(body_bytes))
+
+                    except Exception as exc:
+                        logger.debug("Error rebuilding request: %s", exc)
+
+            except Exception as exc:
+                logger.debug("Error in Claude Code transformations: %s", exc)
+
+        # Send the request
         response = await super().send(request, *args, **kwargs)
+
+        # Transform streaming response to unprefix tool names
+        if is_messages_endpoint and response.status_code == 200:
+            try:
+                response = self._wrap_response_with_tool_unprefixing(response, request)
+            except Exception as exc:
+                logger.debug("Error wrapping response for tool unprefixing: %s", exc)
+
+        # Handle auth errors with token refresh
         try:
-            # Check for both 401 and 400 - Anthropic/Cloudflare may return 400 for auth errors
-            # Also check if it's a Cloudflare HTML error response
             if response.status_code in (400, 401) and not request.extensions.get(
                 "claude_oauth_refresh_attempted"
             ):
-                # Determine if this is an auth error (including Cloudflare HTML errors)
                 is_auth_error = response.status_code == 401
 
                 if response.status_code == 400:
-                    # Check if this is a Cloudflare HTML error
                     is_auth_error = self._is_cloudflare_html_error(response)
                     if is_auth_error:
                         logger.info(
@@ -203,8 +362,64 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
                         logger.warning("Token refresh failed, returning original error")
         except Exception as exc:
             logger.debug("Error during token refresh attempt: %s", exc)
+
         return response
 
+    def _wrap_response_with_tool_unprefixing(
+        self, response: httpx.Response, request: httpx.Request
+    ) -> httpx.Response:
+        """Wrap a streaming response to unprefix tool names.
+
+        Creates a new response with a transformed stream that removes the
+        TOOL_PREFIX from tool names in the response body.
+        """
+        original_stream = response.stream
+        unprefix_fn = self._unprefix_tool_names_in_text
+
+        class UnprefixingStream(httpx.AsyncByteStream):
+            """Async byte stream that unprefixes tool names.
+
+            Inherits from httpx.AsyncByteStream to ensure proper stream interface.
+            """
+
+            def __init__(self, inner_stream: Any) -> None:
+                self._inner = inner_stream
+
+            async def __aiter__(self):
+                async for chunk in self._inner:
+                    if isinstance(chunk, bytes):
+                        text = chunk.decode("utf-8", errors="replace")
+                        text = unprefix_fn(text)
+                        yield text.encode("utf-8")
+                    else:
+                        yield chunk
+
+            async def aclose(self) -> None:
+                if hasattr(self._inner, "aclose"):
+                    try:
+                        result = self._inner.aclose()
+                        # Handle both sync and async aclose
+                        if hasattr(result, "__await__"):
+                            await result
+                    except Exception:
+                        pass  # Ignore close errors
+                elif hasattr(self._inner, "close"):
+                    try:
+                        self._inner.close()
+                    except Exception:
+                        pass
+
+        # Create a new response with the transformed stream
+        # Must include request for raise_for_status() to work
+        new_response = httpx.Response(
+            status_code=response.status_code,
+            headers=response.headers,
+            stream=UnprefixingStream(original_stream),
+            extensions=response.extensions,
+            request=request,
+        )
+        return new_response
+
     @staticmethod
     def _extract_body_bytes(request: httpx.Request) -> bytes | None:
         # Try public content first

{code_puppy-0.0.350 → code_puppy-0.0.352}/code_puppy/plugins/antigravity_oauth/antigravity_model.py

@@ -215,9 +215,39 @@ class AntigravityModel(GoogleModel):
         response = await client.post(url, json=body)
 
         if response.status_code != 200:
-            raise RuntimeError(
-                f"Antigravity API Error {response.status_code}: {response.text}"
-            )
+            # Check for corrupted thought signature error and retry
+            # Error 400: { error: { code: 400, message: Corrupted thought signature., status: INVALID_ARGUMENT } }
+            error_text = response.text
+            if (
+                response.status_code == 400
+                and "Corrupted thought signature" in error_text
+            ):
+                logger.warning(
+                    "Received 400 Corrupted thought signature. Backfilling signatures and retrying."
+                )
+                _backfill_thought_signatures(messages)
+
+                # Re-map messages
+                system_instruction, contents = await self._map_messages(
+                    messages, model_request_parameters
+                )
+
+                # Update body
+                body["contents"] = contents
+                if system_instruction:
+                    body["systemInstruction"] = system_instruction
+
+                # Retry request
+                response = await client.post(url, json=body)
+                # Check error again after retry
+                if response.status_code != 200:
+                    raise RuntimeError(
+                        f"Antigravity API Error {response.status_code}: {response.text}"
+                    )
+            else:
+                raise RuntimeError(
+                    f"Antigravity API Error {response.status_code}: {error_text}"
+                )
 
         data = response.json()
 
@@ -318,24 +348,56 @@ class AntigravityModel(GoogleModel):
 
         # Create async generator for SSE events
         async def stream_chunks() -> AsyncIterator[dict[str, Any]]:
-            async with client.stream("POST", url, json=body) as response:
-                if response.status_code != 200:
-                    text = await response.aread()
-                    raise RuntimeError(
-                        f"Antigravity API Error {response.status_code}: {text.decode()}"
-                    )
+            retry_count = 0
+            while retry_count < 2:
+                should_retry = False
+                async with client.stream("POST", url, json=body) as response:
+                    if response.status_code != 200:
+                        text = await response.aread()
+                        error_msg = text.decode()
+                        if (
+                            response.status_code == 400
+                            and "Corrupted thought signature" in error_msg
+                            and retry_count == 0
+                        ):
+                            should_retry = True
+                        else:
+                            raise RuntimeError(
+                                f"Antigravity API Error {response.status_code}: {error_msg}"
+                            )
 
-                async for line in response.aiter_lines():
-                    line = line.strip()
-                    if not line:
-                        continue
-                    if line.startswith("data: "):
-                        json_str = line[6:]  # Remove 'data: ' prefix
-                        if json_str:
-                            try:
-                                yield json.loads(json_str)
-                            except json.JSONDecodeError:
+                    if not should_retry:
+                        async for line in response.aiter_lines():
+                            line = line.strip()
+                            if not line:
                                 continue
+                            if line.startswith("data: "):
+                                json_str = line[6:]  # Remove 'data: ' prefix
+                                if json_str:
+                                    try:
+                                        yield json.loads(json_str)
+                                    except json.JSONDecodeError:
+                                        continue
+                        return
+
+                # Handle retry outside the context manager
+                if should_retry:
+                    logger.warning(
+                        "Received 400 Corrupted thought signature in stream. Backfilling and retrying."
+                    )
+                    _backfill_thought_signatures(messages)
+
+                    # Re-map messages
+                    system_instruction, contents = await self._map_messages(
+                        messages, model_request_parameters
+                    )
+
+                    # Update body in place
+                    body["contents"] = contents
+                    if system_instruction:
+                        body["systemInstruction"] = system_instruction
+
+                    retry_count += 1
 
         # Create streaming response
         streamed = AntigravityStreamingResponse(
@@ -666,3 +728,12 @@ def _antigravity_process_response_from_parts(
         provider_details=vendor_details,
         provider_name=provider_name,
     )
+
+
+def _backfill_thought_signatures(messages: list[ModelMessage]) -> None:
+    """Backfill all thinking parts with the bypass signature."""
+    for m in messages:
+        if isinstance(m, ModelResponse):
+            for part in m.parts:
+                if isinstance(part, ThinkingPart):
+                    object.__setattr__(part, "signature", BYPASS_THOUGHT_SIGNATURE)

{code_puppy-0.0.350 → code_puppy-0.0.352}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.350"
+version = "0.0.352"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.11,<3.14"