code-puppy 0.0.335__tar.gz → 0.0.336__tar.gz

{code_puppy-0.0.335 → code_puppy-0.0.336}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.335
+Version: 0.0.336
 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.335 → code_puppy-0.0.336}/code_puppy/messaging/rich_renderer.py

@@ -348,7 +348,17 @@ class RichConsoleRenderer:
     # =========================================================================
 
     def _render_file_listing(self, msg: FileListingMessage) -> None:
-        """Render a directory listing matching the old Rich-formatted output."""
+        """Render a compact directory listing with directory summaries.
+
+        Instead of listing every file, we group by directory and show:
+        - Directory name
+        - Number of files
+        - Total size
+        - Number of subdirectories
+        """
+        import os
+        from collections import defaultdict
+
         # Header on single line
         rec_flag = f"(recursive={msg.recursive})"
         banner = self._format_banner("directory_listing", "DIRECTORY LISTING")
@@ -357,32 +367,104 @@ class RichConsoleRenderer:
             f"📂 [bold cyan]{msg.directory}[/bold cyan] [dim]{rec_flag}[/dim]\n"
         )
 
-        # Directory header
-        dir_name = msg.directory.rstrip("/").split("/")[-1] or msg.directory
-        self._console.print(f"📁 [bold blue]{dir_name}[/bold blue]")
+        # Build a tree structure: {parent_path: {files: [], dirs: set(), size: int}}
+        # Each key is a directory path, value contains direct children stats
+        dir_stats: dict = defaultdict(
+            lambda: {"files": [], "subdirs": set(), "total_size": 0}
+        )
+
+        # Root directory is represented as ""
+        root_key = ""
 
-        # Build tree structure from flat list
         for entry in msg.files:
-            # Calculate indentation based on depth
-            prefix = ""
-            for d in range(entry.depth + 1):
-                if d == entry.depth:
-                    prefix += "└── "
-                else:
-                    prefix += "    "
+            path = entry.path
+            parent = os.path.dirname(path) if os.path.dirname(path) else root_key
 
             if entry.type == "dir":
-                self._console.print(f"{prefix}📁 [bold blue]{entry.path}/[/bold blue]")
+                # Register this dir as a subdir of its parent
+                dir_stats[parent]["subdirs"].add(path)
+                # Ensure the dir itself exists in stats (even if empty)
+                _ = dir_stats[path]
             else:
-                icon = self._get_file_icon(entry.path)
-                if entry.size > 0:
-                    size_str = f" [dim]({self._format_size(entry.size)})[/dim]"
-                else:
-                    size_str = ""
+                # It's a file - add to parent's stats
+                dir_stats[parent]["files"].append(entry)
+                dir_stats[parent]["total_size"] += entry.size
+
+        def render_dir_tree(dir_path: str, depth: int = 0) -> None:
+            """Recursively render directory with compact summary."""
+            stats = dir_stats.get(
+                dir_path, {"files": [], "subdirs": set(), "total_size": 0}
+            )
+            files = stats["files"]
+            subdirs = sorted(stats["subdirs"])
+
+            # Calculate total size including subdirectories (recursive)
+            def get_recursive_size(d: str) -> int:
+                s = dir_stats.get(d, {"files": [], "subdirs": set(), "total_size": 0})
+                size = s["total_size"]
+                for sub in s["subdirs"]:
+                    size += get_recursive_size(sub)
+                return size
+
+            def get_recursive_file_count(d: str) -> int:
+                s = dir_stats.get(d, {"files": [], "subdirs": set(), "total_size": 0})
+                count = len(s["files"])
+                for sub in s["subdirs"]:
+                    count += get_recursive_file_count(sub)
+                return count
+
+            indent = "    " * depth
+
+            # For root level, just show contents
+            if dir_path == root_key:
+                # Show files at root level (depth 0)
+                for f in sorted(files, key=lambda x: x.path):
+                    icon = self._get_file_icon(f.path)
+                    name = os.path.basename(f.path)
+                    size_str = (
+                        f" [dim]({self._format_size(f.size)})[/dim]"
+                        if f.size > 0
+                        else ""
+                    )
+                    self._console.print(
+                        f"{indent}{icon} [green]{name}[/green]{size_str}"
+                    )
+
+                # Show subdirs at root level
+                for subdir in subdirs:
+                    render_dir_tree(subdir, depth)
+            else:
+                # Show directory with summary
+                dir_name = os.path.basename(dir_path)
+                rec_size = get_recursive_size(dir_path)
+                rec_file_count = get_recursive_file_count(dir_path)
+                subdir_count = len(subdirs)
+
+                # Build summary parts
+                parts = []
+                if rec_file_count > 0:
+                    parts.append(
+                        f"{rec_file_count} file{'s' if rec_file_count != 1 else ''}"
+                    )
+                if subdir_count > 0:
+                    parts.append(
+                        f"{subdir_count} subdir{'s' if subdir_count != 1 else ''}"
+                    )
+                if rec_size > 0:
+                    parts.append(self._format_size(rec_size))
+
+                summary = f" [dim]({', '.join(parts)})[/dim]" if parts else ""
                 self._console.print(
-                    f"{prefix}{icon} [green]{entry.path}[/green]{size_str}"
+                    f"{indent}📁 [bold blue]{dir_name}/[/bold blue]{summary}"
                 )
 
+                # Recursively show subdirectories
+                for subdir in subdirs:
+                    render_dir_tree(subdir, depth + 1)
+
+        # Render the tree starting from root
+        render_dir_tree(root_key, 0)
+
         # Summary
         self._console.print("\n[bold cyan]Summary:[/bold cyan]")
         self._console.print(

{code_puppy-0.0.335 → code_puppy-0.0.336}/code_puppy/plugins/antigravity_oauth/antigravity_model.py

@@ -54,7 +54,15 @@ class AntigravityModel(GoogleModel):
         messages: list[ModelMessage],
         model_request_parameters: ModelRequestParameters,
     ) -> tuple[ContentDict | None, list[dict]]:
-        """Map messages to Google GenAI format, preserving thinking signatures."""
+        """Map messages to Google GenAI format, preserving thinking signatures.
+
+        IMPORTANT: For Gemini with parallel function calls, the API expects:
+        - Model message: [FC1 + signature, FC2, ...] (all function calls together)
+        - User message: [FR1, FR2, ...] (all function responses together)
+
+        If messages are interleaved (FC1, FR1, FC2, FR2), the API returns 400.
+        This method merges consecutive same-role messages to fix this.
+        """
         contents: list[dict] = []
         system_parts: list[PartDict] = []
 
@@ -95,7 +103,12 @@ class AntigravityModel(GoogleModel):
                         assert_never(part)
 
                 if message_parts:
-                    contents.append({"role": "user", "parts": message_parts})
+                    # Merge with previous user message if exists (for parallel function responses)
+                    if contents and contents[-1].get("role") == "user":
+                        contents[-1]["parts"].extend(message_parts)
+                    else:
+                        contents.append({"role": "user", "parts": message_parts})
+
             elif isinstance(m, ModelResponse):
                 # USE CUSTOM HELPER HERE
                 # Pass model name so we can handle Claude vs Gemini signature placement
@@ -103,7 +116,11 @@ class AntigravityModel(GoogleModel):
                     m, self.system, self._model_name
                 )
                 if maybe_content:
-                    contents.append(maybe_content)
+                    # Merge with previous model message if exists (for parallel function calls)
+                    if contents and contents[-1].get("role") == "model":
+                        contents[-1]["parts"].extend(maybe_content["parts"])
+                    else:
+                        contents.append(maybe_content)
             else:
                 assert_never(m)
 
@@ -435,6 +452,13 @@ class AntigravityStreamingResponse(StreamedResponse):
         return self._timestamp_val
 
 
+# Bypass signature for when no real thought signature is available.
+# Gemini API requires EVERY function call to have a thoughtSignature field.
+# When there's no thinking block or no signature was captured, we use this bypass.
+# This specific key is the official bypass token for Gemini 3 Pro.
+BYPASS_THOUGHT_SIGNATURE = "context_engineering_is_the_way_to_go"
+
+
 def _antigravity_content_model_response(
     m: ModelResponse, provider_name: str, model_name: str = ""
 ) -> ContentDict | None:
@@ -443,6 +467,10 @@ def _antigravity_content_model_response(
     Handles different signature protocols:
     - Claude models: signature goes ON the thinking block itself
     - Gemini models: signature goes on the NEXT part (function_call or text) after thinking
+
+    IMPORTANT: For Gemini, EVERY function call MUST have a thoughtSignature field.
+    If no real signature is available (no preceding ThinkingPart, or ThinkingPart
+    had no signature), we use BYPASS_THOUGHT_SIGNATURE as a fallback.
     """
     parts: list[PartDict] = []
 
@@ -451,6 +479,7 @@ def _antigravity_content_model_response(
     is_gemini = "gemini" in model_name.lower()
 
     # For Gemini: save signature from ThinkingPart to attach to next part
+    # Initialize to None - we'll use BYPASS_THOUGHT_SIGNATURE if still None when needed
     pending_signature: str | None = None
 
     for item in m.parts:
@@ -462,16 +491,24 @@ def _antigravity_content_model_response(
             )
             part["function_call"] = function_call
 
-            # For Gemini: attach pending signature to function call
-            if is_gemini and pending_signature:
-                part["thoughtSignature"] = pending_signature
-                pending_signature = None
+            # For Gemini: ALWAYS attach a thoughtSignature to function calls.
+            # Use the real signature if available, otherwise use bypass.
+            # NOTE: Do NOT clear pending_signature here! Multiple tool calls
+            # in a row (e.g., parallel function calls) all need the same
+            # signature from the preceding ThinkingPart.
+            if is_gemini:
+                part["thoughtSignature"] = (
+                    pending_signature
+                    if pending_signature is not None
+                    else BYPASS_THOUGHT_SIGNATURE
+                )
 
         elif isinstance(item, TextPart):
             part["text"] = item.content
 
-            # For Gemini: attach pending signature to text part
-            if is_gemini and pending_signature:
+            # For Gemini: attach pending signature to text part if available
+            # Clear signature after text since text typically ends a response
+            if is_gemini and pending_signature is not None:
                 part["thoughtSignature"] = pending_signature
                 pending_signature = None
 
@@ -490,6 +527,10 @@ def _antigravity_content_model_response(
                     else:
                         # Default: try both (put on thinking block)
                         part["thoughtSignature"] = item.signature
+                elif is_gemini:
+                    # ThinkingPart exists but has no signature - use bypass
+                    # This ensures subsequent tool calls still get a signature
+                    pending_signature = BYPASS_THOUGHT_SIGNATURE
 
         elif isinstance(item, BuiltinToolCallPart):
             # Skip code execution for now

{code_puppy-0.0.335 → code_puppy-0.0.336}/code_puppy/plugins/antigravity_oauth/transport.py

@@ -422,6 +422,8 @@ class AntigravityClient(httpx.AsyncClient):
 
     async def send(self, request: httpx.Request, **kwargs: Any) -> httpx.Response:
         """Override send to intercept at the lowest level with endpoint fallback."""
+        import asyncio
+
         # Transform POST requests to Antigravity format
         if request.method == "POST" and request.content:
             new_content, new_path, new_query, is_claude_thinking = self._wrap_request(
@@ -467,25 +469,21 @@ class AntigravityClient(httpx.AsyncClient):
                     else:
                         new_headers["anthropic-beta"] = interleaved_header
 
-                # Try each endpoint in fallback order
+                # Try each endpoint with rate limit retry logic
                 last_response = None
-
-                # Check for rate limit
-                import asyncio
-
-                # Try endpoints logic...
-                max_retries = 3
-
-                for attempt in range(max_retries):
-                    for endpoint in ANTIGRAVITY_ENDPOINT_FALLBACKS:
-                        # Build URL with current endpoint
-                        new_url = httpx.URL(
-                            scheme="https",
-                            host=endpoint.replace("https://", ""),
-                            path=new_path,
-                            query=new_query.encode() if new_query else b"",
-                        )
-
+                max_rate_limit_retries = 5  # Max retries for 429s per endpoint
+
+                for endpoint in ANTIGRAVITY_ENDPOINT_FALLBACKS:
+                    # Build URL with current endpoint
+                    new_url = httpx.URL(
+                        scheme="https",
+                        host=endpoint.replace("https://", ""),
+                        path=new_path,
+                        query=new_query.encode() if new_query else b"",
+                    )
+
+                    # Retry loop for rate limits on this endpoint
+                    for rate_limit_attempt in range(max_rate_limit_retries):
                         req = httpx.Request(
                             method=request.method,
                             url=new_url,
@@ -498,45 +496,35 @@ class AntigravityClient(httpx.AsyncClient):
 
                         # Handle rate limit (429)
                         if response.status_code == 429:
-                            try:
-                                # Need to read response to get reset time
-                                await response.aread()
-                                error_data = json.loads(response.content)
-
-                                # Extract reset delay from metadata
-                                reset_delay = 2.0  # Default fallback
-                                if isinstance(error_data, dict):
-                                    error_info = error_data.get("error", {})
-                                    if isinstance(error_info, dict):
-                                        details = error_info.get("details", [])
-                                        for detail in details:
-                                            metadata = detail.get("metadata", {})
-                                            if "quotaResetDelay" in metadata:
-                                                delay_str = metadata["quotaResetDelay"]
-                                                if delay_str.endswith("s"):
-                                                    reset_delay = float(delay_str[:-1])
-                                                break
-
-                                # Only retry if delay is reasonable (< 60s)
-                                if reset_delay < 60:
-                                    # Add small buffer
-                                    wait_time = reset_delay + 0.5
+                            wait_time = await self._extract_rate_limit_delay(response)
+
+                            if wait_time is not None and wait_time < 60:
+                                # Add small buffer to wait time
+                                wait_time = wait_time + 0.1
+                                try:
                                     from code_puppy.messaging import emit_warning
 
                                     emit_warning(
-                                        f"⏳ Rate limited on {endpoint}. Waiting {wait_time:.1f}s..."
+                                        f"⏳ Rate limited (attempt {rate_limit_attempt + 1}/{max_rate_limit_retries}). "
+                                        f"Waiting {wait_time:.2f}s..."
                                     )
-                                    await asyncio.sleep(wait_time)
-                                    continue  # Retry same endpoint
-                                else:
-                                    emit_warning(
-                                        f"❌ Rate limit reset too long ({reset_delay}s). Aborting."
+                                except ImportError:
+                                    logger.warning(
+                                        "Rate limited, waiting %.2fs...", wait_time
                                     )
-                                    return UnwrappedResponse(response)
-                            except Exception:
-                                pass  # Failed to parse error, treat as normal error
 
-                        # Retry on 403, 404, 5xx errors
+                                await asyncio.sleep(wait_time)
+                                continue  # Retry same endpoint
+                            else:
+                                # Wait time too long or couldn't parse, try next endpoint
+                                logger.debug(
+                                    "Rate limit wait too long (%.1fs) on %s, trying next endpoint...",
+                                    wait_time or 0,
+                                    endpoint,
+                                )
+                                break  # Break inner loop, try next endpoint
+
+                        # Retry on 403, 404, 5xx errors - try next endpoint
                         if (
                             response.status_code in (403, 404)
                             or response.status_code >= 500
@@ -546,9 +534,9 @@ class AntigravityClient(httpx.AsyncClient):
                                 endpoint,
                                 response.status_code,
                             )
-                            continue
+                            break  # Try next endpoint
 
-                        # Success or non-retriable error
+                        # Success or non-retriable error (4xx except 429)
                         # Wrap response to unwrap Antigravity format
                         if "alt=sse" in new_query:
                             return UnwrappedSSEResponse(response)
@@ -558,15 +546,96 @@ class AntigravityClient(httpx.AsyncClient):
                         await response.aread()
                         return UnwrappedResponse(response)
 
-                # All endpoints failed, return last response
-                if last_response and last_response.status_code == 429:
-                    await last_response.aread()
+                # All endpoints/retries exhausted, return last response
+                if last_response:
+                    # Ensure response is read for proper error handling
+                    if not last_response.is_stream_consumed:
+                        try:
+                            await last_response.aread()
+                        except Exception:
+                            pass
                     return UnwrappedResponse(last_response)
 
-                return last_response
-
         return await super().send(request, **kwargs)
 
+    async def _extract_rate_limit_delay(self, response: httpx.Response) -> float | None:
+        """Extract the retry delay from a 429 rate limit response.
+
+        Parses the Antigravity/Google API error format to find:
+        - retryDelay from RetryInfo (e.g., "0.088325827s")
+        - quotaResetDelay from ErrorInfo metadata (e.g., "88.325827ms")
+
+        Returns the delay in seconds, or None if parsing fails.
+        """
+        try:
+            # Read response body if not already read
+            if not response.is_stream_consumed:
+                await response.aread()
+
+            error_data = json.loads(response.content)
+
+            if not isinstance(error_data, dict):
+                return 2.0  # Default fallback
+
+            error_info = error_data.get("error", {})
+            if not isinstance(error_info, dict):
+                return 2.0
+
+            details = error_info.get("details", [])
+            if not isinstance(details, list):
+                return 2.0
+
+            # Look for RetryInfo first (most precise)
+            for detail in details:
+                if not isinstance(detail, dict):
+                    continue
+
+                detail_type = detail.get("@type", "")
+
+                # Check for RetryInfo (e.g., "0.088325827s")
+                if "RetryInfo" in detail_type:
+                    retry_delay = detail.get("retryDelay", "")
+                    parsed = self._parse_duration(retry_delay)
+                    if parsed is not None:
+                        return parsed
+
+                # Check for ErrorInfo with quotaResetDelay in metadata
+                if "ErrorInfo" in detail_type:
+                    metadata = detail.get("metadata", {})
+                    if isinstance(metadata, dict):
+                        quota_delay = metadata.get("quotaResetDelay", "")
+                        parsed = self._parse_duration(quota_delay)
+                        if parsed is not None:
+                            return parsed
+
+            return 2.0  # Default if no delay found
+
+        except (json.JSONDecodeError, Exception) as e:
+            logger.debug("Failed to parse rate limit response: %s", e)
+            return 2.0  # Default fallback
+
+    def _parse_duration(self, duration_str: str) -> float | None:
+        """Parse a duration string like '0.088s' or '88.325827ms' to seconds."""
+        if not duration_str or not isinstance(duration_str, str):
+            return None
+
+        duration_str = duration_str.strip()
+
+        try:
+            # Handle milliseconds (e.g., "88.325827ms")
+            if duration_str.endswith("ms"):
+                return float(duration_str[:-2]) / 1000.0
+
+            # Handle seconds (e.g., "0.088325827s")
+            if duration_str.endswith("s"):
+                return float(duration_str[:-1])
+
+            # Try parsing as raw number (assume seconds)
+            return float(duration_str)
+
+        except ValueError:
+            return None
+
 
 def create_antigravity_client(
     access_token: str,

{code_puppy-0.0.335 → code_puppy-0.0.336}/pyproject.toml

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