code-puppy 0.0.367__tar.gz → 0.0.368__tar.gz

{code_puppy-0.0.367 → code_puppy-0.0.368}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.367
+Version: 0.0.368
 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.367 → code_puppy-0.0.368}/code_puppy/claude_cache_client.py

@@ -119,24 +119,62 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
         return None
 
     def _should_refresh_token(self, request: httpx.Request) -> bool:
-        """Check if the token in the request is older than 1 hour."""
+        """Check if the token should be refreshed (within 1 hour of expiry).
+
+        Uses two strategies:
+        1. Decode JWT to check token age (if possible)
+        2. Fall back to stored expires_at from token file
+
+        Returns True if token expires within TOKEN_MAX_AGE_SECONDS (1 hour).
+        """
         token = self._extract_bearer_token(request)
         if not token:
             return False
 
+        # Strategy 1: Try to decode JWT age
         age = self._get_jwt_age_seconds(token)
-        if age is None:
-            return False
-
-        should_refresh = age >= TOKEN_MAX_AGE_SECONDS
+        if age is not None:
+            should_refresh = age >= TOKEN_MAX_AGE_SECONDS
+            if should_refresh:
+                logger.info(
+                    "JWT token is %.1f seconds old (>= %d), will refresh proactively",
+                    age,
+                    TOKEN_MAX_AGE_SECONDS,
+                )
+            return should_refresh
+
+        # Strategy 2: Fall back to stored expires_at from token file
+        should_refresh = self._check_stored_token_expiry()
         if should_refresh:
             logger.info(
-                "JWT token is %.1f seconds old (>= %d), will refresh proactively",
-                age,
+                "Stored token expires within %d seconds, will refresh proactively",
                 TOKEN_MAX_AGE_SECONDS,
             )
         return should_refresh
 
+    @staticmethod
+    def _check_stored_token_expiry() -> bool:
+        """Check if the stored token expires within TOKEN_MAX_AGE_SECONDS.
+
+        This is a fallback for when JWT decoding fails or isn't available.
+        Uses the expires_at timestamp from the stored token file.
+        """
+        try:
+            from code_puppy.plugins.claude_code_oauth.utils import (
+                is_token_expired,
+                load_stored_tokens,
+            )
+
+            tokens = load_stored_tokens()
+            if not tokens:
+                return False
+
+            # is_token_expired already uses TOKEN_REFRESH_BUFFER_SECONDS (1 hour)
+            return is_token_expired(tokens)
+        except Exception as exc:
+            logger.debug("Error checking stored token expiry: %s", exc)
+            return False
+
     @staticmethod
     def _prefix_tool_names(body: bytes) -> bytes | None:
         """Prefix all tool names in the request body with TOOL_PREFIX.

{code_puppy-0.0.367 → code_puppy-0.0.368}/code_puppy/plugins/claude_code_oauth/utils.py

@@ -21,7 +21,10 @@ from .config import (
     get_token_storage_path,
 )
 
-TOKEN_REFRESH_BUFFER_SECONDS = 60
+# Proactive refresh buffer: refresh tokens 1 hour before expiration
+# This ensures smooth operation by refreshing during model requests,
+# well before the token actually expires
+TOKEN_REFRESH_BUFFER_SECONDS = 3600  # 1 hour
 
 logger = logging.getLogger(__name__)
 

{code_puppy-0.0.367 → code_puppy-0.0.368}/code_puppy/pydantic_patches.py

@@ -121,6 +121,67 @@ def patch_process_message_history() -> None:
         pass
 
 
+def patch_tool_call_json_repair() -> None:
+    """Patch pydantic-ai's _call_tool to auto-repair malformed JSON arguments.
+
+    LLMs sometimes produce slightly broken JSON in tool calls (trailing commas,
+    missing quotes, etc.). This patch intercepts tool calls and runs json_repair
+    on the arguments before validation, preventing unnecessary retries.
+    """
+    try:
+        import json_repair
+        from pydantic_ai._tool_manager import ToolManager
+
+        # Store the original method
+        _original_call_tool = ToolManager._call_tool
+
+        async def _patched_call_tool(
+            self,
+            call,
+            *,
+            allow_partial: bool,
+            wrap_validation_errors: bool,
+            approved: bool,
+        ):
+            """Patched _call_tool that repairs malformed JSON before validation."""
+            # Only attempt repair if args is a string (JSON)
+            if isinstance(call.args, str) and call.args:
+                try:
+                    repaired = json_repair.repair_json(call.args)
+                    if repaired != call.args:
+                        # JSON was repaired! Log and update
+                        try:
+                            from rich.console import Console
+                            console = Console(stderr=True)
+                            console.print(
+                                "[bold yellow]🐕 WOOF! Repaired malformed tool call JSON! AWOOOOOOOOOO![/]"
+                            )
+                        except ImportError:
+                            pass  # No rich console available
+
+                        # Update the call args with repaired JSON
+                        call.args = repaired
+                except Exception:
+                    pass  # If repair fails, let original validation handle it
+
+            # Call the original method
+            return await _original_call_tool(
+                self,
+                call,
+                allow_partial=allow_partial,
+                wrap_validation_errors=wrap_validation_errors,
+                approved=approved,
+            )
+
+        # Apply the patch
+        ToolManager._call_tool = _patched_call_tool
+
+    except ImportError:
+        pass  # json_repair or pydantic_ai not available
+    except Exception:
+        pass  # Don't crash on patch failure
+
+
 def apply_all_patches() -> None:
     """Apply all pydantic-ai monkey patches.
 
@@ -129,3 +190,4 @@ def apply_all_patches() -> None:
     patch_user_agent()
     patch_message_history_cleaning()
     patch_process_message_history()
+    patch_tool_call_json_repair()

{code_puppy-0.0.367 → code_puppy-0.0.368}/pyproject.toml

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