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

{code_puppy-0.0.366 → code_puppy-0.0.368}/.gitignore

@@ -28,3 +28,5 @@ dummy_path
 main.dist/
 nuitka-crash-report.xml
 *.backup
+main.bin
+

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.366
+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
@@ -24,7 +24,7 @@ Requires-Dist: openai>=1.99.1
 Requires-Dist: pillow>=10.0.0
 Requires-Dist: playwright>=1.40.0
 Requires-Dist: prompt-toolkit>=3.0.52
-Requires-Dist: pydantic-ai-slim[anthropic,openai]==1.25.0
+Requires-Dist: pydantic-ai-slim[anthropic,openai]==1.26.0
 Requires-Dist: pydantic>=2.4.0
 Requires-Dist: pyfiglet>=0.8.post1
 Requires-Dist: python-dotenv>=1.0.0

{code_puppy-0.0.366 → 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.366 → code_puppy-0.0.368}/code_puppy/gemini_model.py

@@ -46,6 +46,58 @@ def generate_tool_call_id() -> str:
     return str(uuid.uuid4())
 
 
+def _flatten_union_to_object_gemini(union_items: list, defs: dict, resolve_fn) -> dict:
+    """Flatten a union of object types into a single object with all properties.
+
+    For discriminated unions like EditFilePayload, we merge all object types
+    into one with all properties (Gemini doesn't support anyOf/oneOf).
+    """
+    import copy as copy_module
+
+    merged_properties = {}
+    has_string_type = False
+
+    for item in union_items:
+        if not isinstance(item, dict):
+            continue
+
+        # Resolve $ref first
+        if "$ref" in item:
+            ref_path = item["$ref"]
+            ref_name = None
+            if ref_path.startswith("#/$defs/"):
+                ref_name = ref_path[8:]
+            elif ref_path.startswith("#/definitions/"):
+                ref_name = ref_path[14:]
+            if ref_name and ref_name in defs:
+                item = copy_module.deepcopy(defs[ref_name])
+            else:
+                continue
+
+        if item.get("type") == "string":
+            has_string_type = True
+            continue
+
+        if item.get("type") == "null":
+            continue
+
+        if item.get("type") == "object" or "properties" in item:
+            props = item.get("properties", {})
+            for prop_name, prop_schema in props.items():
+                if prop_name not in merged_properties:
+                    merged_properties[prop_name] = resolve_fn(
+                        copy_module.deepcopy(prop_schema)
+                    )
+
+    if not merged_properties:
+        return {"type": "string"} if has_string_type else {"type": "object"}
+
+    return {
+        "type": "object",
+        "properties": merged_properties,
+    }
+
+
 def _sanitize_schema_for_gemini(schema: dict) -> dict:
     """Sanitize JSON schema for Gemini API compatibility.
 
@@ -53,7 +105,9 @@ def _sanitize_schema_for_gemini(schema: dict) -> dict:
     - $defs, definitions, $schema, $id
     - additionalProperties
     - $ref (inlined)
-    - anyOf/oneOf/allOf (converted to any_of/one_of/all_of)
+    - anyOf/oneOf/allOf (flattened - Gemini doesn't support unions!)
+      - For unions of objects: merges into single object with all properties
+      - For simple unions (string | null): picks first non-null type
     """
     import copy
 
@@ -69,6 +123,62 @@ def _sanitize_schema_for_gemini(schema: dict) -> dict:
     def resolve_refs(obj):
         """Recursively resolve $ref references and clean schema."""
         if isinstance(obj, dict):
+            # Handle anyOf/oneOf unions
+            for union_key in ["anyOf", "oneOf"]:
+                if union_key in obj:
+                    union = obj[union_key]
+                    if isinstance(union, list):
+                        # Check if this is a complex union of objects
+                        object_count = 0
+                        has_refs = False
+                        for item in union:
+                            if isinstance(item, dict):
+                                if "$ref" in item:
+                                    has_refs = True
+                                    object_count += 1
+                                elif (
+                                    item.get("type") == "object" or "properties" in item
+                                ):
+                                    object_count += 1
+
+                        # If multiple objects or has refs, flatten to single object
+                        if object_count > 1 or has_refs:
+                            flattened = _flatten_union_to_object_gemini(
+                                union, defs, resolve_refs
+                            )
+                            if "description" in obj:
+                                flattened["description"] = obj["description"]
+                            return flattened
+
+                        # Simple union - pick first non-null type
+                        for item in union:
+                            if isinstance(item, dict) and item.get("type") != "null":
+                                result = dict(item)
+                                if "description" in obj:
+                                    result["description"] = obj["description"]
+                                return resolve_refs(result)
+
+            # Handle allOf by merging all schemas
+            if "allOf" in obj:
+                all_of = obj["allOf"]
+                if isinstance(all_of, list):
+                    merged = {}
+                    merged_properties = {}
+                    for item in all_of:
+                        if isinstance(item, dict):
+                            resolved_item = resolve_refs(item)
+                            if "properties" in resolved_item:
+                                merged_properties.update(
+                                    resolved_item.pop("properties")
+                                )
+                            merged.update(resolved_item)
+                    if merged_properties:
+                        merged["properties"] = merged_properties
+                    for k, v in obj.items():
+                        if k != "allOf":
+                            merged[k] = v
+                    return resolve_refs(merged)
+
             # Check for $ref
             if "$ref" in obj:
                 ref_path = obj["$ref"]
@@ -102,19 +212,13 @@ def _sanitize_schema_for_gemini(schema: dict) -> dict:
                     "default",
                     "examples",
                     "const",
+                    "anyOf",  # Skip any remaining union types
+                    "oneOf",
+                    "allOf",
                 ):
                     continue
 
-                # Transform union types for Gemini
-                new_key = key
-                if key == "anyOf":
-                    new_key = "any_of"
-                elif key == "oneOf":
-                    new_key = "one_of"
-                elif key == "allOf":
-                    new_key = "all_of"
-
-                result[new_key] = resolve_refs(value)
+                result[key] = resolve_refs(value)
             return result
         elif isinstance(obj, list):
             return [resolve_refs(item) for item in obj]

{code_puppy-0.0.366 → code_puppy-0.0.368}/code_puppy/plugins/antigravity_oauth/antigravity_model.py

@@ -99,12 +99,11 @@ class AntigravityModel(GeminiModel):
     def _build_tools(self, tools: list) -> list[dict]:
         """Build tool definitions with model-appropriate schema handling.
 
-        Claude and Gemini have different JSON Schema requirements:
-        - Gemini: needs anyOf->any_of conversion, etc.
-        - Claude: needs standard JSON Schema, simplified unions
+        Both Gemini and Claude require simplified union types in function schemas:
+        - Neither supports anyOf/oneOf/allOf in function parameter schemas
+        - We simplify by picking the first non-null type from unions
         """
 
-        is_claude = self._is_claude_model()
         function_declarations = []
 
         for tool in tools:
@@ -113,11 +112,10 @@ class AntigravityModel(GeminiModel):
                 "description": tool.description or "",
             }
             if tool.parameters_json_schema:
-                # Use _inline_refs with appropriate flags for the model type
+                # Simplify union types for all models (Gemini and Claude both need this)
                 func_decl["parameters"] = _inline_refs(
                     tool.parameters_json_schema,
-                    convert_unions=not is_claude,  # Gemini needs any_of conversion
-                    simplify_for_claude=is_claude,  # Claude needs simplified unions
+                    simplify_unions=True,  # Both Gemini and Claude need simplified unions
                 )
             function_declarations.append(func_decl)
 

{code_puppy-0.0.366 → code_puppy-0.0.368}/code_puppy/plugins/antigravity_oauth/transport.py

@@ -23,20 +23,78 @@ from .constants import (
 logger = logging.getLogger(__name__)
 
 
-def _inline_refs(
-    schema: dict, convert_unions: bool = False, simplify_for_claude: bool = False
-) -> dict:
+def _flatten_union_to_object(union_items: list, defs: dict, resolve_fn) -> dict:
+    """Flatten a union of object types into a single object with all properties.
+
+    For discriminated unions like EditFilePayload (ContentPayload | ReplacementsPayload | DeleteSnippetPayload),
+    we merge all object types into one with all properties marked as optional.
+    """
+    merged_properties = {}
+    has_string_type = False
+
+    for item in union_items:
+        if not isinstance(item, dict):
+            continue
+
+        # Resolve $ref first
+        if "$ref" in item:
+            ref_path = item["$ref"]
+            ref_name = None
+            if ref_path.startswith("#/$defs/"):
+                ref_name = ref_path[8:]
+            elif ref_path.startswith("#/definitions/"):
+                ref_name = ref_path[14:]
+            if ref_name and ref_name in defs:
+                item = copy.deepcopy(defs[ref_name])
+            else:
+                continue
+
+        # Check for string type (common fallback)
+        if item.get("type") == "string":
+            has_string_type = True
+            continue
+
+        # Skip null types
+        if item.get("type") == "null":
+            continue
+
+        # Merge properties from object types
+        if item.get("type") == "object" or "properties" in item:
+            props = item.get("properties", {})
+            for prop_name, prop_schema in props.items():
+                if prop_name not in merged_properties:
+                    # Resolve the property schema
+                    merged_properties[prop_name] = resolve_fn(
+                        copy.deepcopy(prop_schema)
+                    )
+
+    if not merged_properties:
+        # No object properties found, return string type as fallback
+        return {"type": "string"} if has_string_type else {"type": "object"}
+
+    # Build merged object - no required fields since any subset is valid
+    result = {
+        "type": "object",
+        "properties": merged_properties,
+    }
+
+    return result
+
+
+def _inline_refs(schema: dict, simplify_unions: bool = False) -> dict:
     """Inline $ref references and transform schema for Antigravity compatibility.
 
     - Inlines $ref references
     - Removes $defs, definitions, $schema, $id
-    - Optionally converts anyOf/oneOf/allOf to any_of/one_of/all_of (only for Gemini)
     - Removes unsupported fields like 'default', 'examples', 'const'
-    - For Claude: simplifies anyOf unions to single types
+    - When simplify_unions=True: flattens anyOf/oneOf unions:
+      - For unions of objects: merges into single object with all properties
+      - For simple unions (string | null): picks first non-null type
+      (required for both Gemini AND Claude - neither supports union types in function schemas!)
 
     Args:
-        convert_unions: If True, convert anyOf->any_of etc. (for Gemini).
-        simplify_for_claude: If True, simplify anyOf to single types.
+        simplify_unions: If True, simplify anyOf/oneOf unions.
+                         Required for Gemini and Claude models.
     """
     if not isinstance(schema, dict):
         return schema
@@ -47,31 +105,73 @@ def _inline_refs(
     # Extract $defs for reference resolution
     defs = schema.pop("$defs", schema.pop("definitions", {}))
 
-    def resolve_refs(
-        obj, convert_unions=convert_unions, simplify_for_claude=simplify_for_claude
-    ):
+    def resolve_refs(obj, simplify_unions=simplify_unions):
         """Recursively resolve $ref references and transform schema."""
         if isinstance(obj, dict):
-            # For Claude: simplify anyOf/oneOf unions to first non-null type
-            if simplify_for_claude:
+            # Handle anyOf/oneOf unions
+            if simplify_unions:
                 for union_key in ["anyOf", "oneOf"]:
                     if union_key in obj:
                         union = obj[union_key]
                         if isinstance(union, list):
-                            # Find first non-null type
+                            # Check if this is a complex union of objects (discriminated union)
+                            # vs a simple nullable type (string | null)
+                            object_count = 0
+                            has_refs = False
+                            for item in union:
+                                if isinstance(item, dict):
+                                    if "$ref" in item:
+                                        has_refs = True
+                                        object_count += 1
+                                    elif (
+                                        item.get("type") == "object"
+                                        or "properties" in item
+                                    ):
+                                        object_count += 1
+
+                            # If multiple objects or has refs, flatten to single object
+                            if object_count > 1 or has_refs:
+                                flattened = _flatten_union_to_object(
+                                    union, defs, resolve_refs
+                                )
+                                # Keep description if present
+                                if "description" in obj:
+                                    flattened["description"] = obj["description"]
+                                return flattened
+
+                            # Simple union - pick first non-null type
                             for item in union:
                                 if (
                                     isinstance(item, dict)
                                     and item.get("type") != "null"
                                 ):
-                                    # Replace the whole object with this type
                                     result = dict(item)
-                                    # Keep description if present
                                     if "description" in obj:
                                         result["description"] = obj["description"]
-                                    return resolve_refs(
-                                        result, convert_unions, simplify_for_claude
-                                    )
+                                    return resolve_refs(result, simplify_unions)
+
+            # Also handle allOf by merging all schemas
+            if simplify_unions and "allOf" in obj:
+                all_of = obj["allOf"]
+                if isinstance(all_of, list):
+                    merged = {}
+                    merged_properties = {}
+                    for item in all_of:
+                        if isinstance(item, dict):
+                            resolved_item = resolve_refs(item, simplify_unions)
+                            # Deep merge properties dicts
+                            if "properties" in resolved_item:
+                                merged_properties.update(
+                                    resolved_item.pop("properties")
+                                )
+                            merged.update(resolved_item)
+                    if merged_properties:
+                        merged["properties"] = merged_properties
+                    # Keep other fields from original object (except allOf)
+                    for k, v in obj.items():
+                        if k != "allOf":
+                            merged[k] = v
+                    return resolve_refs(merged, simplify_unions)
 
             # Check for $ref
             if "$ref" in obj:
@@ -111,34 +211,23 @@ def _inline_refs(
                 ):
                     continue
 
-                # For Claude: skip additionalProperties
-                if simplify_for_claude and key == "additionalProperties":
+                # Skip additionalProperties (not supported by Gemini or Claude)
+                if simplify_unions and key == "additionalProperties":
                     continue
 
-                # Optionally transform union types for Gemini
-                new_key = key
-                if convert_unions:
-                    if key == "anyOf":
-                        new_key = "any_of"
-                    elif key == "oneOf":
-                        new_key = "one_of"
-                    elif key == "allOf":
-                        new_key = "all_of"
-                    elif key == "additionalProperties":
-                        new_key = "additional_properties"
-
-                result[new_key] = resolve_refs(
-                    value, convert_unions, simplify_for_claude
-                )
+                # Skip any remaining union type keys that weren't simplified above
+                # (This shouldn't happen normally, but just in case)
+                if simplify_unions and key in ("anyOf", "oneOf", "allOf"):
+                    continue
+
+                result[key] = resolve_refs(value, simplify_unions)
             return result
         elif isinstance(obj, list):
-            return [
-                resolve_refs(item, convert_unions, simplify_for_claude) for item in obj
-            ]
+            return [resolve_refs(item, simplify_unions) for item in obj]
         else:
             return obj
 
-    return resolve_refs(schema, convert_unions, simplify_for_claude)
+    return resolve_refs(schema, simplify_unions)
 
 
 class UnwrappedResponse(httpx.Response):
@@ -405,15 +494,14 @@ class AntigravityClient(httpx.AsyncClient):
                                         )
 
                                     # Inline $refs and remove $defs from parameters
-                                    # Convert unions (anyOf->any_of) only for Gemini
-                                    # Simplify schemas for Claude (no anyOf, no additionalProperties)
+                                    # Simplify union types (anyOf/oneOf/allOf) for BOTH Gemini and Claude
+                                    # Neither API supports union types in function schemas!
                                     if "parameters" in func_decl:
                                         is_gemini = "gemini" in model.lower()
                                         is_claude = "claude" in model.lower()
                                         func_decl["parameters"] = _inline_refs(
                                             func_decl["parameters"],
-                                            convert_unions=is_gemini,
-                                            simplify_for_claude=is_claude,
+                                            simplify_unions=(is_gemini or is_claude),
                                         )
 
                 # Fix generationConfig for Antigravity compatibility

{code_puppy-0.0.366 → 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.366 → 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.366 → code_puppy-0.0.368}/pyproject.toml

@@ -4,15 +4,14 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.366"
+version = "0.0.368"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.11,<3.14"
 dependencies = [
-    "pydantic-ai-slim[openai,anthropic]==1.25.0",
+    "pydantic-ai-slim[openai,anthropic]==1.26.0",
     "typer>=0.12.0",
-    "mcp>=1.9.4",
-    
+    "mcp>=1.9.4",    
     "httpx[http2]>=0.24.1",
     "requests>=2.28.0",
     "rich>=13.4.2",